graplix/dist/index.d.cts

Authorization framework for implementing Relation-based Access Control (ReBAC) with the Resolver (Inspired by [GraphQL](https://graphql.org))

import { transformer } from "@openfga/syntax-transformer";
import { Metadata, RelationMetadata, RelationReference, TypeDefinition, Userset } from "@openfga/sdk";

//#region src/BaseEntityTypeMap.d.ts
type BaseEntityTypeMap = {
  [typeName: string]: {
    $type: string;
    [identifier: string]: any;
  };
};
//#endregion
//#region src/utils/Arrayable.d.ts
type Arrayable<T> = T | T[];
//#endregion
//#region src/utils/Nullable.d.ts
type Nullable<T> = T | null | undefined;
//#endregion
//#region src/utils/ValueOf.d.ts
type ValueOf<T extends {}> = T[Extract<keyof T, string>];
//#endregion
//#region src/GraplixResolvers.d.ts
type GraplixResolverDefinition<Context extends {}, EntityTypeMap extends BaseEntityTypeMap, SelectedNodeTypeName extends Extract<keyof EntityTypeMap, string>, TargetNodeTypeName extends Extract<keyof EntityTypeMap, string>> = TargetNodeTypeName extends Extract<keyof EntityTypeMap, string> ? {
  type: TargetNodeTypeName;
  resolve: (entity: EntityTypeMap[SelectedNodeTypeName], context: Context) => Promise<Nullable<EntityTypeMap[TargetNodeTypeName]>> | Promise<Array<EntityTypeMap[TargetNodeTypeName]>>;
} : never;
type GraplixResolvers<Context extends {}, EntityTypeMap extends BaseEntityTypeMap> = { [SelectedNodeTypeName in Extract<keyof EntityTypeMap, string>]: {
  identify: (entity: EntityTypeMap[SelectedNodeTypeName]) => string;
  relations?: {
    [relationName: string]: Arrayable<GraplixResolverDefinition<Context, EntityTypeMap, SelectedNodeTypeName, Extract<keyof EntityTypeMap, string>>>;
  };
} };
//#endregion
//#region src/GraplixSchema.d.ts
type GraplixDirectlyRelatedUserTypes<EntityTypeMap extends BaseEntityTypeMap> = {
  type: Extract<keyof EntityTypeMap, string>;
};
type GraplixComputedSetRelationDefinition = {
  when: string;
  from?: never;
};
type GraplixTupleToUsersetRelationDefinition = {
  when: string;
  from: string;
};
type GraplixUnionRelationDefinition = GraplixComputedSetRelationDefinition | GraplixTupleToUsersetRelationDefinition;
type GraplixSchemaRelationDefinition<EntityTypeMap extends BaseEntityTypeMap> = Arrayable<GraplixDirectlyRelatedUserTypes<EntityTypeMap> | GraplixUnionRelationDefinition>;
type GraplixSchema<EntityTypeMap extends BaseEntityTypeMap> = { [SelectedNodeTypeName in Extract<keyof EntityTypeMap, string>]: {
  [relationName: string]: GraplixSchemaRelationDefinition<EntityTypeMap>;
} };
//#endregion
//#region src/GraplixInput.d.ts
type GraplixInput<Context extends {}, EntityTypeMap extends BaseEntityTypeMap> = {
  schema: GraplixSchema<EntityTypeMap>;
  resolvers: GraplixResolvers<Context, EntityTypeMap>;
};
//#endregion
//#region src/graplix.d.ts
type Graplix<Context extends {}, EntityTypeMap extends BaseEntityTypeMap> = {
  check: (args: {
    user: ValueOf<EntityTypeMap>;
    object: ValueOf<EntityTypeMap>;
    relation: string;
    context: Context;
  }) => Promise<boolean>;
};
declare function graplix<Context extends {}, EntityTypeMap extends BaseEntityTypeMap>(input: GraplixInput<Context, EntityTypeMap>): Graplix<Context, EntityTypeMap>;
//#endregion
//#region src/GraplixIdentifier.d.ts
type GraplixIdentifier<EntityTypeMap extends BaseEntityTypeMap> = (entity: ValueOf<EntityTypeMap>) => {
  type: Extract<keyof EntityTypeMap, string>;
  id: string;
};
//#endregion
//#region src/language/fga.d.ts
declare function fga([data]: TemplateStringsArray): GraplixSchema<BaseEntityTypeMap>;
//#endregion
//#region src/language/parse/parse.d.ts
declare function parse<T extends BaseEntityTypeMap>(input: string): GraplixSchema<T>;
//#endregion
//#region src/language/ValidatedModel.d.ts
type ValidatedModel = {
  schema_version: string;
  type_definitions: Array<ValidatedTypeDefinition>;
};
type ValidatedTypeDefinition = Omit<TypeDefinition, "relations" | "metadata"> & {
  relations?: {
    [key: string]: ValidatedUserset;
  };
  metadata?: ValidatedMetadata;
};
type ValidatedUserset = Omit<Userset, "intersection" | "difference">;
type ValidatedMetadata = Omit<Metadata, "relations"> & {
  relations?: {
    [key: string]: ValidatedRelationMetadata;
  };
};
type ValidatedRelationMetadata = Omit<RelationMetadata, "directly_related_user_types"> & {
  directly_related_user_types?: [Omit<RelationReference, "wildcard">];
};
//#endregion
//#region src/language/validate.d.ts
declare function validate(model: ReturnType<typeof transformer.transformDSLToJSONObject>): asserts model is ValidatedModel;
//#endregion
export { Graplix, GraplixComputedSetRelationDefinition, GraplixDirectlyRelatedUserTypes, GraplixIdentifier, GraplixInput, GraplixResolverDefinition, GraplixResolvers, GraplixSchema, GraplixSchemaRelationDefinition, GraplixTupleToUsersetRelationDefinition, GraplixUnionRelationDefinition, fga, graplix, parse, validate };