@smartive/graphql-magic 2.1.1 → 3.0.1

package/src/permissions/generate.ts

@@ -71,7 +71,7 @@ export const generatePermissions = (models: Models, config: PermissionsConfig) =
         rolePermissions[type] = {};
         for (const action of ACTIONS) {
           if (action === 'READ' || action in block) {
-            rolePermissions[type]![action] = true;
+            rolePermissions[type][action] = true;
           }
         }
       }
@@ -95,7 +95,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 { type } = links[links.length - 1];
   const model = summonByName(models, type);
 
   for (const action of ACTIONS) {
@@ -103,11 +103,11 @@ const addPermissions = (models: Models, permissions: RolePermissions, links: Per
       if (!permissions[type]) {
         permissions[type] = {};
       }
-      if (!permissions[type]![action]) {
-        permissions[type]![action] = [];
+      if (!permissions[type][action]) {
+        permissions[type][action] = [];
       }
-      if (permissions[type]![action] !== true) {
-        (permissions[type]![action] as PermissionStack).push(links);
+      if (permissions[type][action] !== true) {
+        (permissions[type][action] as PermissionStack).push(links);
       }
     }
   }
@@ -123,7 +123,7 @@ const addPermissions = (models: Models, permissions: RolePermissions, links: Per
           reverse: true,
         };
       } else {
-        const field = model.reverseRelationsByName[relation]!;
+        const field = model.reverseRelationsByName[relation];
 
         if (!field) {
           throw new Error(`Relation ${relation} in model ${model.name} does not exist.`);

package/src/resolvers/filters.ts

@@ -72,12 +72,12 @@ const applyWhere = (node: WhereNode, where: Where, ops: Ops<Knex.QueryBuilder>,
     const specialFilter = key.match(/^(\w+)_(\w+)$/);
     if (specialFilter) {
       const [, actualKey, filter] = specialFilter;
-      if (!SPECIAL_FILTERS[filter!]) {
+      if (!SPECIAL_FILTERS[filter]) {
         // Should not happen
         throw new Error(`Invalid filter ${key}.`);
       }
       ops.push((query) =>
-        query.whereRaw(SPECIAL_FILTERS[filter!]!, [`${node.shortTableAlias}.${actualKey}`, value as string])
+        query.whereRaw(SPECIAL_FILTERS[filter], [`${node.shortTableAlias}.${actualKey}`, value as string])
       );
       continue;
     }
@@ -154,7 +154,7 @@ const applyOrderBy = (node: FieldResolverNode, orderBy: OrderBy, query: Knex.Que
       throw new UserInputError(`You need to specify exactly 1 value to order by for each orderBy entry.`);
     }
     const key = keys[0];
-    const value = vals[key!];
+    const value = vals[key];
 
     // Simple field
     // eslint-disable-next-line @typescript-eslint/no-floating-promises -- we do not need to await knex here

package/src/resolvers/mutations.ts

@@ -12,7 +12,7 @@ export const mutationResolver = async (_parent: any, args: any, partialCtx: Cont
   return await partialCtx.knex.transaction(async (knex) => {
     const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
     const ctx = { ...partialCtx, knex, info, aliases: new AliasGenerator() };
-    const model = summonByName(ctx.models, modelName!);
+    const model = summonByName(ctx.models, modelName);
     switch (mutation) {
       case 'create':
         return await create(model, args, ctx);
@@ -110,17 +110,20 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
       return;
     }
 
-    if (dryRun) {
-      if (!(currentModel.name in toDelete)) {
-        toDelete[currentModel.name] = {};
-      }
-      toDelete[currentModel.name]![entity.id] = entity[currentModel.displayField || 'id'] || entity.id;
-    } else {
+    if (!(currentModel.name in toDelete)) {
+      toDelete[currentModel.name] = {};
+    }
+    if (entity.id in toDelete[currentModel.name]) {
+      return;
+    }
+    toDelete[currentModel.name][entity.id] = entity[currentModel.displayField || 'id'] || entity.id;
+
+    if (!dryRun) {
       const normalizedInput = { deleted: true, deletedAt: ctx.now, deletedById: ctx.user.id };
       const data = { prev: entity, input: {}, normalizedInput, next: { ...entity, ...normalizedInput } };
       if (ctx.mutationHook) {
         beforeHooks.push(async () => {
-          await ctx.mutationHook!(currentModel, 'delete', 'before', data, ctx);
+          await ctx.mutationHook(currentModel, 'delete', 'before', data, ctx);
         });
       }
       mutations.push(async () => {
@@ -129,7 +132,7 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
       });
       if (ctx.mutationHook) {
         afterHooks.push(async () => {
-          await ctx.mutationHook!(currentModel, 'delete', 'after', data, ctx);
+          await ctx.mutationHook(currentModel, 'delete', 'after', data, ctx);
         });
       }
     }
@@ -148,13 +151,13 @@ const del = async (model: Model, { where, dryRun }: { where: any; dryRun: boolea
               if (!toUnlink[descendantModel.name]) {
                 toUnlink[descendantModel.name] = {};
               }
-              if (!toUnlink[descendantModel.name]![descendant.id]) {
-                toUnlink[descendantModel.name]![descendant.id] = {
+              if (!toUnlink[descendantModel.name][descendant.id]) {
+                toUnlink[descendantModel.name][descendant.id] = {
                   display: descendant[descendantModel.displayField || 'id'] || entity.id,
                   fields: [],
                 };
               }
-              toUnlink[descendantModel.name]![descendant.id]!.fields.push(name);
+              toUnlink[descendantModel.name][descendant.id].fields.push(name);
             } else {
               mutations.push(async () => {
                 await ctx
@@ -225,7 +228,7 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
     const data = { prev: relatedEntity, input: {}, normalizedInput, next: { ...relatedEntity, ...normalizedInput } };
     if (ctx.mutationHook) {
       beforeHooks.push(async () => {
-        await ctx.mutationHook!(model, 'restore', 'before', data, ctx);
+        await ctx.mutationHook(model, 'restore', 'before', data, ctx);
       });
     }
     mutations.push(async () => {
@@ -234,7 +237,7 @@ const restore = async (model: Model, { where }: { where: any }, ctx: FullContext
     });
     if (ctx.mutationHook) {
       afterHooks.push(async () => {
-        await ctx.mutationHook!(model, 'restore', 'after', data, ctx);
+        await ctx.mutationHook(model, 'restore', 'after', data, ctx);
       });
     }
 

package/src/resolvers/node.ts

@@ -132,7 +132,7 @@ export const getFragmentSpreads = (node: ResolverNode) =>
   node.selectionSet.filter(isFragmentSpreadNode).map((subNode) =>
     getResolverNode({
       ctx: node.ctx,
-      node: node.ctx.info.fragments[subNode.name.value]!,
+      node: node.ctx.info.fragments[subNode.name.value],
       tableAlias: node.tableAlias,
       baseTypeDefinition: node.baseTypeDefinition,
       typeName: node.model.name,

package/src/resolvers/resolver.ts

@@ -165,7 +165,7 @@ const applySubQueries = async (
     if (!entriesById[entry[ID_ALIAS]]) {
       entriesById[entry[ID_ALIAS]] = [];
     }
-    entriesById[entry[ID_ALIAS]!]!.push(entry);
+    entriesById[entry[ID_ALIAS]].push(entry);
   }
   const ids = Object.keys(entriesById);
 
@@ -189,7 +189,7 @@ const applySubQueries = async (
     const children = hydrate(subNode, rawChildren);
 
     for (const child of children) {
-      for (const entry of entriesById[child[foreignKey] as string]!) {
+      for (const entry of entriesById[child[foreignKey] as string]) {
         if (isList) {
           (entry[fieldName] as Entry[]).push(cloneDeep(child));
         } else {

package/src/resolvers/utils.ts

@@ -72,13 +72,13 @@ export function hydrate<T extends Entry>(
     outer: for (const [column, value] of Object.entries(entry)) {
       let current = res;
       const shortParts = column.split('__');
-      const fieldName = shortParts.pop()!;
+      const fieldName = shortParts.pop();
       const columnWithoutField = shortParts.join('__');
       const longColumn = node.ctx.aliases.getLong(columnWithoutField);
       const longColumnWithoutRoot = longColumn.replace(new RegExp(`^${tableAlias}(__)?`), '');
       const allParts = [tableAlias, ...(longColumnWithoutRoot ? longColumnWithoutRoot.split('__') : []), fieldName];
       for (let i = 0; i < allParts.length - 1; i++) {
-        const part = allParts[i]!;
+        const part = allParts[i];
 
         if (!current[part]) {
           const idField = [node.ctx.aliases.getShort(allParts.slice(0, i + 1).join('__')), ID_ALIAS].join('__');

package/tests/api/__snapshots__/delete.spec.ts.snap

@@ -0,0 +1,18 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`delete works with self-referential entities 1`] = `
+{
+  "deleteAnotherObject": "226a20e8-5c18-4423-99ca-eb0df6ff4fdd",
+}
+`;
+
+exports[`delete works with self-referential entities 2`] = `
+{
+  "anotherObjects": [
+    {
+      "deleted": true,
+      "id": "226a20e8-5c18-4423-99ca-eb0df6ff4fdd",
+    },
+  ],
+}
+`;

package/tests/api/__snapshots__/query.spec.ts.snap

@@ -0,0 +1,22 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`query can be executed 1`] = `
+{
+  "manyObjects": [
+    {
+      "another": {
+        "id": "226a20e8-5c18-4423-99ca-eb0df6ff4fdd",
+        "manyObjects": [
+          {
+            "field": null,
+            "id": "604ab55d-ec3e-4857-9f27-219158f80e64",
+          },
+        ],
+      },
+      "field": null,
+      "id": "604ab55d-ec3e-4857-9f27-219158f80e64",
+      "xyz": 1,
+    },
+  ],
+}
+`;

package/tests/api/delete.spec.ts

@@ -0,0 +1,28 @@
+import { gql } from '../../src';
+import { ANOTHER_ID } from '../utils/database/seed';
+import { withServer } from '../utils/server';
+
+describe('delete', () => {
+  it('works with self-referential entities', async () => {
+    await withServer(async (request) => {
+      expect(
+        await request(gql`
+          mutation DeleteAnotherObject {
+            deleteAnotherObject(where: { id: "${ANOTHER_ID}" })
+          }
+        `)
+      ).toMatchSnapshot();
+
+      expect(
+        await request(gql`
+          query GetAnotherObject {
+            anotherObjects(where: { id: "${ANOTHER_ID}", deleted: true }) {
+              id
+              deleted
+            }
+          }
+        `)
+      ).toMatchSnapshot();
+    });
+  });
+});

package/tests/api/query.spec.ts

@@ -0,0 +1,28 @@
+import { gql } from '../../src';
+import { ANOTHER_ID, SOME_ID } from '../utils/database/seed';
+import { withServer } from '../utils/server';
+
+describe('query', () => {
+  it('can be executed', async () => {
+    await withServer(async (request) => {
+      expect(
+        await request(gql`
+          query SomeQuery {
+            manyObjects(where: { another: { id: "${ANOTHER_ID}" } }, orderBy: [{ xyz: DESC }]) {
+              id
+              field
+              xyz
+              another {
+                id
+                manyObjects(where: { id: "${SOME_ID}" }) {
+                  id
+                  field
+                }
+              }
+            }
+          }
+        `)
+      ).toMatchSnapshot();
+    });
+  });
+});

package/tests/unit/__snapshots__/generate.spec.ts.snap

@@ -3,11 +3,21 @@
 exports[`generate generates a schema 1`] = `
 "type AnotherObject {
   id: ID!
+  myself: AnotherObject
+  deleted: Boolean!
+  deletedAt: DateTime
+  deletedBy: User
+  self(where: AnotherObjectWhere, orderBy: [AnotherObjectOrderBy!], limit: Int, offset: Int): AnotherObject
   manyObjects(where: SomeObjectWhere, search: String, orderBy: [SomeObjectOrderBy!], limit: Int, offset: Int): [SomeObject!]!
 }
 
+input AnotherObjectOrderBy {
+  deletedAt: Order
+}
+
 input AnotherObjectWhere {
   id: [ID!]
+  deleted: [Boolean!] = false
 }
 
 input AnotherObjectWhereUnique {
@@ -21,6 +31,8 @@ input CreateSomeObject {
 scalar DateTime
 
 type Mutation {
+  deleteAnotherObject(where: AnotherObjectWhereUnique!, dryRun: Boolean): ID!
+  restoreAnotherObject(where: AnotherObjectWhereUnique!): ID!
   createSomeObject(data: CreateSomeObject!): SomeObject!
   updateSomeObject(where: SomeObjectWhereUnique!, data: UpdateSomeObject!): SomeObject!
   deleteSomeObject(where: SomeObjectWhereUnique!, dryRun: Boolean): ID!
@@ -35,9 +47,15 @@ enum Order {
 type Query {
   me: User
   someObject(where: SomeObjectWhereUnique!): SomeObject!
+  anotherObjects(where: AnotherObjectWhere, orderBy: [AnotherObjectOrderBy!], limit: Int, offset: Int): [AnotherObject!]!
   manyObjects(where: SomeObjectWhere, search: String, orderBy: [SomeObjectOrderBy!], limit: Int, offset: Int): [SomeObject!]!
 }
 
+enum Role {
+  ADMIN
+  USER
+}
+
 enum SomeEnum {
   A
   B
@@ -89,6 +107,8 @@ scalar Upload
 type User {
   id: ID!
   username: String
+  role: Role
+  deletedAnotherObjects(where: AnotherObjectWhere, orderBy: [AnotherObjectOrderBy!], limit: Int, offset: Int): [AnotherObject!]!
   createdManyObjects(where: SomeObjectWhere, search: String, orderBy: [SomeObjectOrderBy!], limit: Int, offset: Int): [SomeObject!]!
   updatedManyObjects(where: SomeObjectWhere, search: String, orderBy: [SomeObjectOrderBy!], limit: Int, offset: Int): [SomeObject!]!
   deletedManyObjects(where: SomeObjectWhere, search: String, orderBy: [SomeObjectOrderBy!], limit: Int, offset: Int): [SomeObject!]!

package/tests/unit/__snapshots__/resolve.spec.ts.snap

@@ -4,11 +4,14 @@ exports[`resolvers are generated correctly 1`] = `
 {
   "Mutation": {
     "createSomeObject": [Function],
+    "deleteAnotherObject": [Function],
     "deleteSomeObject": [Function],
+    "restoreAnotherObject": [Function],
     "restoreSomeObject": [Function],
     "updateSomeObject": [Function],
   },
   "Query": {
+    "anotherObjects": [Function],
     "manyObjects": [Function],
     "me": [Function],
     "someObject": [Function],

package/tests/unit/generate.spec.ts

@@ -1,5 +1,5 @@
-import { printSchemaFromModels } from '../../src/generate';
-import { rawModels } from './utils';
+import { printSchemaFromModels } from '../../src';
+import { rawModels } from '../utils/models';
 
 describe('generate', () => {
   it('generates a schema', () => {

package/tests/unit/resolve.spec.ts

@@ -1,12 +1,12 @@
 import { makeExecutableSchema } from '@graphql-tools/schema';
 import { execute, parse, Source } from 'graphql';
 import knex from 'knex';
+import { DateTime } from 'luxon';
 import { gql } from '../../src/client/gql';
 import { Context } from '../../src/context';
 import { generate } from '../../src/generate';
 import { getResolvers } from '../../src/resolvers';
-import { models, permissions, rawModels } from './utils';
-import { DateTime } from 'luxon';
+import { models, permissions, rawModels } from '../utils/models';
 
 const test = async (operationName: string, query: string, variableValues: object, responses: unknown[]) => {
   const knexInstance = knex({

package/tests/utils/database/knex.ts

@@ -0,0 +1,19 @@
+import knex from 'knex';
+
+export const getKnex = (database = 'postgres') =>
+  knex({
+    client: 'postgresql',
+    connection: {
+      host: 'localhost',
+      database,
+      user: 'postgres',
+      password: 'password',
+    },
+    migrations: {
+      tableName: 'knex_migrations',
+    },
+    pool: {
+      min: 0,
+      max: 30,
+    },
+  });

package/tests/utils/database/schema.ts

@@ -0,0 +1,62 @@
+import { Knex } from 'knex';
+
+export const setupSchema = async (knex: Knex) => {
+  await knex.raw(`CREATE TYPE "someEnum" AS ENUM ('A','B','C')`);
+
+  await knex.raw(`CREATE TYPE "role" AS ENUM ('ADMIN','USER')`);
+
+  await knex.schema.createTable('User', (table) => {
+    table.uuid('id').notNullable().primary();
+    table.string('username', undefined).nullable();
+    table
+      .enum('role', null as any, {
+        useNative: true,
+        existingType: true,
+        enumName: 'role',
+      })
+      .nullable();
+  });
+
+  await knex.schema.createTable('AnotherObject', (table) => {
+    table.uuid('id').notNullable().primary();
+    table.uuid('myselfId').notNullable();
+    table.foreign('myselfId').references('id').inTable('AnotherObject');
+    table.boolean('deleted').notNullable().defaultTo(false);
+    table.timestamp('deletedAt').nullable();
+    table.uuid('deletedById').nullable();
+    table.foreign('deletedById').references('id').inTable('User');
+  });
+
+  await knex.schema.createTable('AnotherObjectRevision', (table) => {
+    table.uuid('id').notNullable().primary();
+    table.boolean('deleted').notNullable();
+  });
+  
+  await knex.schema.createTable('SomeObject', (table) => {
+    table.uuid('id').notNullable().primary();
+    table.string('field', undefined).nullable();
+    table.uuid('anotherId').notNullable();
+    table.foreign('anotherId').references('id').inTable('AnotherObject');
+    table.decimal('list', 1, 1).notNullable();
+    table.integer('xyz').notNullable();
+    table.timestamp('createdAt').notNullable();
+    table.uuid('createdById').notNullable();
+    table.foreign('createdById').references('id').inTable('User');
+    table.timestamp('updatedAt').notNullable();
+    table.uuid('updatedById').notNullable();
+    table.foreign('updatedById').references('id').inTable('User');
+    table.boolean('deleted').notNullable().defaultTo(false);
+    table.timestamp('deletedAt').nullable();
+    table.uuid('deletedById').nullable();
+    table.foreign('deletedById').references('id').inTable('User');
+  });
+
+  await knex.schema.createTable('SomeObjectRevision', (table) => {
+    table.uuid('id').notNullable().primary();
+    table.uuid('someObjectId').notNullable();
+    table.uuid('createdById').notNullable();
+    table.timestamp('createdAt').notNullable().defaultTo(knex.fn.now(0));
+    table.boolean('deleted').notNullable();
+    table.integer('xyz').notNullable();
+  });
+};

package/tests/utils/database/seed.ts

@@ -0,0 +1,54 @@
+import { Knex } from 'knex';
+import { DateTime } from 'luxon';
+import { summonByName } from '../../../src';
+import { models } from '../models';
+
+export const ADMIN_ID = '04e45b48-04cf-4b38-bb25-b9af5ae0b2c4';
+
+export const SOME_ID = '604ab55d-ec3e-4857-9f27-219158f80e64';
+export const ANOTHER_ID = '226a20e8-5c18-4423-99ca-eb0df6ff4fdd';
+
+export const seed = {
+  User: [
+    {
+      id: ADMIN_ID,
+      username: 'admin',
+      role: 'ADMIN',
+    },
+  ],
+  AnotherObject: [
+    {
+      id: ANOTHER_ID,
+      myselfId: ANOTHER_ID,
+    },
+  ],
+  SomeObject: [
+    {
+      id: SOME_ID,
+      anotherId: ANOTHER_ID,
+      list: 0,
+      xyz: 1,
+    },
+  ],
+};
+
+export const setupSeed = async (knex: Knex) => {
+  const now = DateTime.now();
+  for (const [table, entities] of Object.entries(seed)) {
+    const model = summonByName(models, table);
+    await knex.batchInsert(
+      table,
+      entities.map((entity, i) => ({
+        ...entity,
+        ...(model.creatable && {
+          createdAt: now.plus({ second: i }),
+          createdById: ADMIN_ID,
+        }),
+        ...(model.updatable && {
+          updatedAt: now.plus({ second: i }),
+          updatedById: ADMIN_ID,
+        }),
+      }))
+    );
+  }
+};

package/tests/utils/generate-migration.ts

@@ -0,0 +1,35 @@
+import { writeFileSync } from 'fs';
+import { simpleGit } from 'simple-git';
+import { MigrationGenerator } from '../../src/migrations/generate';
+import { getKnex } from './database/knex';
+import { rawModels } from './models';
+
+const git = simpleGit();
+
+const getDate = () => {
+  const date = new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+};
+
+const writeMigration = async () => {
+  const name = process.argv[2] || (await git.branch()).current.split('/').pop();
+
+  const knex = getKnex();
+
+  try {
+    const migrations = await new MigrationGenerator(knex, rawModels).generate();
+
+    writeFileSync(`tmp/${getDate()}_${name}.ts`, migrations);
+  } finally {
+    await knex.destroy();
+  }
+};
+
+void writeMigration();

package/tests/{unit/utils.ts → utils/models.ts}

@@ -8,6 +8,11 @@ export const rawModels: RawModels = [
     type: 'enum',
     values: ['A', 'B', 'C'],
   },
+  {
+    name: 'Role',
+    type: 'enum',
+    values: ['ADMIN', 'USER'],
+  },
 
   {
     name: 'SomeRawObject',
@@ -23,6 +28,25 @@ export const rawModels: RawModels = [
         name: 'username',
         type: 'String',
       },
+      {
+        name: 'role',
+        type: 'Role',
+      },
+    ],
+  },
+  {
+    type: 'object',
+    name: 'AnotherObject',
+    listQueriable: true,
+    deletable: true,
+    fields: [
+      {
+        type: 'AnotherObject',
+        name: 'myself',
+        toOne: true,
+        reverse: 'self',
+        relation: true
+      }
     ],
   },
   {
@@ -51,6 +75,8 @@ export const rawModels: RawModels = [
       {
         name: 'list',
         type: 'Float',
+        scale: 1,
+        precision: 1,
         nonNull: true,
         list: true,
         args: [{ name: 'magic', type: 'Boolean' }],
@@ -66,11 +92,6 @@ export const rawModels: RawModels = [
       },
     ],
   },
-  {
-    type: 'object',
-    name: 'AnotherObject',
-    fields: [],
-  },
 ];
 
 export const models = getModels(rawModels);