@smartive/graphql-magic 2.1.0 → 3.0.0

package/tests/utils/database/schema.ts

@@ -0,0 +1,51 @@
+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();
+  });
+
+  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,53 @@
+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,
+    },
+  ],
+  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,8 +28,17 @@ export const rawModels: RawModels = [
         name: 'username',
         type: 'String',
       },
+      {
+        name: 'role',
+        type: 'Role',
+      },
     ],
   },
+  {
+    type: 'object',
+    name: 'AnotherObject',
+    fields: [],
+  },
   {
     type: 'object',
     name: 'SomeObject',
@@ -51,6 +65,8 @@ export const rawModels: RawModels = [
       {
         name: 'list',
         type: 'Float',
+        scale: 1,
+        precision: 1,
         nonNull: true,
         list: true,
         args: [{ name: 'magic', type: 'Boolean' }],
@@ -66,11 +82,6 @@ export const rawModels: RawModels = [
       },
     ],
   },
-  {
-    type: 'object',
-    name: 'AnotherObject',
-    fields: [],
-  },
 ];
 
 export const models = getModels(rawModels);

package/tests/utils/server.ts

@@ -0,0 +1,108 @@
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import { execute, parse, Source, TypedQueryDocumentNode } from 'graphql';
+import graphqlRequest, { RequestDocument, Variables } from 'graphql-request';
+import { createServer, RequestListener } from 'http';
+import { Knex } from 'knex';
+import { DateTime } from 'luxon';
+import { Context } from '../../src/context';
+import { generate } from '../../src/generate';
+import { getResolvers } from '../../src/resolvers';
+import { getKnex } from './database/knex';
+import { setupSchema } from './database/schema';
+import { ADMIN_ID, setupSeed } from './database/seed';
+import { models, permissions, rawModels } from './models';
+
+const MIN_PORT = 49152;
+const MAX_PORT = 65535;
+
+export const withServer = async (
+  cb: (
+    request: (document: RequestDocument | TypedQueryDocumentNode, ...variablesAndRequestHeaders: any) => Promise<any>,
+    knex: Knex
+  ) => Promise<void>
+) => {
+  // eslint-disable-next-line prefer-const
+  let handler: RequestListener;
+  let port: number;
+  const server = createServer((req, res) => handler(req, res));
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    try {
+      port = Math.floor(Math.random() * (MAX_PORT - MIN_PORT + 1)) + MIN_PORT;
+      await new Promise<void>((res, rej) => server.listen(port, res).once('error', rej));
+      break;
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  const rootKnex = getKnex();
+  const dbName = `test_${port}`;
+  await rootKnex.raw('DROP DATABASE IF EXISTS ?? WITH (FORCE)', dbName);
+  await rootKnex.raw(`CREATE DATABASE ?? OWNER ??`, [dbName, 'postgres']);
+
+  const knex = getKnex(dbName);
+
+  try {
+    await setupSchema(knex);
+    await setupSeed(knex);
+
+    handler = async (req, res) => {
+      const user = await knex('User').where({ id: ADMIN_ID }).first();
+
+      const typeDefs = generate(rawModels);
+      const contextValue: Context = {
+        req,
+        knex,
+        document: typeDefs,
+        locale: 'en',
+        locales: ['en'],
+        user,
+        rawModels,
+        models,
+        permissions,
+        now: DateTime.fromISO('2020-01-01T00:00:00.000Z'),
+      };
+      const {
+        query,
+        variables: variableValues,
+        operationName,
+      } = await new Promise<any>((res) => {
+        const chunks: any = [];
+        req
+          .on('data', (chunk) => {
+            chunks.push(chunk);
+          })
+          .on('end', () => {
+            res(JSON.parse(Buffer.concat(chunks).toString()));
+          });
+      });
+      const result = await execute({
+        schema: makeExecutableSchema({
+          typeDefs,
+          resolvers: getResolvers(models),
+        }),
+        document: parse(new Source(query, 'GraphQL request')),
+        contextValue,
+        variableValues,
+        operationName,
+      });
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    };
+
+    const request = <T, V extends Variables = Variables>(
+      document: RequestDocument | TypedQueryDocumentNode<T, V>,
+      ...variablesAndRequestHeaders: any
+    ) => graphqlRequest(`http://localhost:${port}`, document, ...variablesAndRequestHeaders);
+
+    await cb(request, knex);
+  } finally {
+    server.close();
+    await knex.destroy();
+    await rootKnex.raw('DROP DATABASE IF EXISTS ?? WITH (FORCE)', dbName);
+    await rootKnex.destroy();
+  }
+};

package/tsconfig.json

@@ -9,5 +9,5 @@
     "target": "esnext",
     "moduleResolution": "bundler",
     "allowSyntheticDefaultImports": true
-  }
+  },
 }