@smartive/graphql-magic 9.1.2 → 10.0.0

package/dist/esm/models/model-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-definitions.js","sourceRoot":"","sources":["../../../src/models/model-definitions.ts"],"names":[],"mappings":""}

package/dist/esm/models/models.d.ts

@@ -1,204 +1,158 @@
-import { Field } from '..';
-import type { OrderBy } from '../resolvers/arguments';
-import type { Value } from '../values';
-export type RawModels = RawModel[];
-export type RawModel = {
+import { CustomFieldDefinition, EnumFieldDefinition, FloatFieldDefinition, IDFieldDefinition, InputModelDefinition, IntFieldDefinition, InterfaceModelDefinition, JsonFieldDefinition, ObjectModelDefinition, OrderBy, PrimitiveFieldDefinition, RawEnumModelDefinition, StringFieldDefinition, UploadFieldDefinition } from '..';
+import { BooleanFieldDefinition, DateTimeFieldDefinition, EntityFieldDefinition, EntityModelDefinition, EnumModelDefinition, ModelDefinition, ModelDefinitions, ObjectFieldDefinition, RelationFieldDefinition } from './model-definitions';
+export type ObjectField = ObjectFieldDefinition;
+export type EntityField = EntityFieldDefinition;
+export type PrimitiveField = PrimitiveFieldDefinition;
+export type IDField = IDFieldDefinition;
+export type BooleanField = BooleanFieldDefinition;
+export type StringField = StringFieldDefinition;
+export type DateTimeField = DateTimeFieldDefinition;
+export type IntField = IntFieldDefinition;
+export type FloatField = FloatFieldDefinition;
+export type UploadField = UploadFieldDefinition;
+export type JsonField = JsonFieldDefinition;
+export type EnumField = EnumFieldDefinition;
+export type CustomField = CustomFieldDefinition;
+export type RelationField = Omit<RelationFieldDefinition, 'foreignKey'> & {
+    foreignKey: string;
+};
+export declare class Models {
+    models: Model[];
+    private modelsByName;
+    scalars: ScalarModel[];
+    rawEnums: RawEnumModel[];
+    enums: EnumModel[];
+    inputs: InputModel[];
+    interfaces: InterfaceModel[];
+    objects: ObjectModel[];
+    entities: EntityModel[];
+    definitions: ModelDefinitions;
+    constructor(definitions: ModelDefinitions);
+    getModel<K extends keyof ModelKindToClassMapping>(name: string, kind?: K): ModelKindToClassMapping[K];
+}
+export declare abstract class Model {
+    models: Models;
     name: string;
-    plural?: string;
-    description?: string;
-} & ({
+    plural: string;
+    description: string;
+    constructor(models: Models, definition: ModelDefinition);
+}
+export declare class ScalarModel extends Model {
     kind: 'scalar';
-} | {
+}
+export declare class EnumModel extends Model {
     kind: 'enum';
     values: string[];
     deleted?: true;
-} | {
+    constructor(models: Models, definition: EnumModelDefinition);
+}
+export declare class RawEnumModel extends Model {
     kind: 'raw-enum';
     values: string[];
-} | {
+    constructor(models: Models, definition: RawEnumModelDefinition);
+}
+export declare class InterfaceModel extends Model {
     kind: 'interface';
-    fields: ModelField[];
-} | {
-    kind: 'input';
+    fields: EntityField[];
+    constructor(models: Models, definition: InterfaceModelDefinition);
+}
+export declare class InputModel extends Model {
+    kind: 'model';
     fields: ObjectField[];
-} | {
+    constructor(models: Models, definition: InputModelDefinition);
+}
+export declare class ObjectModel extends Model {
     kind: 'object';
     fields: ObjectField[];
-} | {
+    constructor(models: Models, definition: ObjectModelDefinition);
+}
+export declare class EntityModel extends Model {
     kind: 'entity';
+    root?: boolean;
+    parent?: string;
     interfaces?: string[];
     queriable?: boolean;
     listQueriable?: boolean;
     creatable?: boolean | {
-        createdBy?: Partial<RelationField>;
-        createdAt?: Partial<DateTimeField>;
+        createdBy?: Partial<RelationFieldDefinition>;
+        createdAt?: Partial<DateTimeFieldDefinition>;
     };
     updatable?: boolean | {
-        updatedBy?: Partial<RelationField>;
-        updatedAt?: Partial<DateTimeField>;
+        updatedBy?: Partial<RelationFieldDefinition>;
+        updatedAt?: Partial<DateTimeFieldDefinition>;
     };
     deletable?: boolean | {
-        deleted?: Partial<BooleanField>;
-        deletedBy?: Partial<RelationField>;
-        deletedAt?: Partial<DateTimeField>;
+        deleted?: Partial<BooleanFieldDefinition>;
+        deletedBy?: Partial<RelationFieldDefinition>;
+        deletedAt?: Partial<DateTimeFieldDefinition>;
     };
     displayField?: string;
     defaultOrderBy?: OrderBy;
-    fields: ModelField[];
+    fields: EntityField[];
     deleted?: true;
     oldName?: string;
-});
-export type ScalarModel = Extract<RawModel, {
-    kind: 'scalar';
-}>;
-export type EnumModel = Extract<RawModel, {
-    kind: 'enum';
-}>;
-export type RawEnumModel = Extract<RawModel, {
-    kind: 'raw-enum';
-}>;
-export type InterfaceModel = Extract<RawModel, {
-    kind: 'interface';
-}>;
-export type ObjectModel = Extract<RawModel, {
-    kind: 'object';
-}>;
-export type InputModel = Extract<RawModel, {
-    kind: 'input';
-}>;
-export type EntityModel = Extract<RawModel, {
-    kind: 'entity';
-}>;
-type BaseNumberType = {
-    unit?: 'million';
-    min?: number;
-    max?: number;
+    fieldsByName: Record<string, EntityField>;
+    fieldsByColumnName: Record<string, EntityField>;
+    private _relations;
+    private _relationsByName;
+    private _reverseRelations;
+    private _reverseRelationsByName;
+    private _manyToManyRelations;
+    private _manyToManyRelationsByName;
+    pluralField: string;
+    slug: string;
+    labelPlural: string;
+    label: string;
+    private _parentModel;
+    constructor(models: Models, definition: EntityModelDefinition);
+    getField(name: string): EntityFieldDefinition;
+    get relations(): NormalRelation[];
+    get relationsByName(): Record<string, NormalRelation>;
+    getRelation(name: string): NormalRelation;
+    get reverseRelations(): ReverseRelation[];
+    get reverseRelationsByName(): Record<string, ReverseRelation>;
+    getReverseRelation(name: string): ReverseRelation;
+    get manyToManyRelations(): ManyToManyRelation[];
+    get manyToManyRelationsByName(): Record<string, ManyToManyRelation>;
+    getManyToManyRelation(name: string): ManyToManyRelation;
+    get parentModel(): EntityModel;
+    get rootModel(): EntityModel;
+}
+declare const MODEL_KIND_TO_CLASS_MAPPING: {
+    entity: typeof EntityModel;
+    enum: typeof EnumModel;
+    input: typeof InputModel;
+    interface: typeof InterfaceModel;
+    object: typeof ObjectModel;
+    'raw-enum': typeof RawEnumModel;
+    scalar: typeof ScalarModel;
 };
-type FieldBase = Omit<Field, 'type'>;
-type FieldBase2 = ({
-    kind?: 'primitive' | undefined;
-} & ({
-    type: 'ID';
-} | {
-    type: 'Boolean';
-} | {
-    type: 'String';
-    stringType?: 'email' | 'url' | 'phone';
-    large?: true;
-    maxLength?: number;
-} | {
-    type: 'DateTime';
-    dateTimeType?: 'year' | 'date' | 'datetime' | 'year_and_month';
-    endOfDay?: boolean;
-} | ({
-    type: 'Int';
-    intType?: 'currency';
-} & BaseNumberType) | ({
-    type: 'Float';
-    floatType?: 'currency' | 'percentage';
-    double?: boolean;
-    precision?: number;
-    scale?: number;
-} & BaseNumberType) | {
-    type: 'Upload';
-})) | {
-    kind: 'enum';
-    type: string;
-    possibleValues?: Value[];
-} | {
-    kind: 'custom';
-    type: string;
+type ModelKindToClassMapping = {
+    [K in keyof typeof MODEL_KIND_TO_CLASS_MAPPING]: InstanceType<(typeof MODEL_KIND_TO_CLASS_MAPPING)[K]>;
 };
-export type ObjectField = FieldBase & FieldBase2;
-export type ModelField = FieldBase & (FieldBase2 | {
-    kind: 'json';
-    type: string;
-} | {
-    kind: 'relation';
-    type: string;
-    toOne?: boolean;
-    reverse?: string;
-    foreignKey?: string;
-    onDelete?: 'cascade' | 'set-null';
-}) & {
-    primary?: boolean;
-    unique?: boolean;
-    filterable?: boolean | {
-        default?: Value;
-    };
-    searchable?: boolean;
-    orderable?: boolean;
-    comparable?: boolean;
-    queriable?: boolean | {
-        roles?: string[];
-    };
-    creatable?: boolean | {
-        roles?: string[];
-    };
-    updatable?: boolean | {
-        roles?: string[];
-    };
-    generated?: boolean;
-    tooltip?: string;
-    required?: boolean;
-    indent?: boolean;
-    hidden?: boolean;
-    deleted?: true;
-    oldName?: string;
-    meta?: Record<string, unknown>;
-};
-export type PrimitiveField = Extract<ModelField, {
-    kind?: 'primitive' | undefined;
-}>;
-export type IDField = Extract<PrimitiveField, {
-    type: 'ID';
-}>;
-export type BooleanField = Extract<PrimitiveField, {
-    type: 'Boolean';
-}>;
-export type StringField = Extract<PrimitiveField, {
-    type: 'String';
-}>;
-export type DateTimeField = Extract<PrimitiveField, {
-    type: 'DateTime';
-}>;
-export type IntField = Extract<PrimitiveField, {
-    type: 'Int';
-}>;
-export type FloatField = Extract<PrimitiveField, {
-    type: 'Float';
-}>;
-export type UploadField = Extract<PrimitiveField, {
-    type: 'Upload';
-}>;
-export type JsonField = Extract<ModelField, {
-    kind: 'json';
-}>;
-export type EnumField = Extract<ModelField, {
-    kind: 'enum';
-}>;
-export type CustomField = Extract<ModelField, {
-    kind: 'custom';
-}>;
-export type RelationField = Extract<ModelField, {
-    kind: 'relation';
-}>;
-export type Models = Model[];
-export type Model = EntityModel & {
-    fieldsByName: Record<string, ModelField>;
-    relations: Relation[];
-    relationsByName: Record<string, Relation>;
-    reverseRelations: ReverseRelation[];
-    reverseRelationsByName: Record<string, ReverseRelation>;
-};
-export type Relation = {
+export declare abstract class Relation {
+    name: string;
+    sourceModel: EntityModel;
     field: RelationField;
-    model: Model;
-    reverseRelation: ReverseRelation;
-};
-export type ReverseRelation = RelationField & {
-    model: Model;
+    targetModel: EntityModel;
+    constructor(name: string, sourceModel: EntityModel, field: RelationField, targetModel: EntityModel);
+}
+export declare class NormalRelation extends Relation {
     field: RelationField;
-    fieldModel: Model;
-};
+    reverse: ReverseRelation;
+    constructor(sourceModel: EntityModel, field: RelationField, targetModel: EntityModel);
+}
+export declare class ReverseRelation extends Relation {
+    reverse: NormalRelation;
+    constructor(reverse: NormalRelation);
+}
+export declare class ManyToManyRelation {
+    name: string;
+    sourceModel: EntityModel;
+    relationFromSource: ReverseRelation;
+    relationModel: EntityModel;
+    relationToTarget: NormalRelation;
+    targetModel: EntityModel;
+    constructor(relationFromSource: ReverseRelation, relationToTarget: NormalRelation);
+}
 export {};