@smartive/graphql-magic 3.1.0 → 4.0.0

package/src/migrations/generate.ts

@@ -4,8 +4,8 @@ import { SchemaInspector } from 'knex-schema-inspector';
 import { Column } from 'knex-schema-inspector/dist/types/column';
 import { SchemaInspector as SchemaInspectorType } from 'knex-schema-inspector/dist/types/schema-inspector';
 import lowerFirst from 'lodash/lowerFirst';
-import { EnumModel, isEnumModel, Model, ModelField, Models, RawModels } from '../models';
-import { get, getModels, summonByName, typeToField } from '../utils';
+import { EnumModel, Model, ModelField, Models, RawModels } from '../models';
+import { get, getModels, isEnumModel, summonByName, typeToField } from '../utils';
 import { Value } from '../values';
 
 type Callbacks = (() => void)[];
@@ -130,20 +130,23 @@ export class MigrationGenerator {
         this.createFields(
           model,
           model.fields.filter(
-            ({ name, relation, raw, foreignKey }) =>
-              !raw && !this.columns[model.name].some((col) => col.name === (foreignKey || (relation ? `${name}Id` : name)))
+            ({ name, ...field }) =>
+              field.type !== 'raw' &&
+              !this.columns[model.name].some(
+                (col) => col.name === (field.type === 'relation' ? field.foreignKey || `${name}Id` : name)
+              )
           ),
           up,
           down
         );
 
         // Update fields
-        const existingFields = model.fields.filter(({ name, relation, nonNull }) => {
-          const col = this.columns[model.name].find((col) => col.name === (relation ? `${name}Id` : name));
+        const existingFields = model.fields.filter(({ name, type, nonNull }) => {
+          const col = this.columns[model.name].find((col) => col.name === (type === 'relation' ? `${name}Id` : name));
           if (!col) {
             return false;
           }
-          return !model.nonStrict && !nonNull && !col.is_nullable;
+          return !nonNull && !col.is_nullable;
         });
         this.updateFields(model, existingFields, up, down);
       }
@@ -174,8 +177,8 @@ export class MigrationGenerator {
                           writer.writeLine(`deleted: row.deleted,`);
                         }
 
-                        for (const { name, relation } of model.fields.filter(({ updatable }) => updatable)) {
-                          const col = relation ? `${name}Id` : name;
+                        for (const { name, type } of model.fields.filter(({ updatable }) => updatable)) {
+                          const col = type === 'relation' ? `${name}Id` : name;
 
                           writer.writeLine(`${col}: row.${col},`);
                         }
@@ -194,21 +197,25 @@ export class MigrationGenerator {
         } else {
           const revisionTable = `${model.name}Revision`;
           const missingRevisionFields = model.fields.filter(
-            ({ name, relation, raw, foreignKey, updatable }) =>
-              !raw &&
+            ({ name, updatable, ...field }) =>
+              field.type !== 'raw' &&
               updatable &&
-              !this.columns[revisionTable].some((col) => col.name === (foreignKey || (relation ? `${name}Id` : name)))
+              !this.columns[revisionTable].some(
+                (col) => col.name === (field.type === 'relation' ? field.foreignKey || `${name}Id` : name)
+              )
           );
 
           this.createRevisionFields(model, missingRevisionFields, up, down);
 
           const revisionFieldsToRemove = model.fields.filter(
-            ({ name, updatable, foreignKey, relation, raw, generated }) =>
+            ({ name, updatable, generated, ...field }) =>
               !generated &&
-              !raw &&
+              field.type !== 'raw' &&
               !updatable &&
-              foreignKey !== 'id' &&
-              this.columns[revisionTable].some((col) => col.name === (foreignKey || (relation ? `${name}Id` : name)))
+              !(field.type === 'relation' && field.foreignKey === 'id') &&
+              this.columns[revisionTable].some(
+                (col) => col.name === (field.type === 'relation' ? field.foreignKey || `${name}Id` : name)
+              )
           );
           this.createRevisionFields(model, revisionFieldsToRemove, down, up);
         }
@@ -269,8 +276,8 @@ export class MigrationGenerator {
       for (const field of fields) {
         this.alterTable(model.name, () => {
           this.renameColumn(
-            field.relation ? `${field.oldName}Id` : get(field, 'oldName'),
-            field.relation ? `${field.name}Id` : field.name
+            field.type === 'relation' ? `${field.oldName}Id` : get(field, 'oldName'),
+            field.type === 'relation' ? `${field.name}Id` : field.name
           );
         });
       }
@@ -280,8 +287,8 @@ export class MigrationGenerator {
       for (const field of fields) {
         this.alterTable(model.name, () => {
           this.renameColumn(
-            field.relation ? `${field.name}Id` : field.name,
-            field.relation ? `${field.oldName}Id` : get(field, 'oldName')
+            field.type === 'relation' ? `${field.name}Id` : field.name,
+            field.type === 'relation' ? `${field.oldName}Id` : get(field, 'oldName')
           );
         });
       }
@@ -289,9 +296,8 @@ export class MigrationGenerator {
 
     for (const field of fields) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      summonByName(this.columns[model.name]!, field.relation ? `${field.oldName!}Id` : field.oldName!).name = field.relation
-        ? `${field.name}Id`
-        : field.name;
+      summonByName(this.columns[model.name]!, field.type === 'relation' ? `${field.oldName!}Id` : field.oldName!).name =
+        field.type === 'relation' ? `${field.name}Id` : field.name;
     }
   }
 
@@ -337,8 +343,8 @@ export class MigrationGenerator {
 
     down.push(() => {
       this.alterTable(model.name, () => {
-        for (const { relation, name } of fields) {
-          this.dropColumn(relation ? `${name}Id` : name);
+        for (const { type, name } of fields) {
+          this.dropColumn(type === 'relation' ? `${name}Id` : name);
         }
       });
     });
@@ -363,7 +369,7 @@ export class MigrationGenerator {
           this.column(
             field,
             { alter: true },
-            summonByName(this.columns[model.name], field.relation ? `${field.name}Id` : field.name)
+            summonByName(this.columns[model.name], field.type === 'relation' ? `${field.name}Id` : field.name)
           );
         }
       });
@@ -389,7 +395,7 @@ export class MigrationGenerator {
             this.column(
               field,
               { alter: true },
-              summonByName(this.columns[model.name], field.relation ? `${field.name}Id` : field.name)
+              summonByName(this.columns[model.name], field.type === 'relation' ? `${field.name}Id` : field.name)
             );
           }
         });
@@ -405,9 +411,7 @@ export class MigrationGenerator {
       writer.writeLine(`table.uuid('id').notNullable().primary();`);
       writer.writeLine(`table.uuid('${typeToField(model.name)}Id').notNullable();`);
       writer.write(`table.uuid('createdById')`);
-      if (!model.nonStrict) {
-        writer.write('.notNullable()');
-      }
+      writer.write('.notNullable()');
       writer.write(';').newLine();
       writer.writeLine(`table.timestamp('createdAt').notNullable().defaultTo(knex.fn.now(0));`);
       if (model.deletable) {
@@ -435,8 +439,8 @@ export class MigrationGenerator {
         this.writer
           .write(`await knex('${model.name}Revision').update(`)
           .inlineBlock(() => {
-            for (const { name, relation } of missingRevisionFields) {
-              const col = relation ? `${name}Id` : name;
+            for (const { name, type } of missingRevisionFields) {
+              const col = type === 'relation' ? `${name}Id` : name;
               this.writer
                 .write(
                   `${col}: knex.raw('(select "${col}" from "${model.name}" where "${model.name}".id = "${
@@ -463,7 +467,7 @@ export class MigrationGenerator {
       down.push(() => {
         this.alterTable(revisionTable, () => {
           for (const field of missingRevisionFields) {
-            this.dropColumn(field.relation ? `${field.name}Id` : field.name);
+            this.dropColumn(field.type === 'relation' ? `${field.name}Id` : field.name);
           }
         });
       });
@@ -538,7 +542,7 @@ export class MigrationGenerator {
   }
 
   private column(
-    { name, relation, type, primary, list, ...field }: ModelField,
+    { name, primary, list, ...field }: ModelField,
     { setUnique = true, setNonNull = true, alter = false, foreign = true, setDefault = true } = {},
     toColumn?: Column
   ) {
@@ -574,60 +578,58 @@ export class MigrationGenerator {
       }
       this.writer.write(';').newLine();
     };
-    if (relation) {
-      col(`table.uuid('${name}Id')`);
-      if (foreign && !alter) {
-        this.writer.writeLine(`table.foreign('${name}Id').references('id').inTable('${type}');`);
-      }
-    } else if (this.rawModels.some((m) => m.name === type && m.type === 'enum')) {
-      list
-        ? this.writer.write(`table.specificType('${name}', '"${typeToField(type)}"[]');`)
-        : this.writer
+    switch (field.type) {
+      case 'Boolean':
+        col(`table.boolean('${name}')`);
+        break;
+      case 'Int':
+        col(`table.integer('${name}')`);
+        break;
+      case 'Float':
+        if (field.double) {
+          col(`table.double('${name}')`);
+        } else {
+          col(`table.decimal('${name}', ${get(field, 'precision')}, ${get(field, 'scale')})`);
+        }
+        break;
+      case 'String':
+        if (field.large) {
+          col(`table.text('${name}')`);
+        } else {
+          col(`table.string('${name}', ${field.maxLength})`);
+        }
+        break;
+      case 'DateTime':
+        col(`table.timestamp('${name}')`);
+        break;
+      case 'ID':
+        col(`table.uuid('${name}')`);
+        break;
+      case 'Upload':
+        break;
+      case 'relation':
+        col(`table.uuid('${name}Id')`);
+        if (foreign && !alter) {
+          this.writer.writeLine(`table.foreign('${name}Id').references('id').inTable('${field.typeName}');`);
+        }
+        break;
+      case 'enum':
+        if (list) {
+          this.writer.write(`table.specificType('${name}', '"${typeToField(field.type)}"[]');`);
+        } else {
+          this.writer
             .write(`table.enum('${name}', null as any, `)
             .inlineBlock(() => {
               this.writer.writeLine(`useNative: true,`);
               this.writer.writeLine(`existingType: true,`);
-              this.writer.writeLine(`enumName: '${typeToField(type)}',`);
+              this.writer.writeLine(`enumName: '${typeToField(field.type)}',`);
             })
             .write(')');
-      col();
-    } else {
-      switch (type) {
-        case 'Boolean':
-          col(`table.boolean('${name}')`);
-          break;
-        case 'Int':
-          col(`table.integer('${name}')`);
-          break;
-        case 'Float':
-          if (field.double) {
-            col(`table.double('${name}')`);
-          } else {
-            col(`table.decimal('${name}', ${get(field, 'precision')}, ${get(field, 'scale')})`);
-          }
-          break;
-        case 'String':
-          if (field.large) {
-            col(`table.text('${name}')`);
-          } else {
-            col(`table.string('${name}', ${field.maxLength})`);
-          }
-          break;
-        case 'DateTime':
-          col(`table.timestamp('${name}')`);
-          break;
-        case 'ID':
-          if (field.maxLength) {
-            col(`table.string('${name}', ${get(field, 'maxLength')})`);
-          } else {
-            col(`table.uuid('${name}')`);
-          }
-          break;
-        case 'Upload':
-          break;
-        default:
-          throw new Error(`Unknown field type ${type}`);
-      }
+        }
+        col();
+        break;
+      default:
+        throw new Error(`Unknown field type ${field.type}`);
     }
   }
 }

package/src/models.ts

@@ -1,17 +1,12 @@
+import { DateTime } from 'luxon';
+import { Field } from '.';
 import type { Context } from './context';
 import type { OrderBy } from './resolvers/arguments';
-import type { Directive, Value } from './values';
+import type { Value } from './values';
 
 export type RawModels = RawModel[];
 
-export type RawModel =
-  | ScalarModel
-  | EnumModel
-  | RawEnumModel
-  | InterfaceModel
-  | ObjectModel
-  | RawObjectModel
-  | JsonObjectModel;
+export type RawModel = ScalarModel | EnumModel | RawEnumModel | InterfaceModel | ObjectModel | RawObjectModel;
 
 type BaseModel = {
   name: string;
@@ -28,19 +23,11 @@ export type RawEnumModel = BaseModel & { type: 'raw-enum'; values: string[] };
 export type InterfaceModel = BaseModel & { type: 'interface'; fields: ModelField[] };
 
 export type RawObjectModel = BaseModel & {
-  type: 'raw-object';
-  fields: ModelField[];
-  rawFilters?: { name: string; type: string; list?: boolean; nonNull?: boolean }[];
-};
-
-export type JsonObjectModel = BaseModel & {
-  type: 'json-object';
-  json: true;
-  fields: Pick<ModelField, 'type' | 'name' | 'nonNull'>[];
+  type: 'raw';
+  fields: RawObjectField[];
 };
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- data is derived from the models
-export type Entity = Record<string, any>;
+export type Entity = Record<string, unknown> & { createdAt?: DateTime; deletedAt?: DateTime };
 
 export type Action = 'create' | 'update' | 'delete' | 'restore';
 
@@ -55,13 +42,13 @@ export type MutationHook = (
 export type ObjectModel = BaseModel & {
   type: 'object';
   interfaces?: string[];
-  // createdAt, createdBy, updatedAt, updatedBy can be null
-  nonStrict?: boolean;
   queriable?: boolean;
   listQueriable?: boolean;
-  creatable?: boolean;
-  updatable?: boolean;
-  deletable?: boolean;
+  creatable?: boolean | { createdBy?: Partial<RelationField>; createdAt?: Partial<DateTimeField> };
+  updatable?: boolean | { updatedBy?: Partial<RelationField>; updatedAt?: Partial<DateTimeField> };
+  deletable?:
+    | boolean
+    | { deleted?: Partial<BooleanField>; deletedBy?: Partial<RelationField>; deletedAt?: Partial<DateTimeField> };
   displayField?: string;
   defaultOrderBy?: OrderBy;
   fields: ModelField[];
@@ -71,136 +58,109 @@ export type ObjectModel = BaseModel & {
   oldName?: string;
 };
 
-export type InputObject = {
-  name: string;
-  type: string;
-  nonNull?: boolean;
-};
-
-export const isObjectModel = (model: RawModel): model is ObjectModel => model.type === 'object';
-
-export const isEnumModel = (model: RawModel): model is EnumModel => model.type === 'enum';
-
-export const isRawEnumModel = (model: RawModel): model is RawEnumModel => model.type === 'raw-enum';
-
-export const isScalarModel = (model: RawModel): model is ScalarModel => model.type === 'scalar';
-
-export const isRawObjectModel = (model: RawModel): model is RawObjectModel => model.type === 'raw-object';
-
-export const isJsonObjectModel = (model: RawModel): model is RawObjectModel => model.type === 'json-object';
-
-export const isEnumList = (models: RawModels, field: ModelField) =>
-  field?.list === true && models.find(({ name }) => name === field.type)?.type === 'enum';
-
-export const and =
-  (...predicates: ((field: ModelField) => boolean)[]) =>
-  (field: ModelField) =>
-    predicates.every((predicate) => predicate(field));
-
-export const not = (predicate: (field: ModelField) => boolean) => (field: ModelField) => !predicate(field);
-
-export const isRelation = ({ relation }: ModelField) => !!relation;
-
-export type VisibleRelationsByRole = Record<string, Record<string, string[]>>;
-
-export const isVisibleRelation = (visibleRelationsByRole: VisibleRelationsByRole, modelName: string, role: string) => {
-  const whitelist = visibleRelationsByRole[role]?.[modelName];
-  return ({ name }: Field) => (whitelist ? whitelist.includes(name) : true);
-};
-
-export const isToOneRelation = ({ toOne }: ModelField) => !!toOne;
-
-export const isQueriableField = ({ queriable }: ModelField) => queriable !== false;
-
-export const isRaw = ({ raw }: ModelField) => !!raw;
-
-export const isVisible = ({ hidden }: ModelField) => hidden !== true;
-
-export const isSimpleField = and(not(isRelation), not(isRaw));
-
-export const isUpdatable = ({ updatable }: ModelField) => !!updatable;
-
-export const isCreatable = ({ creatable }: ModelField) => !!creatable;
-
-export const isQueriableBy = (role: string) => (field: ModelField) =>
-  isQueriableField(field) && (!field.queriableBy || field.queriableBy.includes(role));
-
-export const isUpdatableBy = (role: string) => (field: ModelField) =>
-  isUpdatable(field) && (!field.updatableBy || field.updatableBy.includes(role));
-
-export const isCreatableBy = (role: string) => (field: ModelField) =>
-  isCreatable(field) && (!field.creatableBy || field.creatableBy.includes(role));
-
-export const actionableRelations = (model: Model, action: 'create' | 'update' | 'filter') =>
-  model.fields.filter(
-    ({ relation, ...field }) =>
-      relation &&
-      field[`${action === 'filter' ? action : action.slice(0, -1)}able` as 'filterable' | 'creatable' | 'updatable']
-  );
-
-export type Field = {
-  name: string;
-  type: string;
-  default?: Value;
-  list?: boolean;
-  nonNull?: boolean;
-  args?: Field[];
-  directives?: Directive[];
-};
-
-export type ModelField = Field & {
-  primary?: boolean;
-  unique?: boolean;
-  filterable?: boolean;
-  defaultFilter?: Value;
-  searchable?: boolean;
-  possibleValues?: Value[];
-  orderable?: boolean;
-  comparable?: boolean;
-  relation?: boolean;
-  onDelete?: 'cascade' | 'set-null';
-  reverse?: string;
-  toOne?: boolean;
-  foreignKey?: string;
-  queriable?: false;
-  queriableBy?: string[];
-  creatable?: boolean;
-  creatableBy?: string[];
-  updatable?: boolean;
-  updatableBy?: string[];
-  generated?: boolean;
-  raw?: boolean;
-  json?: boolean;
-  dateTimeType?: 'year' | 'date' | 'datetime' | 'year_and_month';
-  stringType?: 'email' | 'url' | 'phone';
-  floatType?: 'currency' | 'percentage';
+type BaseNumberType = {
   unit?: 'million';
-  intType?: 'currency';
   min?: number;
   max?: number;
-  // The tooltip is "hidden" behind an icon in the admin forms
-  tooltip?: string;
-  // The description is always visible below the inputs in the admin forms
-  description?: string;
-  large?: true;
-  maxLength?: number;
-  double?: boolean;
-  precision?: number;
-  scale?: number;
-  defaultValue?: string | number | ReadonlyArray<string> | undefined;
-  endOfDay?: boolean;
-  obfuscate?: true;
-  // If true the field must be filled within forms but can be null in the database
-  required?: boolean;
-  indent?: boolean;
-  // If true the field is hidden in the admin interface
-  hidden?: boolean;
-
-  // temporary fields for the generation of migrations
-  deleted?: true;
-  oldName?: string;
 };
 
+type BaseField = Omit<Field, 'type'>;
+
+type PrimitiveField =
+  | { 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' };
+
+type RawObjectField = BaseField & PrimitiveField;
+
+export type ModelField = BaseField &
+  (
+    | PrimitiveField
+    | { type: 'json'; typeName: string }
+    | { type: 'enum'; typeName: string; possibleValues?: Value[] }
+    | { type: 'raw'; typeName: string }
+    | {
+        type: 'relation';
+        typeName: 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;
+    // The tooltip is "hidden" behind an icon in the admin forms
+    tooltip?: string;
+    defaultValue?: string | number | ReadonlyArray<string> | undefined;
+    // If true the field must be filled within forms but can be null in the database
+    required?: boolean;
+    indent?: boolean;
+    // If true the field is hidden in the admin interface
+    hidden?: boolean;
+
+    // temporary fields for the generation of migrations
+    deleted?: true;
+    oldName?: string;
+  };
+
+export type IDField = Extract<ModelField, { type: 'ID' }>;
+export type BooleanField = Extract<ModelField, { type: 'Boolean' }>;
+export type StringField = Extract<ModelField, { type: 'String' }>;
+export type DateTimeField = Extract<ModelField, { type: 'DateTime' }>;
+export type IntField = Extract<ModelField, { type: 'Int' }>;
+export type FloatField = Extract<ModelField, { type: 'Float' }>;
+export type JsonField = Extract<ModelField, { type: 'json' }>;
+export type EnumField = Extract<ModelField, { type: 'enum' }>;
+export type RawField = Extract<ModelField, { type: 'raw' }>;
+export type RelationField = Extract<ModelField, { type: 'relation' }>;
+
 export type Models = Model[];
 
 export type Model = ObjectModel & {
@@ -212,17 +172,13 @@ export type Model = ObjectModel & {
 };
 
 export type Relation = {
-  field: ModelField;
+  field: RelationField;
   model: Model;
   reverseRelation: ReverseRelation;
 };
 
-export type ReverseRelation = {
-  name: string;
-  type: string;
-  foreignKey: string;
-  toOne: boolean;
+export type ReverseRelation = RelationField & {
   model: Model;
-  field: ModelField;
+  field: RelationField;
   fieldModel: Model;
 };

package/src/permissions/check.ts

@@ -3,7 +3,7 @@ import { FullContext } from '../context';
 import { NotFoundError, PermissionError } from '../errors';
 import { Model } from '../models';
 import { AliasGenerator, hash, ors } from '../resolvers/utils';
-import { get, getModelPlural, summonByName } from '../utils';
+import { get, getModelPlural, isRelation, summonByName } from '../utils';
 import { BasicValue } from '../values';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
 
@@ -139,7 +139,7 @@ export const checkCanWrite = async (
   let linked = false;
 
   for (const field of model.fields
-    .filter(({ relation }) => relation)
+    .filter(isRelation)
     .filter((field) => field.generated || (action === 'CREATE' ? field.creatable : field.updatable))) {
     const foreignKey = field.foreignKey || `${field.name}Id`;
     const foreignId = data[foreignKey] as string;

package/src/permissions/generate.ts

@@ -1,5 +1,5 @@
 import { Models } from '../models';
-import { summonByName } from '../utils';
+import { isRelation, summonByName } from '../utils';
 
 export type PermissionAction = 'READ' | 'CREATE' | 'UPDATE' | 'DELETE' | 'RESTORE' | 'LINK';
 
@@ -114,7 +114,7 @@ const addPermissions = (models: Models, permissions: RolePermissions, links: Per
 
   if (block.RELATIONS) {
     for (const [relation, subBlock] of Object.entries(block.RELATIONS)) {
-      const field = model.fields.find((field) => field.relation && field.name === relation);
+      const field = model.fields.filter(isRelation).find((field) => field.name === relation);
       let link: PermissionLink;
       if (field) {
         link = {

package/src/resolvers/filters.ts

@@ -85,7 +85,7 @@ const applyWhere = (node: WhereNode, where: Where, ops: Ops<Knex.QueryBuilder>,
     const field = summonByName(node.model.fields, key);
     const fullKey = `${node.shortTableAlias}.${key}`;
 
-    if (field.relation) {
+    if (field.type === 'relation') {
       const relation = get(node.model.relationsByName, field.name);
       const tableAlias = `${node.model.name}__W__${key}`;
       const subNode: WhereNode = {