@smartive/graphql-magic 1.0.1

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@smartive/graphql-magic",
+  "version": "1.0.1",
+  "description": "",
+  "source": "src/index.ts",
+  "type": "module",
+  "module": "dist/esm/index.js",
+  "main": "dist/cjs/index.cjs",
+  "types": "dist/esm/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffecs": false,
+  "scripts": {
+    "bootstrap": "npm ci && npm run generate",
+    "generate": "npm run generate:index-files",
+    "generate:index-files": "cti create ./src --excludes types --withoutbackup",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "test": "npm run lint && npm run test:unit && npm run build",
+    "test:unit": "jest tests/unit --no-cache --no-watchman",
+    "clean": "del-cli dist/**",
+    "prebuild": "npm run clean",
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc",
+    "build:cjs": "esbuild src/index.ts --bundle --platform=node --outdir=dist/cjs --out-extension:.js=.cjs --format=cjs --packages=external",
+    "publish": "semantic-release"
+  },
+  "overrides": {
+    "graphql": "$graphql",
+    "rollup": "3.26.2"
+  },
+  "browserslist": "> 0.25%, not dead",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@apollo/server": "^4.0.0",
+    "code-block-writer": "^12.0.0",
+    "graphql": "^15.8.0",
+    "inflection": "^2.0.1",
+    "knex": "^2.4.2",
+    "knex-schema-inspector": "^3.0.1",
+    "lodash": "^4.17.21",
+    "luxon": "^3.3.0",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@smartive/eslint-config": "3.2.0",
+    "@smartive/prettier-config": "3.1.2",
+    "@types/jest": "29.5.3",
+    "@types/lodash": "4.14.195",
+    "@types/luxon": "3.3.0",
+    "@types/uuid": "9.0.2",
+    "create-ts-index": "1.14.0",
+    "del-cli": "5.0.0",
+    "esbuild": "0.18.11",
+    "eslint": "8.44.0",
+    "jest": "29.6.1",
+    "mock-knex": "0.4.12",
+    "prettier": "2.8.8",
+    "ts-jest": "29.1.1",
+    "ts-node": "10.9.1",
+    "typescript": "5.1.6"
+  }
+}

package/renovate.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["gitlab>smartive/internal-it/renovate"],
+  "packageRules": [
+    {
+      "packagePatterns": ["^@types[/]"],
+      "groupName": "TypeScript typings"
+    },
+    {
+      "packagePatterns": ["^eslint*", "prettier"],
+      "groupName": "Linting"
+    },
+    {
+      "updateTypes": ["major"],
+      "automerge": false,
+      "gitLabAutomerge": false,
+      "labels": ["dependencies", "dependencies-major"]
+    },
+    {
+      "packagePatterns": ["*"],
+      "rangeStrategy": "replace"
+    },
+    {
+      "depTypeList": ["devDependencies"],
+      "rangeStrategy": "pin"
+    },
+    {
+      "depTypeList": ["peerDependencies"],
+      "rangeStrategy": "widen"
+    }
+  ]
+}

package/src/client/gql.ts

@@ -0,0 +1,7 @@
+// This tag does nothing (just generates a string) - it is here for the tooling (syntax highlighting, formatting and type generation)
+export const gql = (chunks: TemplateStringsArray, ...variables: (string | number | boolean)[]): string => {
+  return chunks.reduce(
+    (accumulator, chunk, index) => `${accumulator}${chunk}${index in variables ? variables[index] : ''}`,
+    ''
+  );
+};

package/src/client/index.ts

@@ -0,0 +1,4 @@
+// created from 'create-ts-index'
+
+export * from './gql';
+export * from './queries';

package/src/client/queries.ts

@@ -0,0 +1,251 @@
+import upperFirst from 'lodash/upperFirst';
+import {
+  actionableRelations,
+  and,
+  isQueriableBy,
+  isRelation,
+  isSimpleField,
+  isToOneRelation,
+  isUpdatableBy,
+  isVisibleRelation,
+  Model,
+  Models,
+  not,
+  Relation,
+  ReverseRelation,
+  VisibleRelationsByRole,
+} from '../models';
+import { getModelPlural, getModelPluralField, summonByName, typeToField } from '../utils';
+
+export const getUpdateEntityQuery = (
+  model: Model,
+  role: any,
+  fields?: string[] | undefined,
+  additionalFields = ''
+) => `query Update${model.name}Fields ($id: ID!) {
+  data: ${typeToField(model.name)}(where: { id: $id }) {
+    id
+    ${model.fields
+      .filter(({ name }) => !fields || fields.includes(name))
+      .filter(not(isRelation))
+      .filter(isUpdatableBy(role))
+      .map(({ name }) => name)
+      .join(' ')}
+    ${actionableRelations(model, 'update')
+      .filter(({ name }) => !fields || fields.includes(name))
+      .map(({ name }) => `${name} { id }`)}
+    ${additionalFields}
+  }
+}`;
+
+export const getEditEntityRelationsQuery = (
+  models: Models,
+  model: Model,
+  action: 'create' | 'update' | 'filter',
+  fields?: string[],
+  ignoreFields?: string[],
+  additionalFields: Record<string, string> = {}
+) => {
+  const relations = actionableRelations(model, action).filter(
+    ({ name }) => (!fields || fields.includes(name)) && (!ignoreFields || !ignoreFields.includes(name))
+  );
+
+  return (
+    !!relations.length &&
+    `query ${upperFirst(action)}${model.name}Relations {
+      ${relations
+        .map(({ name, type }) => {
+          const model = summonByName(models, type);
+
+          return `${name}: ${getModelPluralField(model)} {
+            id
+            display: ${model.displayField || ''}
+            ${additionalFields[name] || ''}
+          }`;
+        })
+        .join(' ')}
+    }`
+  );
+};
+
+export const getManyToManyRelations = (model: Model, fields?: string[], ignoreFields?: string[]) => {
+  const manyToManyRelations: [ReverseRelation, Relation][] = [];
+  for (const field of model.reverseRelations) {
+    if ((fields && !fields.includes(field.name)) || (ignoreFields && ignoreFields.includes(field.name))) {
+      continue;
+    }
+
+    const relation = field.model.relations.find(
+      (relation) => !relation.field.generated && relation.field.name !== field.field.name
+    );
+    if (!relation) {
+      continue;
+    }
+
+    const inapplicableFields = field.model.fields.filter(
+      (otherField) => !otherField.generated && ![field.field.name, relation.field.name].includes(otherField.name)
+    );
+    if (inapplicableFields.length) {
+      continue;
+    }
+
+    manyToManyRelations.push([field, relation]);
+  }
+  return manyToManyRelations;
+};
+
+export const getManyToManyRelation = (model: Model, name: string) => getManyToManyRelations(model, [name])[0];
+
+export const getManyToManyRelationsQuery = (
+  model: Model,
+  action: 'create' | 'update',
+  manyToManyRelations: [ReverseRelation, Relation][]
+) =>
+  !!manyToManyRelations.length &&
+  (action === 'update'
+    ? `query Update${model.name}ManyToManyRelations($id: ID!) {
+            ${typeToField(model.name)}(where: { id: $id }) {
+              ${manyToManyRelations
+                .map(([reverseRelation, { field }]) => {
+                  return `${reverseRelation.name} {
+                    id
+                    ${field.name} {
+                      id
+                    }
+                  }`;
+                })
+                .join(' ')}
+            }
+            ${manyToManyRelations
+              .map(([reverseRelation, { model }]) => {
+                return `${reverseRelation.name}: ${getModelPluralField(model)} {
+                  id
+                  ${model.displayField || ''}
+                }`;
+              })
+              .join(' ')}
+          }`
+    : `query Create${model.name}ManyToManyRelations {
+            ${manyToManyRelations
+              .map(([reverseRelation, { model }]) => {
+                return `${reverseRelation.name}: ${getModelPluralField(model)} {
+                  id
+                  ${model.displayField || ''}
+                }`;
+              })
+              .join(' ')}
+          }`);
+
+export type MutationQuery = {
+  mutated: {
+    id: string;
+  };
+};
+
+export const getMutationQuery = (model: Model, action: 'create' | 'update' | 'delete') =>
+  action === 'create'
+    ? `
+        mutation Create${model.name} ($data: Create${model.name}!) {
+          mutated: create${model.name}(data: $data) {
+            id
+          }
+        }
+        `
+    : action === 'update'
+    ? `
+        mutation Update${model.name} ($id: ID!, $data: Update${model.name}!) {
+          mutated: update${model.name}(where: { id: $id } data: $data) {
+            id
+          }
+        }
+        `
+    : `
+        mutation Delete${model.name} ($id: ID!) {
+          mutated: delete${model.name}(where: { id: $id }) {
+            id
+          }
+        }
+        `;
+
+export const displayField = (model: Model) => `
+${model.displayField ? `display: ${model.displayField}` : ''}
+`;
+
+export const getEntityListQuery = (
+  model: Model,
+  role: string,
+  additionalFields = '',
+  root?: {
+    model: Model;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    entity: any;
+    reverseRelationName: string;
+  }
+) => `query ${getModelPlural(model)}List(
+  ${root ? '$id: ID!,' : ''}
+  $limit: Int!,
+  $where: ${model.name}Where!,
+  ${model.fields.some(({ searchable }) => searchable) ? '$search: String,' : ''}
+) {
+  ${root ? `root: ${typeToField(root.model.name)}(where: { id: $id }) {` : ''}
+    data: ${root ? root.reverseRelationName : getModelPluralField(model)}(limit: $limit, where: $where, ${
+  model.fields.some(({ searchable }) => searchable) ? ', search: $search' : ''
+}) {
+      ${displayField(model)}
+      ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
+      ${additionalFields}
+    }
+  ${root ? '}' : ''}
+}`;
+
+export const getEntityQuery = (
+  models: Models,
+  model: Model,
+  role: string,
+  visibleRelationsByRole: VisibleRelationsByRole,
+  typesWithSubRelations: string[]
+) => `query Admin${model.name} ($id: ID!) {
+  data: ${typeToField(model.name)}(where: { id: $id }) {
+    ${displayField(model)}
+    ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
+    ${queryRelations(
+      models,
+      model.fields.filter(and(isRelation, isVisibleRelation(visibleRelationsByRole, model.name, role))),
+      role,
+      typesWithSubRelations
+    )}
+    ${queryRelations(
+      models,
+      model.reverseRelations.filter(and(isToOneRelation, isVisibleRelation(visibleRelationsByRole, model.name, role))),
+      role,
+      typesWithSubRelations
+    )}
+  }
+}`;
+
+export const getFindEntityQuery = (model: Model, role: string) => `query Find${model.name}($where: ${
+  model.name
+}Where!, $orderBy: [${model.name}OrderBy!]) {
+  data: ${getModelPluralField(model)}(limit: 1, where: $where, orderBy: $orderBy) {
+    ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
+  }
+}`;
+
+export const queryRelations = (
+  models: Models,
+  relations: { name: string; type: string }[],
+  role: string,
+  typesWithSubRelations: string[]
+) =>
+  relations
+    .map(({ name, type }): string => {
+      const relatedModel = summonByName(models, type);
+      const subRelations = typesWithSubRelations.includes(type) ? relatedModel.fields.filter(isRelation) : [];
+
+      return `${name} {
+          id
+          ${displayField(relatedModel)}
+          ${subRelations.length > 0 ? queryRelations(models, subRelations, role, typesWithSubRelations) : ''}
+        }`;
+    })
+    .join('\n');

package/src/context.ts

@@ -0,0 +1,27 @@
+import { DocumentNode, GraphQLResolveInfo } from 'graphql';
+import { IncomingMessage } from 'http';
+import { Knex } from 'knex';
+import { DateTime } from 'luxon';
+import { Entity, Models, MutationHook, RawModels } from './models';
+import { Permissions } from './permissions/generate';
+import { AliasGenerator } from './resolvers/utils';
+
+// Minimal user structure required by graphql-magic
+export type User = { id: string; role: string };
+
+export type Context = {
+  req: IncomingMessage;
+  now: DateTime;
+  knex: Knex;
+  document: DocumentNode;
+  locale: string;
+  locales: string[];
+  user: User;
+  rawModels: RawModels;
+  models: Models;
+  permissions: Permissions;
+  mutationHook?: MutationHook;
+  handleUploads?: (data: Entity) => Promise<void>;
+};
+
+export type FullContext = Context & { info: GraphQLResolveInfo; aliases: AliasGenerator };

package/src/errors.ts

@@ -0,0 +1,32 @@
+import { GraphQLError as GQLError } from 'graphql';
+import { PermissionAction } from './permissions/generate';
+
+export class GraphQLError extends GQLError {
+  constructor(message: string, extensions: ConstructorParameters<typeof GQLError>[6]) {
+    super(message, undefined, undefined, undefined, undefined, undefined, extensions);
+  }
+}
+
+export class ForbiddenError extends GraphQLError {
+  constructor(what: string) {
+    super(what, { code: 'FORBIDDEN' });
+  }
+}
+
+export class NotFoundError extends GraphQLError {
+  constructor(what: string) {
+    super(what, { code: 'NOT_FOUND' });
+  }
+}
+
+export class UserInputError extends GraphQLError {
+  constructor(what: string) {
+    super(what, { code: 'BAD_USER_INPUT' });
+  }
+}
+
+export class PermissionError extends ForbiddenError {
+  constructor(action: PermissionAction, what: string) {
+    super(`You do not have sufficient permissions to ${action.toLowerCase()} ${what}.`);
+  }
+}

package/src/generate/generate.ts

@@ -0,0 +1,273 @@
+import { buildASTSchema, DefinitionNode, DocumentNode, GraphQLSchema, print } from 'graphql';
+import flatMap from 'lodash/flatMap';
+import {
+  Field,
+  isEnumModel,
+  isJsonObjectModel,
+  isQueriableField,
+  isRawEnumModel,
+  isRawObjectModel,
+  isScalarModel,
+  RawModels,
+} from '../models';
+import { getModelPluralField, getModels, typeToField } from '../utils';
+import { document, enm, input, object, scalar } from './utils';
+
+export const generateDefinitions = (rawModels: RawModels): DefinitionNode[] => {
+  const models = getModels(rawModels);
+
+  return [
+    // Predefined types
+    enm('Order', ['ASC', 'DESC']),
+    scalar('DateTime'),
+    scalar('Upload'),
+
+    ...rawModels.filter(isEnumModel).map((model) => enm(model.name, model.values)),
+    ...rawModels.filter(isRawEnumModel).map((model) => enm(model.name, model.values)),
+    ...rawModels.filter(isScalarModel).map((model) => scalar(model.name)),
+    ...rawModels.filter(isRawObjectModel).map((model) => object(model.name, model.fields)),
+    ...rawModels.filter(isJsonObjectModel).map((model) => object(model.name, model.fields)),
+    ...rawModels
+      .filter(isRawObjectModel)
+      .filter(({ rawFilters }) => rawFilters)
+      .map((model) =>
+        input(
+          `${model.name}Where`,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- array gets filtered above to only include models with rawFilters
+          model.rawFilters!.map(({ name, type, list = false, nonNull = false }) => ({ name, type, list, nonNull }))
+        )
+      ),
+
+    ...flatMap(
+      models.map((model) => {
+        const types = [
+          object(
+            model.name,
+            [
+              ...model.fields.filter(isQueriableField).map((field) => ({
+                ...field,
+                args: [
+                  ...(field.args || []),
+                  ...(hasRawFilters(rawModels, field.type) ? [{ name: 'where', type: `${field.type}Where` }] : []),
+                ],
+                directives: field.directives,
+              })),
+              ...model.reverseRelations.map(({ name, field, model }) => ({
+                name,
+                type: model.name,
+                list: !field.toOne,
+                nonNull: !field.toOne,
+                args: [
+                  { name: 'where', type: `${model.name}Where` },
+                  ...(model.fields.some(({ searchable }) => searchable) ? [{ name: 'search', type: 'String' }] : []),
+                  ...(model.fields.some(({ orderable }) => orderable)
+                    ? [{ name: 'orderBy', type: `${model.name}OrderBy`, list: true }]
+                    : []),
+                  { name: 'limit', type: 'Int' },
+                  { name: 'offset', type: 'Int' },
+                ],
+              })),
+            ],
+            model.interfaces
+          ),
+          input(`${model.name}Where`, [
+            ...model.fields
+              .filter(({ unique, filterable, relation }) => (unique || filterable) && !relation)
+              .map(({ name, type, defaultFilter }) => ({ name, type, list: true, default: defaultFilter })),
+            ...flatMap(
+              model.fields.filter(({ comparable }) => comparable),
+              ({ name, type }) => [
+                { name: `${name}_GT`, type },
+                { name: `${name}_GTE`, type },
+                { name: `${name}_LT`, type },
+                { name: `${name}_LTE`, type },
+              ]
+            ),
+            ...model.fields
+              .filter(({ filterable, relation }) => filterable && relation)
+              .map(({ name, type }) => ({
+                name,
+                type: `${type}Where`,
+              })),
+          ]),
+          input(
+            `${model.name}WhereUnique`,
+            model.fields.filter(({ unique }) => unique).map(({ name, type }) => ({ name, type }))
+          ),
+          ...(model.fields.some(({ orderable }) => orderable)
+            ? [
+                input(
+                  `${model.name}OrderBy`,
+                  model.fields.filter(({ orderable }) => orderable).map(({ name }) => ({ name, type: 'Order' }))
+                ),
+              ]
+            : []),
+        ];
+
+        if (model.creatable) {
+          types.push(
+            input(
+              `Create${model.name}`,
+              model.fields
+                .filter(({ creatable }) => creatable)
+                .map(({ name, relation, type, nonNull, list, default: defaultValue }) =>
+                  relation
+                    ? { name: `${name}Id`, type: 'ID', nonNull }
+                    : { name, type, list, nonNull: nonNull && defaultValue === undefined }
+                )
+            )
+          );
+        }
+
+        if (model.updatable) {
+          types.push(
+            input(
+              `Update${model.name}`,
+              model.fields
+                .filter(({ updatable }) => updatable)
+                .map(({ name, relation, type, list }) =>
+                  relation ? { name: `${name}Id`, type: 'ID' } : { name, type, list }
+                )
+            )
+          );
+        }
+        return types;
+      })
+    ),
+
+    object('Query', [
+      {
+        name: 'me',
+        type: 'User',
+      },
+      ...models
+        .filter(({ queriable }) => queriable)
+        .map(({ name }) => ({
+          name: typeToField(name),
+          type: name,
+          nonNull: true,
+          args: [
+            {
+              name: 'where',
+              type: `${name}WhereUnique`,
+              nonNull: true,
+            },
+          ],
+        })),
+      ...models
+        .filter(({ listQueriable }) => listQueriable)
+        .map((model) => ({
+          name: getModelPluralField(model),
+          type: model.name,
+          list: true,
+          nonNull: true,
+          args: [
+            { name: 'where', type: `${model.name}Where` },
+            ...(model.fields.some(({ searchable }) => searchable) ? [{ name: 'search', type: 'String' }] : []),
+            ...(model.fields.some(({ orderable }) => orderable)
+              ? [{ name: 'orderBy', type: `${model.name}OrderBy`, list: true }]
+              : []),
+            { name: 'limit', type: 'Int' },
+            { name: 'offset', type: 'Int' },
+          ],
+        })),
+    ]),
+
+    object('Mutation', [
+      ...flatMap(
+        models.map((model): Field[] => {
+          const mutations: Field[] = [];
+
+          if (model.creatable) {
+            mutations.push({
+              name: `create${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: 'data',
+                  type: `Create${model.name}`,
+                  nonNull: true,
+                },
+              ],
+            });
+          }
+
+          if (model.updatable) {
+            mutations.push({
+              name: `update${model.name}`,
+              type: model.name,
+              nonNull: true,
+              args: [
+                {
+                  name: 'where',
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true,
+                },
+                {
+                  name: 'data',
+                  type: `Update${model.name}`,
+                  nonNull: true,
+                },
+              ],
+            });
+          }
+
+          if (model.deletable) {
+            mutations.push({
+              name: `delete${model.name}`,
+              type: 'ID',
+              nonNull: true,
+              args: [
+                {
+                  name: 'where',
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true,
+                },
+                {
+                  name: 'dryRun',
+                  type: 'Boolean',
+                },
+              ],
+            });
+            mutations.push({
+              name: `restore${model.name}`,
+              type: 'ID',
+              nonNull: true,
+              args: [
+                {
+                  name: 'where',
+                  type: `${model.name}WhereUnique`,
+                  nonNull: true,
+                },
+              ],
+            });
+          }
+
+          return mutations;
+        })
+      ),
+    ]),
+  ];
+};
+
+export const generate = (rawModels: RawModels) => document(generateDefinitions(rawModels));
+
+export const printSchema = (schema: GraphQLSchema): string =>
+  [
+    ...schema.getDirectives().map((d) => d.astNode && print(d.astNode)),
+    ...Object.values(schema.getTypeMap())
+      .filter((t) => !t.name.match(/^__/))
+      .sort((a, b) => (a.name > b.name ? 1 : -1))
+      .map((t) => t.astNode && print(t.astNode)),
+  ]
+    .filter(Boolean)
+    .map((s) => `${s}\n`)
+    .join('\n');
+
+const hasRawFilters = (models: RawModels, type: string) =>
+  models.filter(isRawObjectModel).some(({ name, rawFilters }) => name === type && !!rawFilters);
+
+export const printSchemaFromDocument = (document: DocumentNode) => printSchema(buildASTSchema(document));
+
+export const printSchemaFromModels = (models: RawModels) => printSchema(buildASTSchema(generate(models)));