@smartive/graphql-magic 1.0.1

package/src/utils.ts

@@ -0,0 +1,186 @@
+import assert from 'assert';
+import { pluralize } from 'inflection';
+import camelCase from 'lodash/camelCase';
+import lodashGet from 'lodash/get';
+import kebabCase from 'lodash/kebabCase';
+import startCase from 'lodash/startCase';
+import { Model, Models, ObjectModel, RawModels, Relation, ReverseRelation, isObjectModel } from './models';
+
+const isNotFalsy = <T>(v: T | null | undefined | false): v is T => typeof v !== 'undefined' && v !== null && v !== false;
+
+export const merge = <T>(objects: ({ [name: string]: T } | undefined | false)[] | undefined): { [name: string]: T } =>
+  (objects || []).filter(isNotFalsy).reduce((i, acc) => ({ ...acc, ...i }), {});
+
+// Target -> target
+export const typeToField = (type: string) => type.substr(0, 1).toLowerCase() + type.substr(1);
+
+export const getModelPlural = (model: ObjectModel | Model) => model.plural || pluralize(model.name);
+
+export const getModelPluralField = (model: Model) => typeToField(getModelPlural(model));
+
+export const getModelSlug = (model: Model) => kebabCase(getModelPlural(model));
+
+export const getModelLabelPlural = (model: Model) => getLabel(getModelPlural(model));
+
+export const getModelLabel = (model: Model) => getLabel(model.name);
+
+export const getLabel = (s: string) => startCase(camelCase(s));
+
+export const getModels = (rawModels: RawModels): Models => {
+  const models: Models = rawModels.filter(isObjectModel).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: !model.nonStrict, orderable: true, generated: true },
+              {
+                name: 'createdBy',
+                type: 'User',
+                relation: true,
+                nonNull: !model.nonStrict,
+                reverse: `created${getModelPlural(model)}`,
+                generated: true,
+              },
+            ]
+          : []),
+        ...(model.updatable
+          ? [
+              { name: 'updatedAt', type: 'DateTime', nonNull: !model.nonStrict, orderable: true, generated: true },
+              {
+                name: 'updatedBy',
+                type: 'User',
+                relation: true,
+                nonNull: !model.nonStrict,
+                reverse: `updated${getModelPlural(model)}`,
+                generated: true,
+              },
+            ]
+          : []),
+        ...(model.deletable
+          ? [
+              {
+                name: 'deleted',
+                type: 'Boolean',
+                nonNull: true,
+                default: false,
+                filterable: true,
+                defaultFilter: false,
+                generated: true,
+              },
+              { name: 'deletedAt', type: 'DateTime', orderable: true, generated: true },
+              {
+                name: 'deletedBy',
+                type: 'User',
+                relation: true,
+                reverse: `deleted${getModelPlural(model)}`,
+                generated: true,
+              },
+            ]
+          : []),
+      ].map(({ foreignKey, ...field }) => ({
+        ...field,
+        ...(field.relation && {
+          foreignKey: 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.filter(({ relation }) => relation)) {
+      const fieldModel = summonByName(models, field.type);
+
+      const reverseRelation: ReverseRelation = {
+        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 summonByName = <T extends { name: string }>(array: T[], value: string) => summonByKey(array, 'name', value);
+
+export const summonByKey = <T>(array: readonly T[] | undefined, key: string, value: unknown) =>
+  summon(array, (element: T) => lodashGet(element, key) === value, `No element found with ${key} ${value}`);
+
+export const summon = <T>(array: readonly T[] | undefined, cb: Parameters<T[]['find']>[1], errorMessage?: string) => {
+  if (array === undefined) {
+    throw new Error('Base array is not defined.');
+  }
+  const result = array.find(cb);
+  if (result === undefined) {
+    console.trace();
+    throw new Error(errorMessage || 'Element not found.');
+  }
+  return result;
+};
+
+type ForSure<T> = T extends undefined | null ? never : T;
+
+export const it = <T>(object: T | null | undefined): ForSure<T> => {
+  if (object === undefined || object === null) {
+    console.trace();
+    throw new Error('Base object is not defined.');
+  }
+
+  return object as 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)}`);
+  }
+  return value as ForSure<ForSure<T>[U]>;
+};
+
+export const getString = (v: unknown) => {
+  assert(typeof v === 'string');
+  return v;
+};
+
+export const retry = async <T>(cb: () => Promise<T>, condition: (e: any) => boolean) => {
+  try {
+    return await cb();
+  } catch (e) {
+    if (condition(e)) {
+      return await cb();
+    } else {
+      throw e;
+    }
+  }
+};

package/src/values.ts

@@ -0,0 +1,19 @@
+import { DateTime } from 'luxon';
+
+export class Enum {
+  constructor(public value: string) {}
+}
+
+export type BasicValue = undefined | null | boolean | string | number | DateTime;
+
+export type Value = any; // BasicValue | Enum | Enum[] | Record<string, Value> | Value[];
+
+export type Values = {
+  name: string;
+  values: Value;
+}[];
+
+export type Directive = {
+  name: string;
+  values?: Values | undefined;
+};

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

@@ -0,0 +1,105 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`generate generates a schema 1`] = `
+"type AnotherObject {
+  id: ID!
+  manyObjects(where: SomeObjectWhere, search: String, orderBy: [SomeObjectOrderBy!], limit: Int, offset: Int): [SomeObject!]!
+}
+
+input AnotherObjectWhere {
+  id: [ID!]
+}
+
+input AnotherObjectWhereUnique {
+  id: ID
+}
+
+input CreateSomeObject {
+  xyz: Int!
+}
+
+scalar DateTime
+
+type Mutation {
+  createSomeObject(data: CreateSomeObject!): SomeObject!
+  updateSomeObject(where: SomeObjectWhereUnique!, data: UpdateSomeObject!): SomeObject!
+  deleteSomeObject(where: SomeObjectWhereUnique!, dryRun: Boolean): ID!
+  restoreSomeObject(where: SomeObjectWhereUnique!): ID!
+}
+
+enum Order {
+  ASC
+  DESC
+}
+
+type Query {
+  me: User
+  someObject(where: SomeObjectWhereUnique!): SomeObject!
+  manyObjects(where: SomeObjectWhere, search: String, orderBy: [SomeObjectOrderBy!], limit: Int, offset: Int): [SomeObject!]!
+}
+
+enum SomeEnum {
+  A
+  B
+  C
+}
+
+type SomeObject {
+  id: ID!
+  field: String
+  another: AnotherObject!
+  list(magic: Boolean): [Float!]!
+  xyz: Int!
+  createdAt: DateTime!
+  createdBy: User!
+  updatedAt: DateTime!
+  updatedBy: User!
+  deleted: Boolean!
+  deletedAt: DateTime
+  deletedBy: User
+}
+
+input SomeObjectOrderBy {
+  xyz: Order
+  createdAt: Order
+  updatedAt: Order
+  deletedAt: Order
+}
+
+input SomeObjectWhere {
+  id: [ID!]
+  deleted: [Boolean!] = false
+  another: AnotherObjectWhere
+}
+
+input SomeObjectWhereUnique {
+  id: ID
+}
+
+type SomeRawObject {
+  field: String
+}
+
+input UpdateSomeObject {
+  xyz: Int
+}
+
+scalar Upload
+
+type User {
+  id: ID!
+  username: String
+  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!]!
+}
+
+input UserWhere {
+  id: [ID!]
+}
+
+input UserWhereUnique {
+  id: ID
+}
+"
+`;

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

@@ -0,0 +1,60 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`resolvers are generated correctly 1`] = `
+{
+  "Mutation": {
+    "createSomeObject": [Function],
+    "deleteSomeObject": [Function],
+    "restoreSomeObject": [Function],
+    "updateSomeObject": [Function],
+  },
+  "Query": {
+    "manyObjects": [Function],
+    "me": [Function],
+    "someObject": [Function],
+  },
+}
+`;
+
+exports[`resolvers resolve lists, many-to-one and one-to-many queries 1`] = `
+{
+  "data": {
+    "manyObjects": [
+      {
+        "another": {
+          "id": "bar",
+          "manyObjects": [
+            {
+              "field": "foo",
+              "id": "foo",
+            },
+          ],
+        },
+        "field": "foo",
+        "id": "foo",
+      },
+    ],
+  },
+}
+`;
+
+exports[`resolvers resolve lists, many-to-one and one-to-many queries: query 1`] = `"select * from "User" where "id" = $1 limit $2"`;
+
+exports[`resolvers resolve lists, many-to-one and one-to-many queries: query 2`] = `"select "SO"."id" as "SO__ID", "SO"."id" as "SO__id", "SO"."field" as "SO__field", "SO__a"."id" as "SO__a__ID", "SO__a"."id" as "SO__a__id" from "SomeObject" as "SO" left join "AnotherObject" as "SO__W__a" on "SO"."anotherId" = "SO__W__a"."id" left join "AnotherObject" as "SO__a" on "SO"."anotherId" = "SO__a"."id" where "SO__W__a"."id" in ($1) and "SO"."deleted" = $2 order by "SO"."xyz" DESC"`;
+
+exports[`resolvers resolve lists, many-to-one and one-to-many queries: query 3`] = `"select "SO__a__mO"."id" as "SO__a__mO__ID", "SO__a__mO"."id" as "SO__a__mO__id", "SO__a__mO"."field" as "SO__a__mO__field", "SO__a__mO"."anotherId" as "SO__a__mO__anotherId" from "SomeObject" as "SO__a__mO" where "SO__a__mO"."id" in ($1) and "SO__a__mO"."deleted" = $2 and "SO__a__mO"."anotherId" = $3 order by "SO__a__mO"."createdAt" DESC"`;
+
+exports[`resolvers resolve single query 1`] = `
+{
+  "data": {
+    "someObject": {
+      "field": "foo",
+      "id": "foo",
+    },
+  },
+}
+`;
+
+exports[`resolvers resolve single query: query 1`] = `"select * from "User" where "id" = $1 limit $2"`;
+
+exports[`resolvers resolve single query: query 2`] = `"select "SO"."id" as "SO__ID", "SO"."id" as "SO__id", "SO"."field" as "SO__field" from "SomeObject" as "SO" where "SO"."id" = $1 and "SO"."deleted" = $2 order by "SO"."createdAt" DESC limit $3"`;

package/tests/unit/generate.spec.ts

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

package/tests/unit/resolve.spec.ts

@@ -0,0 +1,128 @@
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import { execute, parse, Source } from 'graphql';
+import knex from 'knex';
+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';
+
+const test = async (operationName: string, query: string, variableValues: object, responses: unknown[]) => {
+  const knexInstance = knex({
+    client: 'postgresql',
+  });
+
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const mockKnex = require('mock-knex');
+  mockKnex.mock(knexInstance);
+  const tracker = mockKnex.getTracker();
+
+  tracker.install();
+  tracker.on('query', function someFunction(query, step) {
+    expect(query.sql).toMatchSnapshot('query');
+    query.response(responses[step - 1]);
+  });
+
+  const user = await knexInstance('User').where({ id: 1 }).first();
+  const typeDefs = generate(rawModels);
+  const contextValue: Context = {
+    req: null as any,
+    knex: knexInstance,
+    document: typeDefs,
+    locale: 'en',
+    locales: ['en'],
+    user,
+    rawModels,
+    models,
+    permissions,
+    now: DateTime.fromISO('2020-01-01T00:00:00.000Z'),
+  };
+  const result = await execute({
+    schema: makeExecutableSchema({
+      typeDefs,
+      resolvers: getResolvers(models),
+    }),
+    document: parse(new Source(query, 'GraphQL request')),
+    contextValue,
+    variableValues,
+    operationName,
+  });
+
+  expect(result).toMatchSnapshot();
+
+  tracker.uninstall();
+};
+
+describe('resolvers', () => {
+  it('are generated correctly', () => {
+    expect(getResolvers(models)).toMatchSnapshot();
+  });
+
+  it('resolve lists, many-to-one and one-to-many queries', async () => {
+    await test(
+      'SomeQuery',
+      gql`
+        query SomeQuery {
+          manyObjects(where: { another: { id: "bar" } }, orderBy: [{ xyz: DESC }]) {
+            id
+            field
+            another {
+              id
+              manyObjects(where: { id: "foo" }) {
+                id
+                field
+              }
+            }
+          }
+        }
+      `,
+      {},
+      [
+        { id: 1, role: 'ADMIN' },
+        [
+          {
+            SO__ID: 'foo',
+            SO__id: 'foo',
+            SO__field: 'foo',
+            SO__a__ID: 'bar',
+            SO__a__id: 'bar',
+          },
+        ],
+        [
+          {
+            SO__a__mO__ID: 'foo',
+            SO__a__mO__id: 'foo',
+            SO__a__mO__field: 'foo',
+            SO__a__mO__anotherId: 'bar',
+          },
+        ],
+      ]
+    );
+  });
+
+  it('resolve single query', async () => {
+    await test(
+      'SomeQuery',
+      gql`
+        query SomeQuery {
+          someObject(where: { id: "foo" }) {
+            id
+            field
+          }
+        }
+      `,
+      {},
+      [
+        { id: 1, role: 'ADMIN' },
+        [
+          {
+            SO__ID: 'foo',
+            SO__id: 'foo',
+            SO__field: 'foo',
+          },
+        ],
+      ]
+    );
+  });
+});

package/tests/unit/utils.ts

@@ -0,0 +1,82 @@
+import { RawModels } from '../../src/models';
+import { generatePermissions, PermissionsConfig } from '../../src/permissions/generate';
+import { getModels } from '../../src/utils';
+
+export const rawModels: RawModels = [
+  {
+    name: 'SomeEnum',
+    type: 'enum',
+    values: ['A', 'B', 'C'],
+  },
+
+  {
+    name: 'SomeRawObject',
+    type: 'raw-object',
+    fields: [{ name: 'field', type: 'String' }],
+  },
+
+  {
+    type: 'object',
+    name: 'User',
+    fields: [
+      {
+        name: 'username',
+        type: 'String',
+      },
+    ],
+  },
+  {
+    type: 'object',
+    name: 'SomeObject',
+    plural: 'ManyObjects',
+    description: 'An object',
+    queriable: true,
+    listQueriable: true,
+    creatable: true,
+    updatable: true,
+    deletable: true,
+    fields: [
+      {
+        name: 'field',
+        searchable: true,
+        type: 'String',
+      },
+      {
+        name: 'another',
+        type: 'AnotherObject',
+        relation: true,
+        filterable: true,
+        nonNull: true,
+      },
+      {
+        name: 'list',
+        type: 'Float',
+        nonNull: true,
+        list: true,
+        args: [{ name: 'magic', type: 'Boolean' }],
+      },
+      {
+        name: 'xyz',
+        type: 'Int',
+        description: 'yay',
+        nonNull: true,
+        creatable: true,
+        updatable: true,
+        orderable: true,
+      },
+    ],
+  },
+  {
+    type: 'object',
+    name: 'AnotherObject',
+    fields: [],
+  },
+];
+
+export const models = getModels(rawModels);
+
+const permissionsConfig: PermissionsConfig = {
+  ADMIN: true,
+};
+
+export const permissions = generatePermissions(models, permissionsConfig);

package/tsconfig.jest.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["**/*.ts", "**/*.tsx", "**/unit/**/*.spec.ts"],
+  "exclude": ["node_modules", "dist"],
+  "compilerOptions": {
+    "rootDir": "./",
+    "types": ["jest"],
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "isolatedModules": true,
+    "allowJs": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "include": ["./src/**/*.ts", "./src/**/*.tsx"],
+  "exclude": ["node_modules", "dist"],
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "rootDir": "./src",
+    "sourceMap": true,
+    "declaration": true,
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  }
+}