@smartive/graphql-magic 9.1.2 → 10.0.0

package/src/models/mutation-hook.ts

@@ -1,6 +1,6 @@
 import { DateTime } from 'luxon';
-import { Model } from '.';
 import { Context } from '..';
+import { EntityModel } from './models';
 
 export type Entity = Record<string, unknown> & { createdAt?: DateTime; deletedAt?: DateTime };
 
@@ -9,7 +9,7 @@ export type FullEntity = Entity & { id: string };
 export type Action = 'create' | 'update' | 'delete' | 'restore';
 
 export type MutationHook = (
-  model: Model,
+  model: EntityModel,
   action: Action,
   when: 'before' | 'after',
   data: { prev: Entity; input: Entity; normalizedInput: Entity; next: FullEntity },

package/src/models/utils.ts

@@ -1,28 +1,19 @@
 import assert from 'assert';
-import { pluralize } from 'inflection';
-import camelCase from 'lodash/camelCase';
+import { camelCase, startCase } from 'lodash';
 import lodashGet from 'lodash/get';
-import kebabCase from 'lodash/kebabCase';
-import startCase from 'lodash/startCase';
 import {
-  BooleanField,
   CustomField,
-  DateTimeField,
+  EntityField,
   EntityModel,
   EnumField,
   EnumModel,
   InputModel,
+  InterfaceModel,
   Model,
-  ModelField,
-  Models,
   ObjectModel,
   PrimitiveField,
   RawEnumModel,
-  RawModel,
-  RawModels,
-  Relation,
   RelationField,
-  ReverseRelation,
   ScalarModel,
 } from './models';
 
@@ -34,216 +25,90 @@ export const merge = <T>(objects: ({ [name: string]: T } | undefined | false)[]
 // Target -> target
 export const typeToField = (type: string) => type.substr(0, 1).toLowerCase() + type.substr(1);
 
-export const getModelPlural = (model: EntityModel | Model) => model.plural || pluralize(model.name);
+export const getLabel = (s: string) => startCase(camelCase(s));
 
-export const getModelPluralField = (model: Model) => typeToField(getModelPlural(model));
+export const or =
+  <T>(...predicates: ((field: T) => boolean)[]) =>
+  (field: T) =>
+    predicates.some((predicate) => predicate(field));
 
-export const getModelSlug = (model: Model) => kebabCase(getModelPlural(model));
+export const and =
+  <T>(...predicates: ((field: T) => boolean)[]) =>
+  (field: T) =>
+    predicates.every((predicate) => predicate(field));
 
-export const getModelLabelPlural = (model: Model) => getLabel(getModelPlural(model));
+export const not =
+  <T>(predicate: (field: T) => boolean) =>
+  (field: T) =>
+    !predicate(field);
 
-export const getModelLabel = (model: Model) => getLabel(model.name);
+export const isRootModel = (model: EntityModel) => model.root;
 
-export const getLabel = (s: string) => startCase(camelCase(s));
+export const isEntityModel = (model: Model): model is EntityModel => model instanceof EntityModel;
 
-export const isEntityModel = (model: RawModel): model is EntityModel => model.kind === 'entity';
+export const isEnumModel = (model: Model): model is EnumModel => model instanceof EnumModel;
 
-export const isEnumModel = (model: RawModel): model is EnumModel => model.kind === 'enum';
+export const isRawEnumModel = (model: Model): model is RawEnumModel => model instanceof RawEnumModel;
 
-export const isRawEnumModel = (model: RawModel): model is RawEnumModel => model.kind === 'raw-enum';
+export const isScalarModel = (model: Model): model is ScalarModel => model instanceof ScalarModel;
 
-export const isScalarModel = (model: RawModel): model is ScalarModel => model.kind === 'scalar';
+export const isObjectModel = (model: Model): model is ObjectModel => model instanceof ObjectModel;
 
-export const isObjectModel = (model: RawModel): model is ObjectModel => model.kind === 'object';
+export const isInputModel = (model: Model): model is InputModel => model instanceof InputModel;
 
-export const isInputModel = (model: RawModel): model is InputModel => model.kind === 'input';
+export const isInterfaceModel = (model: Model): model is InterfaceModel => model instanceof InterfaceModel;
 
-export const isEnumList = (models: RawModels, field: ModelField) =>
-  field?.list === true && models.find(({ name }) => name === field.kind)?.kind === 'enum';
+export const isUpdatableModel = (model: EntityModel) => model.updatable && model.fields.some(isUpdatableField);
 
-export const and =
-  (...predicates: ((field: ModelField) => boolean)[]) =>
-  (field: ModelField) =>
-    predicates.every((predicate) => predicate(field));
+export const isUpdatableField = (field: EntityField) => !field.inherited && !!field.updatable;
 
-export const not = (predicate: (field: ModelField) => boolean) => (field: ModelField) => !predicate(field);
+export const modelNeedsTable = (model: EntityModel) => model.fields.some((field) => !field.inherited);
 
-export const isPrimitive = (field: ModelField): field is PrimitiveField =>
+export const hasName = (name: string) => (field: EntityField) => field.name == name;
+
+export const isPrimitive = (field: EntityField): field is PrimitiveField =>
   field.kind === undefined || field.kind === 'primitive';
 
-export const isEnum = (field: ModelField): field is EnumField => field.kind === 'enum';
+export const isEnum = (field: EntityField): field is EnumField => field.kind === 'enum';
+
+export const isRelation = (field: EntityField): field is RelationField => field.kind === 'relation';
 
-export const isRelation = (field: ModelField): field is RelationField => field.kind === 'relation';
+export const isInherited = (field: EntityField) => field.inherited;
 
-export const isToOneRelation = (field: ModelField): field is RelationField => isRelation(field) && !!field.toOne;
+export const isInTable = (field: EntityField) => field.name === 'id' || !field.inherited;
 
-export const isQueriableField = ({ queriable }: ModelField) => queriable !== false;
+export const isToOneRelation = (field: EntityField): field is RelationField => isRelation(field) && !!field.toOne;
 
-export const isCustomField = (field: ModelField): field is CustomField => field.kind === 'custom';
+export const isQueriableField = ({ queriable }: EntityField) => queriable !== false;
 
-export const isVisible = ({ hidden }: ModelField) => hidden !== true;
+export const isCustomField = (field: EntityField): field is CustomField => field.kind === 'custom';
+
+export const isVisible = ({ hidden }: EntityField) => hidden !== true;
 
 export const isSimpleField = and(not(isRelation), not(isCustomField));
 
-export const isUpdatable = ({ updatable }: ModelField) => !!updatable;
+export const isUpdatable = ({ updatable }: EntityField) => !!updatable;
 
-export const isCreatable = ({ creatable }: ModelField) => !!creatable;
+export const isCreatable = ({ creatable }: EntityField) => !!creatable;
 
-export const isQueriableBy = (role: string) => (field: ModelField) =>
+export const isQueriableBy = (role: string) => (field: EntityField) =>
   field.queriable !== false &&
   (field.queriable === undefined ||
     field.queriable === true ||
     !field.queriable.roles ||
     field.queriable.roles.includes(role));
 
-export const isUpdatableBy = (role: string) => (field: ModelField) =>
+export const isUpdatableBy = (role: string) => (field: EntityField) =>
   field.updatable && (field.updatable === true || !field.updatable.roles || field.updatable.roles.includes(role));
 
-export const isCreatableBy = (role: string) => (field: ModelField) =>
+export const isCreatableBy = (role: string) => (field: EntityField) =>
   field.creatable && (field.creatable === true || !field.creatable.roles || field.creatable.roles.includes(role));
 
-export const actionableRelations = (model: Model, action: 'create' | 'update' | 'filter') =>
-  model.fields
-    .filter(isRelation)
-    .filter(
-      (field) =>
-        field[`${action === 'filter' ? action : action.slice(0, -1)}able` as 'filterable' | 'creatable' | 'updatable']
-    );
-
-export const getModels = (rawModels: RawModels): Models => {
-  const models: Models = rawModels.filter(isEntityModel).map((model) => {
-    const objectModel: Model = {
-      ...model,
-      fieldsByName: {},
-      relations: [],
-      relationsByName: {},
-      reverseRelations: [],
-      reverseRelationsByName: {},
-      fields: (
-        [
-          { name: 'id', type: 'ID', nonNull: true, unique: true, primary: true, generated: true },
-          ...model.fields,
-          ...(model.creatable
-            ? [
-                {
-                  name: 'createdAt',
-                  type: 'DateTime',
-                  nonNull: true,
-                  orderable: true,
-                  generated: true,
-                  ...(typeof model.creatable === 'object' && model.creatable.createdAt),
-                } satisfies DateTimeField,
-                {
-                  name: 'createdBy',
-                  kind: 'relation',
-                  type: 'User',
-                  nonNull: true,
-                  reverse: `created${getModelPlural(model)}`,
-                  generated: true,
-                  ...(typeof model.creatable === 'object' && model.creatable.createdBy),
-                } satisfies RelationField,
-              ]
-            : []),
-          ...(model.updatable
-            ? [
-                {
-                  name: 'updatedAt',
-                  type: 'DateTime',
-                  nonNull: true,
-                  orderable: true,
-                  generated: true,
-                  ...(typeof model.updatable === 'object' && model.updatable.updatedAt),
-                } satisfies DateTimeField,
-                {
-                  name: 'updatedBy',
-                  kind: 'relation',
-                  type: 'User',
-                  nonNull: true,
-                  reverse: `updated${getModelPlural(model)}`,
-                  generated: true,
-                  ...(typeof model.updatable === 'object' && model.updatable.updatedBy),
-                } satisfies RelationField,
-              ]
-            : []),
-          ...(model.deletable
-            ? [
-                {
-                  name: 'deleted',
-                  type: 'Boolean',
-                  nonNull: true,
-                  defaultValue: false,
-                  filterable: { default: false },
-                  generated: true,
-                  ...(typeof model.deletable === 'object' && model.deletable.deleted),
-                } satisfies BooleanField,
-                {
-                  name: 'deletedAt',
-                  type: 'DateTime',
-                  orderable: true,
-                  generated: true,
-                  ...(typeof model.deletable === 'object' && model.deletable.deletedAt),
-                } satisfies DateTimeField,
-                {
-                  name: 'deletedBy',
-                  kind: 'relation',
-                  type: 'User',
-                  reverse: `deleted${getModelPlural(model)}`,
-                  generated: true,
-                  ...(typeof model.deletable === 'object' && model.deletable.deletedBy),
-                } satisfies RelationField,
-              ]
-            : []),
-        ] satisfies ModelField[]
-      ).map((field: ModelField) => ({
-        ...field,
-        ...(field.kind === 'relation' && {
-          foreignKey: field.foreignKey || `${field.name}Id`,
-        }),
-      })),
-    };
-
-    for (const field of objectModel.fields) {
-      objectModel.fieldsByName[field.name] = field;
-    }
-
-    return objectModel;
-  });
-
-  for (const model of models) {
-    for (const field of model.fields) {
-      if (field.kind !== 'relation') {
-        continue;
-      }
-
-      const fieldModel = summonByName(models, field.type);
-
-      const reverseRelation: ReverseRelation = {
-        kind: 'relation',
-        name: field.reverse || (field.toOne ? typeToField(model.name) : getModelPluralField(model)),
-        foreignKey: get(field, 'foreignKey'),
-        type: model.name,
-        toOne: !!field.toOne,
-        fieldModel,
-        field,
-        model,
-      };
-
-      const relation: Relation = {
-        field,
-        model: fieldModel,
-        reverseRelation,
-      };
-      model.relations.push(relation);
-      model.relationsByName[relation.field.name] = relation;
-
-      fieldModel.reverseRelations.push(reverseRelation);
-
-      fieldModel.reverseRelationsByName[reverseRelation.name] = reverseRelation;
-    }
-  }
-
-  return models;
-};
+export const actionableRelations = (model: EntityModel, action: 'create' | 'update' | 'filter') =>
+  model.relations.filter(
+    (relation) =>
+      relation.field[`${action === 'filter' ? action : action.slice(0, -1)}able` as 'filterable' | 'creatable' | 'updatable']
+  );
 
 export const summonByName = <T extends { name: string }>(array: T[], value: string) => summonByKey(array, 'name', value);
 
@@ -277,8 +142,9 @@ export const it = <T>(object: T | null | undefined): ForSure<T> => {
 export const get = <T, U extends keyof ForSure<T>>(object: T | null | undefined, key: U): ForSure<ForSure<T>[U]> => {
   const value = it(object)[key];
   if (value === undefined || value === null) {
-    console.trace();
-    throw new Error(`Object doesn't have ${String(key)}`);
+    const error = new Error(`Object doesn't have ${String(key)}`);
+    console.warn(error);
+    throw error;
   }
   return value as ForSure<ForSure<T>[U]>;
 };

package/src/permissions/check.ts

@@ -1,8 +1,8 @@
 import { Knex } from 'knex';
 import { FullContext } from '../context';
 import { NotFoundError, PermissionError } from '../errors';
-import { Model } from '../models/models';
-import { get, getModelPlural, isRelation, summonByName } from '../models/utils';
+import { EntityModel } from '../models/models';
+import { get, isRelation } from '../models/utils';
 import { AliasGenerator, hash, ors } from '../resolvers/utils';
 import { BasicValue } from '../values';
 import { PermissionAction, PermissionLink, PermissionStack } from './generate';
@@ -86,11 +86,14 @@ export const applyPermissions = (
  */
 export const getEntityToMutate = async (
   ctx: Pick<FullContext, 'models' | 'permissions' | 'user' | 'knex'>,
-  model: Model,
+  model: EntityModel,
   where: Record<string, BasicValue>,
   action: 'UPDATE' | 'DELETE' | 'RESTORE'
 ) => {
-  const query = ctx.knex(model.name).where(where).first();
+  const query = ctx
+    .knex(model.parent || model.name)
+    .where(where)
+    .first();
   let entity = await query.clone();
 
   if (!entity) {
@@ -113,6 +116,11 @@ export const getEntityToMutate = async (
     throw new PermissionError(action, `this ${model.name}`, 'no available permissions applied');
   }
 
+  if (model.parent) {
+    const subEntity = await ctx.knex(model.name).where({ id: entity.id }).first();
+    Object.assign(entity, subEntity);
+  }
+
   return entity;
 };
 
@@ -121,7 +129,7 @@ export const getEntityToMutate = async (
  */
 export const checkCanWrite = async (
   ctx: Pick<FullContext, 'models' | 'permissions' | 'user' | 'knex'>,
-  model: Model,
+  model: EntityModel,
   data: Record<string, BasicValue>,
   action: 'CREATE' | 'UPDATE'
 ) => {
@@ -131,7 +139,7 @@ export const checkCanWrite = async (
     return;
   }
   if (permissionStack === false) {
-    throw new PermissionError(action, getModelPlural(model), 'no applicable permissions');
+    throw new PermissionError(action, model.plural, 'no applicable permissions');
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- using `select(1 as any)` to instantiate an "empty" query builder
@@ -202,11 +210,11 @@ const permissionLinkQuery = (
     subQuery.where({ [`${alias}.id`]: ctx.user.id });
   }
   if (where) {
-    applyWhere(summonByName(ctx.models, type), subQuery, alias, where, aliases);
+    applyWhere(ctx.models.getModel(type, 'entity'), subQuery, alias, where, aliases);
   }
 
   for (const { type, foreignKey, reverse, where } of links) {
-    const model = summonByName(ctx.models, type);
+    const model = ctx.models.getModel(type, 'entity');
     const subAlias = aliases.getShort();
     if (reverse) {
       // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
@@ -226,7 +234,7 @@ const permissionLinkQuery = (
   subQuery.whereRaw(`"${alias}".id = ?`, id);
 };
 
-const applyWhere = (model: Model, query: Knex.QueryBuilder, alias: string, where: any, aliases: AliasGenerator) => {
+const applyWhere = (model: EntityModel, query: Knex.QueryBuilder, alias: string, where: any, aliases: AliasGenerator) => {
   for (const [key, value] of Object.entries(where)) {
     const relation = model.relationsByName[key];
 
@@ -234,11 +242,11 @@ const applyWhere = (model: Model, query: Knex.QueryBuilder, alias: string, where
       const subAlias = aliases.getShort();
       // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
       query.leftJoin(
-        `${relation.model.name} as ${subAlias}`,
+        `${relation.targetModel.name} as ${subAlias}`,
         `${alias}.${relation.field.foreignKey || `${relation.field.name}Id`}`,
         `${subAlias}.id`
       );
-      applyWhere(relation.model, query, subAlias, value, aliases);
+      applyWhere(relation.targetModel, query, subAlias, value, aliases);
     } else if (Array.isArray(value)) {
       // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
       query.whereIn(`${alias}.${key}`, value);

package/src/permissions/generate.ts

@@ -1,5 +1,5 @@
 import { Models } from '../models/models';
-import { isRelation, summonByName } from '../models/utils';
+import { isRelation } from '../models/utils';
 
 export type PermissionAction = 'READ' | 'CREATE' | 'UPDATE' | 'DELETE' | 'RESTORE' | 'LINK';
 
@@ -96,7 +96,7 @@ export const generatePermissions = (models: Models, config: PermissionsConfig) =
 
 const addPermissions = (models: Models, permissions: RolePermissions, links: PermissionLink[], block: PermissionsBlock) => {
   const { type } = links[links.length - 1];
-  const model = summonByName(models, type);
+  const model = models.getModel(type, 'entity');
 
   for (const action of ACTIONS) {
     if (action === 'READ' || action in block) {
@@ -123,15 +123,15 @@ const addPermissions = (models: Models, permissions: RolePermissions, links: Per
           reverse: true,
         };
       } else {
-        const field = model.reverseRelationsByName[relation];
+        const reverseRelation = model.reverseRelationsByName[relation];
 
-        if (!field) {
+        if (!reverseRelation) {
           throw new Error(`Relation ${relation} in model ${model.name} does not exist.`);
         }
 
         link = {
-          type: field.model.name,
-          foreignKey: field.foreignKey,
+          type: reverseRelation.targetModel.name,
+          foreignKey: reverseRelation.field.foreignKey,
         };
       }
       if (subBlock.WHERE) {

package/src/resolvers/filters.ts

@@ -1,9 +1,9 @@
 import { Knex } from 'knex';
+import { EntityModel, FullContext } from '..';
 import { ForbiddenError, UserInputError } from '../errors';
-import { get, summonByName } from '../models/utils';
 import { OrderBy, Where, normalizeArguments } from './arguments';
-import { FieldResolverNode, WhereNode } from './node';
-import { Joins, Ops, addJoin, apply, ors } from './utils';
+import { FieldResolverNode } from './node';
+import { Joins, Ops, addJoin, apply, getColumn, ors } from './utils';
 
 export const SPECIAL_FILTERS: Record<string, string> = {
   GT: '?? > ?',
@@ -12,6 +12,16 @@ export const SPECIAL_FILTERS: Record<string, string> = {
   LTE: '?? <= ?',
 };
 
+export type WhereNode = {
+  ctx: FullContext;
+
+  rootModel: EntityModel;
+  rootTableAlias: string;
+
+  model: EntityModel;
+  tableAlias: string;
+};
+
 export const applyFilters = (node: FieldResolverNode, query: Knex.QueryBuilder, joins: Joins) => {
   const normalizedArguments = normalizeArguments(node);
   if (!normalizedArguments.orderBy) {
@@ -52,16 +62,20 @@ export const applyFilters = (node: FieldResolverNode, query: Knex.QueryBuilder,
     applyOrderBy(node, orderBy, query);
   }
 
+  if (node.model.parent) {
+    void query.where({
+      [getColumn(node, 'type')]: node.model.name,
+    });
+  }
+
   if (where) {
     const ops: Ops<Knex.QueryBuilder> = [];
     applyWhere(node, where, ops, joins);
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    apply(query, ops);
+    void apply(query, ops);
   }
 
   if (search) {
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    applySearch(node, search, query);
+    void applySearch(node, search, query);
   }
 };
 
@@ -76,37 +90,40 @@ const applyWhere = (node: WhereNode, where: Where, ops: Ops<Knex.QueryBuilder>,
         // Should not happen
         throw new Error(`Invalid filter ${key}.`);
       }
-      ops.push((query) =>
-        query.whereRaw(SPECIAL_FILTERS[filter], [`${node.shortTableAlias}.${actualKey}`, value as string])
-      );
+      ops.push((query) => query.whereRaw(SPECIAL_FILTERS[filter], [getColumn(node, actualKey), value as string]));
       continue;
     }
 
-    const field = summonByName(node.model.fields, key);
-    const fullKey = `${node.shortTableAlias}.${key}`;
+    const field = node.model.getField(key);
 
     if (field.kind === 'relation') {
-      const relation = get(node.model.relationsByName, field.name);
-      const tableAlias = `${node.model.name}__W__${key}`;
+      const relation = node.model.getRelation(field.name);
+      const targetModel = relation.targetModel;
+      const rootModel = targetModel.parentModel || targetModel;
+      const rootTableAlias = `${node.model.name}__W__${key}`;
+      const tableAlias = targetModel === rootModel ? rootTableAlias : `${node.model.name}__WS__${key}`;
       const subNode: WhereNode = {
         ctx: node.ctx,
-        model: relation.model,
-        tableName: relation.model.name,
+
+        rootModel,
+        rootTableAlias,
+
+        model: targetModel,
         tableAlias,
-        shortTableAlias: node.ctx.aliases.getShort(tableAlias),
-        foreignKey: relation.field.foreignKey,
       };
-      addJoin(joins, node.tableAlias, subNode.tableName, subNode.tableAlias, get(subNode, 'foreignKey'), 'id');
+      addJoin(joins, node.tableAlias, subNode.model.name, subNode.tableAlias, relation.field.foreignKey, 'id');
       applyWhere(subNode, value as Where, ops, joins);
       continue;
     }
 
+    const column = getColumn(node, key);
+
     if (Array.isArray(value)) {
       if (field && field.list) {
         ops.push((query) =>
           ors(
             query,
-            value.map((v) => (subQuery) => subQuery.whereRaw('? = ANY(??)', [v, fullKey] as string[]))
+            value.map((v) => (subQuery) => subQuery.whereRaw('? = ANY(??)', [v, column] as string[]))
           )
         );
         continue;
@@ -116,22 +133,22 @@ const applyWhere = (node: WhereNode, where: Where, ops: Ops<Knex.QueryBuilder>,
         if (value.some((v) => v !== null)) {
           ops.push((query) =>
             ors(query, [
-              (subQuery) => subQuery.whereIn(fullKey, value.filter((v) => v !== null) as string[]),
-              (subQuery) => subQuery.whereNull(fullKey),
+              (subQuery) => subQuery.whereIn(column, value.filter((v) => v !== null) as string[]),
+              (subQuery) => subQuery.whereNull(column),
             ])
           );
           continue;
         }
 
-        ops.push((query) => query.whereNull(fullKey));
+        ops.push((query) => query.whereNull(column));
         continue;
       }
 
-      ops.push((query) => query.whereIn(fullKey, value as string[]));
+      ops.push((query) => query.whereIn(column, value as string[]));
       continue;
     }
 
-    ops.push((query) => query.where({ [fullKey]: value }));
+    ops.push((query) => query.where({ [column]: value }));
   }
 };
 
@@ -143,7 +160,7 @@ const applySearch = (node: FieldResolverNode, search: string, query: Knex.QueryB
       .map(
         ({ name }) =>
           (query) =>
-            query.whereILike(`${node.shortTableAlias}.${name}`, `%${search}%`)
+            query.whereILike(getColumn(node, name), `%${search}%`)
       )
   );
 
@@ -157,7 +174,6 @@ const applyOrderBy = (node: FieldResolverNode, orderBy: OrderBy, query: Knex.Que
     const value = vals[key];
 
     // Simple field
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here
-    query.orderBy(`${node.shortTableAlias}.${key}`, value);
+    void query.orderBy(getColumn(node, key), value);
   }
 };

package/src/resolvers/index.ts

@@ -6,4 +6,5 @@ export * from './mutations';
 export * from './node';
 export * from './resolver';
 export * from './resolvers';
+export * from './selects';
 export * from './utils';