@smartive/graphql-magic 8.0.0 → 8.1.1

package/src/bin/gqm/index.ts

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { config } from 'dotenv';
+import knex from 'knex';
+import { simpleGit } from 'simple-git';
+import {
+  MigrationGenerator,
+  generateDBModels,
+  generateKnexTables,
+  generateMutations,
+  getMigrationDate,
+  printSchemaFromModels,
+} from '../..';
+import { generateGraphqlApiTypes, generateGraphqlClientTypes } from '../gqm/codegen';
+import { KNEXFILE_PATH, parseKnexfile } from '../gqm/parse-knexfile';
+import { parseModels } from '../gqm/parse-models';
+import { readLine } from '../gqm/readline';
+import { ensureFileExists, getSetting, getSettings, writeToFile } from '../gqm/settings';
+import { KNEXFILE } from '../gqm/templates';
+
+config({
+  path: '.env',
+});
+config({
+  path: '.env.local',
+});
+
+program.description('The graphql-magic cli.');
+
+program
+  .command('setup')
+  .description('Set up the project')
+  .action(async () => {
+    await getSettings();
+    ensureFileExists(KNEXFILE_PATH, KNEXFILE);
+  });
+
+program
+  .command('generate')
+  .description('Generate all the things')
+  .action(async () => {
+    const rawModels = await parseModels();
+    const generatedFolderPath = await getSetting('generatedFolderPath');
+    writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(rawModels));
+    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(rawModels));
+    writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(rawModels));
+    writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(rawModels));
+    await generateGraphqlApiTypes();
+    await generateGraphqlClientTypes();
+  });
+
+program
+  .command('generate-models')
+  .description('Generate models.json')
+  .action(async () => {
+    const rawModels = await parseModels();
+    const generatedFolderPath = await getSetting('generatedFolderPath');
+    writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
+  });
+
+program
+  .command('generate-schema')
+  .description('Generate schema')
+  .action(async () => {
+    const rawModels = await parseModels();
+    const generatedFolderPath = await getSetting('generatedFolderPath');
+    writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(rawModels));
+  });
+
+program
+  .command('generate-mutation-queries')
+  .description('Generate mutation-queries')
+  .action(async () => {
+    const rawModels = await parseModels();
+    const generatedFolderPath = await getSetting('generatedFolderPath');
+    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(rawModels));
+  });
+
+program
+  .command('generate-db-types')
+  .description('Generate DB types')
+  .action(async () => {
+    const rawModels = await parseModels();
+    const generatedFolderPath = await getSetting('generatedFolderPath');
+    writeToFile(`${generatedFolderPath}/db/index.ts`, generateMutations(rawModels));
+  });
+
+program
+  .command('generate-knex-types')
+  .description('Generate Knex types')
+  .action(async () => {
+    const rawModels = await parseModels();
+    const generatedFolderPath = await getSetting('generatedFolderPath');
+    writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(rawModels));
+  });
+
+program
+  .command('generate-graphql-api-types')
+  .description('Generate Graphql API types')
+  .action(async () => {
+    await generateGraphqlApiTypes();
+  });
+
+program
+  .command('generate-graphql-client-types')
+  .description('Generate Graphql client types')
+  .action(async () => {
+    await generateGraphqlClientTypes();
+  });
+
+program
+  .command('generate-migration')
+  .description('Generate Migration')
+  .action(async () => {
+    const git = simpleGit();
+
+    let name = process.argv[process.argv.indexOf('gqm') + 1] || (await git.branch()).current.split('/').pop();
+
+    if (name && ['staging', 'production'].includes(name)) {
+      name = await readLine('Migration name:');
+    }
+
+    const knexfile = await parseKnexfile();
+    const db = knex(knexfile);
+
+    try {
+      const rawModels = await parseModels();
+      const migrations = await new MigrationGenerator(db, rawModels).generate();
+
+      writeToFile(`migrations/${getMigrationDate()}_${name}.ts`, migrations);
+    } finally {
+      await db.destroy();
+    }
+  });
+
+program
+  .command('*', { noHelp: true })
+  .description('Invalid command')
+  .action(() => {
+    console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args.join(' '));
+    process.exit(1);
+  });
+
+// Parse the arguments
+program.parse(process.argv);

package/src/bin/gqm/parse-knexfile.ts

@@ -0,0 +1,21 @@
+import { IndentationText, Project } from 'ts-morph';
+import { ensureFileExists } from './settings';
+import { staticEval } from './static-eval';
+import { KNEXFILE } from './templates';
+import { findDeclarationInFile } from './utils';
+
+export const KNEXFILE_PATH = `knexfile.ts`;
+
+export const parseKnexfile = async () => {
+  const project = new Project({
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+    },
+  });
+  ensureFileExists(KNEXFILE_PATH, KNEXFILE);
+
+  const sourceFile = project.addSourceFileAtPath(KNEXFILE_PATH);
+  const configDeclaration = findDeclarationInFile(sourceFile, 'config');
+  const config = staticEval(configDeclaration, {});
+  return config;
+};

package/src/bin/gqm/parse-models.ts

@@ -0,0 +1,24 @@
+import { IndentationText, Project } from 'ts-morph';
+import { RawModels } from '../..';
+import { getSetting, writeToFile } from './settings';
+import { staticEval } from './static-eval';
+import { findDeclarationInFile } from './utils';
+
+export const parseModels = async () => {
+  const project = new Project({
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+    },
+  });
+  const modelsPath = await getSetting('modelsPath');
+  const sourceFile = project.addSourceFileAtPath(modelsPath);
+
+  const modelsDeclaration = findDeclarationInFile(sourceFile, 'rawModels');
+
+  const rawModels = staticEval(modelsDeclaration, {});
+
+  const generatedFolderPath = await getSetting('generatedFolderPath');
+  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
+
+  return rawModels as RawModels;
+};

package/src/bin/gqm/readline.ts

@@ -0,0 +1,15 @@
+import readline from 'readline';
+
+export const readLine = (prompt: string): Promise<string> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise<string>((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+};

package/src/bin/gqm/settings.ts

@@ -0,0 +1,112 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+import { readLine } from './readline';
+import { CLIENT_CODEGEN, EMPTY_MODELS, GRAPHQL_CODEGEN } from './templates';
+
+const SETTINGS_PATH = '.gqmrc.json';
+
+const DEFAULTS = {
+  modelsPath: {
+    question: 'What is the models path?',
+    defaultValue: 'src/config/models.ts',
+    init: (path: string) => {
+      ensureFileExists(path, EMPTY_MODELS);
+    },
+  },
+  generatedFolderPath: {
+    question: 'What is the path for generated stuff?',
+    defaultValue: 'src/generated',
+    init: (path: string) => {
+      ensureFileExists(`${path}/.gitkeep`, '');
+      ensureFileExists(`${path}/db/.gitkeep`, '');
+      ensureFileExists(`${path}/api/.gitkeep`, '');
+      ensureFileExists(`${path}/client/.gitkeep`, '');
+      ensureFileExists(`graphql-codegen.yml`, GRAPHQL_CODEGEN(path));
+      ensureFileExists(`client-codegen.yml`, CLIENT_CODEGEN(path));
+    },
+  },
+};
+
+type Settings = {
+  modelsPath: string;
+  generatedFolderPath: string;
+};
+
+const initSetting = async (name: string) => {
+  const { question, defaultValue, init } = DEFAULTS[name];
+  const value = (await readLine(`${question} (${defaultValue})`)) || defaultValue;
+  init(value);
+  return value;
+};
+
+const initSettings = async () => {
+  const settings: Settings = {} as Settings;
+  for (const name of Object.keys(DEFAULTS)) {
+    settings[name] = await initSetting(name);
+  }
+  saveSettings(settings);
+};
+
+const saveSettings = (settings: Settings) => {
+  writeToFile(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+};
+
+export const getSettings = async (): Promise<Settings> => {
+  if (!existsSync(SETTINGS_PATH)) {
+    await initSettings();
+  }
+  return JSON.parse(readFileSync(SETTINGS_PATH, 'utf8'));
+};
+
+export const getSetting = async (name: keyof Settings): Promise<string> => {
+  const settings = await getSettings();
+  if (!(name in settings)) {
+    settings[name] = await initSetting(name);
+    saveSettings(settings);
+  }
+  return settings[name];
+};
+
+const ensureDirectoryExists = (filePath: string) => {
+  const dir = dirname(filePath);
+
+  if (existsSync(dir)) {
+    return true;
+  }
+
+  ensureDirectoryExists(dir);
+
+  try {
+    mkdirSync(dir);
+    return true;
+  } catch (err) {
+    if (err.code === 'EEXIST') {
+      return true;
+    }
+    throw err;
+  }
+};
+
+export const ensureFileExists = (filePath: string, content: string) => {
+  if (!existsSync(filePath)) {
+    console.info(`Creating ${filePath}`);
+    ensureDirectoryExists(filePath);
+    writeFileSync(filePath, content);
+  }
+};
+
+export const writeToFile = (filePath: string, content: string) => {
+  ensureDirectoryExists(filePath);
+  if (existsSync(filePath)) {
+    const currentContent = readFileSync(filePath, 'utf-8');
+    if (content === currentContent) {
+      // console.info(`${filePath} unchanged`);
+    } else {
+      writeFileSync(filePath, content);
+      console.info(`${filePath} updated`);
+    }
+  } else {
+    writeFileSync(filePath, content);
+    console.info(`Created ${filePath}`);
+  }
+};

package/src/bin/gqm/static-eval.ts

@@ -0,0 +1,203 @@
+import { Dictionary } from 'lodash';
+import {
+  CaseClause,
+  ElementAccessExpression,
+  Identifier,
+  Node,
+  ObjectLiteralExpression,
+  PrefixUnaryExpression,
+  ShorthandPropertyAssignment,
+  SyntaxKind,
+  TemplateExpression,
+  TemplateTail,
+} from 'ts-morph';
+import { Visitor, visit } from './visitor';
+
+export const staticEval = (node: Node, context: Dictionary<unknown>) =>
+  visit<unknown, Dictionary<unknown>>(node, context, visitor);
+
+const visitor: Visitor<unknown, Dictionary<unknown>> = {
+  undefined: () => undefined,
+  [SyntaxKind.VariableDeclaration]: (node, context) => staticEval(node.getInitializer(), context),
+  [SyntaxKind.ArrayLiteralExpression]: (node, context) => {
+    const values: unknown[] = [];
+    for (const value of node.getElements()) {
+      if (value.isKind(SyntaxKind.SpreadElement)) {
+        values.push(...(staticEval(value, context) as unknown[]));
+      } else {
+        values.push(staticEval(value, context));
+      }
+    }
+    return values;
+  },
+  [SyntaxKind.ObjectLiteralExpression]: (node: ObjectLiteralExpression, context) => {
+    const result: Dictionary<unknown> = {};
+    for (const property of node.getProperties()) {
+      Object.assign(result, staticEval(property, context));
+    }
+    return result;
+  },
+  [SyntaxKind.StringLiteral]: (node) => node.getLiteralValue(),
+  [SyntaxKind.PropertyAssignment]: (node, context) => ({
+    [node.getName()]: staticEval(node.getInitializer(), context),
+  }),
+  [SyntaxKind.ShorthandPropertyAssignment]: (node: ShorthandPropertyAssignment, context) => ({
+    [node.getName()]: staticEval(node.getNameNode(), context),
+  }),
+  [SyntaxKind.SpreadElement]: (node, context) => staticEval(node.getExpression(), context),
+  [SyntaxKind.SpreadAssignment]: (node, context) => staticEval(node.getExpression(), context),
+  [SyntaxKind.Identifier]: (node: Identifier, context) => {
+    switch (node.getText()) {
+      case 'undefined':
+        return undefined;
+      case 'process':
+        return process;
+    }
+    const definitionNodes = node.getDefinitionNodes();
+    if (!definitionNodes.length) {
+      throw new Error(`No definition node found for identifier ${node.getText()}.`);
+    }
+    return staticEval(definitionNodes[0], context);
+  },
+  [SyntaxKind.ParenthesizedExpression]: (node, context) => staticEval(node.getExpression(), context),
+  [SyntaxKind.AsExpression]: (node, context) => staticEval(node.getExpression(), context),
+  [SyntaxKind.ConditionalExpression]: (node, context) =>
+    staticEval(node.getCondition(), context)
+      ? staticEval(node.getWhenTrue(), context)
+      : staticEval(node.getWhenFalse(), context),
+  [SyntaxKind.TrueKeyword]: () => true,
+  [SyntaxKind.FalseKeyword]: () => false,
+  [SyntaxKind.NumericLiteral]: (node) => node.getLiteralValue(),
+  [SyntaxKind.CallExpression]: (node, context) => {
+    const method = staticEval(node.getExpression(), context) as (...args: unknown[]) => unknown;
+    const args = node.getArguments().map((arg) => staticEval(arg, context));
+    return method(...args);
+  },
+  [SyntaxKind.PropertyAccessExpression]: (node, context) => {
+    const target = staticEval(node.getExpression(), context);
+    const property = target[node.getName()];
+    if (typeof property === 'function') {
+      if (Array.isArray(target)) {
+        switch (node.getName()) {
+          case 'map':
+          case 'flatMap':
+          case 'includes':
+          case 'some':
+          case 'find':
+          case 'filter':
+            return target[node.getName()].bind(target);
+        }
+      } else if (typeof target === 'string') {
+        const name = node.getName() as keyof string;
+        switch (name) {
+          case 'slice':
+          case 'toUpperCase':
+          case 'toLowerCase':
+            return target[name].bind(target);
+        }
+      }
+      throw new Error(`Cannot handle method ${node.getName()} on type ${typeof target}`);
+    }
+
+    return property;
+  },
+  [SyntaxKind.ArrowFunction]: (node, context) => {
+    return (...args: unknown[]) => {
+      const parameters: Dictionary<unknown> = {};
+      let i = 0;
+      for (const parameter of node.getParameters()) {
+        parameters[parameter.getName()] = args[i];
+        i++;
+      }
+      return staticEval(node.getBody(), { ...context, ...parameters });
+    };
+  },
+  [SyntaxKind.Block]: (node, context) => {
+    for (const statement of node.getStatements()) {
+      return staticEval(statement, context);
+    }
+  },
+  [SyntaxKind.CaseClause]: (node, context) => {
+    const statements = node.getStatements();
+    if (statements.length !== 1) {
+      console.error(node.getText());
+      throw new Error(`Can only handle code blocks with 1 statement.`);
+    }
+    return staticEval(statements[0], context);
+  },
+  [SyntaxKind.DefaultClause]: (node, context) => {
+    const statements = node.getStatements();
+    if (statements.length !== 1) {
+      console.error(node.getText());
+      throw new Error(`Can only handle code blocks with exactly 1 statement.`);
+    }
+    return staticEval(statements[0], context);
+  },
+  [SyntaxKind.ReturnStatement]: (node, context) => {
+    return staticEval(node.getExpression(), context);
+  },
+  [SyntaxKind.SwitchStatement]: (node, context) => {
+    const value = staticEval(node.getExpression(), context);
+    let active = false;
+    for (const clause of node.getCaseBlock().getClauses()) {
+      switch (clause.getKind()) {
+        case SyntaxKind.DefaultClause:
+          return staticEval(clause, context);
+        case SyntaxKind.CaseClause: {
+          const caseClause: CaseClause = clause.asKindOrThrow(SyntaxKind.CaseClause);
+          if (caseClause.getStatements().length && active) {
+            return staticEval(clause, context);
+          }
+          const caseValue = staticEval(caseClause.getExpression(), context);
+          if (value === caseValue) {
+            active = true;
+            if (caseClause.getStatements().length) {
+              return staticEval(clause, context);
+            }
+          }
+        }
+      }
+    }
+  },
+  [SyntaxKind.Parameter]: (node, context) => context[node.getName()],
+  [SyntaxKind.BinaryExpression]: (node, context) => {
+    switch (node.getOperatorToken().getKind()) {
+      case SyntaxKind.EqualsEqualsEqualsToken:
+        return staticEval(node.getLeft(), context) === staticEval(node.getRight(), context);
+      case SyntaxKind.BarBarToken:
+        return staticEval(node.getLeft(), context) || staticEval(node.getRight(), context);
+      default:
+        throw new Error(`Cannot handle operator of kind ${node.getOperatorToken().getKindName()}`);
+    }
+  },
+  [SyntaxKind.SatisfiesExpression]: (node, context) => staticEval(node.getExpression(), context),
+  [SyntaxKind.TemplateExpression]: (node: TemplateExpression, context) =>
+    node.getHead().getLiteralText() +
+    node
+      .getTemplateSpans()
+      .map((span) => (staticEval(span.getExpression(), context) as string) + staticEval(span.getLiteral(), context))
+      .join(''),
+  [SyntaxKind.TemplateTail]: (node: TemplateTail) => node.getLiteralText(),
+  [SyntaxKind.TemplateMiddle]: (node) => node.getLiteralText(),
+  [SyntaxKind.PrefixUnaryExpression]: (node: PrefixUnaryExpression, context) => {
+    switch (node.getOperatorToken()) {
+      case SyntaxKind.PlusToken:
+        return +staticEval(node.getOperand(), context);
+      case SyntaxKind.MinusToken:
+        return -staticEval(node.getOperand(), context);
+      case SyntaxKind.TildeToken:
+        return ~staticEval(node.getOperand(), context);
+      case SyntaxKind.ExclamationToken:
+        return !staticEval(node.getOperand(), context);
+      case SyntaxKind.PlusPlusToken:
+      case SyntaxKind.MinusMinusToken:
+        throw new Error(`Cannot handle assignments.`);
+    }
+  },
+  [SyntaxKind.ElementAccessExpression]: (node: ElementAccessExpression, context) => {
+    const target = staticEval(node.getExpression(), context);
+    const argument = staticEval(node.getArgumentExpression(), context) as string;
+    return target[argument];
+  },
+  [SyntaxKind.NoSubstitutionTemplateLiteral]: (node) => node.getLiteralValue(),
+};

package/src/bin/gqm/templates.ts

@@ -0,0 +1,64 @@
+export const EMPTY_MODELS = `
+import { RawModels, getModels } from '@smartive/graphql-magic';
+
+export const rawModels: RawModels = [
+  {
+    kind: 'entity',
+    name: 'User',
+    fields: []
+  },
+]
+
+export const models = getModels(rawModels);
+`;
+
+export const GRAPHQL_CODEGEN = (path: string) => `
+overwrite: true
+schema: '${path}/schema.graphql'
+documents: null
+generates:
+  ${path}/api/index.ts:
+    plugins:
+      - 'typescript'
+      - 'typescript-resolvers'
+      - add:
+          content: "import { DateTime } from 'luxon'"
+config:
+  scalars:
+    DateTime: DateTime
+`;
+
+export const CLIENT_CODEGEN = (path: string) => `
+schema: ${path}/schema.graphql
+documents: [ './src/**/*.ts', './src/**/*.tsx' ]
+generates:
+  ${path}/client/index.ts:
+    plugins:
+      - typescript
+      - typescript-operations
+      - typescript-compatibility
+
+config:
+  preResolveTypes: true # Simplifies the generated types
+  namingConvention: keep # Keeps naming as-is
+  nonOptionalTypename: true # Forces \`__typename\` on all selection sets
+  skipTypeNameForRoot: true # Don't generate __typename for root types
+  avoidOptionals: # Avoids optionals on the level of the field
+    field: true
+  scalars:
+    DateTime: string
+`;
+
+export const KNEXFILE = `
+const config = {
+  client: 'postgresql',
+  connection: {
+    host: process.env.DATABASE_HOST,
+    database: process.env.DATABASE_NAME,
+    user: process.env.DATABASE_USER,
+    password: process.env.DATABASE_PASSWORD,
+  },
+} as const;
+
+export default config;
+`;

package/src/bin/gqm/utils.ts

@@ -0,0 +1,23 @@
+import { SourceFile, SyntaxKind, SyntaxList } from 'ts-morph';
+
+export const findDeclarationInFile = (sourceFile: SourceFile, name: string) => {
+  const syntaxList = sourceFile.getChildrenOfKind(SyntaxKind.SyntaxList)[0];
+  if (!syntaxList) {
+    throw new Error('No SyntaxList');
+  }
+  const declaration = findDeclaration(syntaxList, name);
+  if (!declaration) {
+    throw new Error(`No ${name} declaration`);
+  }
+  return declaration;
+};
+
+const findDeclaration = (syntaxList: SyntaxList, name: string) => {
+  for (const variableStatement of syntaxList.getChildrenOfKind(SyntaxKind.VariableStatement)) {
+    for (const declaration of variableStatement.getDeclarationList().getDeclarations()) {
+      if (declaration.getName() === name) {
+        return declaration;
+      }
+    }
+  }
+};

package/src/bin/gqm/visitor.ts

@@ -0,0 +1,29 @@
+import { KindToNodeMappings, Node, SyntaxKind } from 'ts-morph';
+import { get } from '../..';
+
+export type Visitor<T, C> = {
+  undefined?: () => T;
+  unknown?: (node: Node) => T;
+} & {
+  [kind in keyof KindToNodeMappings]?: (node: KindToNodeMappings[kind], context: C) => T;
+};
+
+export const visit = <T, C>(node: Node | undefined, context: C, visitor: Visitor<T, C>) => {
+  const kind: undefined | keyof KindToNodeMappings = node?.getKind();
+  if (kind in visitor) {
+    return visitor[kind](node.asKindOrThrow(kind), context);
+  }
+
+  if ('unknown' in visitor) {
+    return visitor.unknown(node);
+  }
+
+  console.error(node.getText());
+  console.error(node.getParent().getText());
+  throw new Error(
+    `Cannot handle kind ${get(
+      Object.entries(SyntaxKind).find(([, val]) => val === kind),
+      0
+    )}`
+  );
+};

package/src/client/mutations.ts

@@ -1,11 +1,12 @@
 import upperCase from 'lodash/upperCase';
-import { Models } from '../models/models';
+import { isEntityModel } from '..';
+import { RawModels } from '../models/models';
 
 const constantCase = (str: string) => upperCase(str).replace(/ /g, '_');
 
-export const generateMutations = (models: Models) => {
+export const generateMutations = (models: RawModels) => {
   const parts: string[] = [];
-  for (const { name, creatable, updatable, deletable } of models) {
+  for (const { name, creatable, updatable, deletable } of models.filter(isEntityModel)) {
     if (creatable) {
       parts.push(
         `export const CREATE_${constantCase(

package/src/migrations/generate.ts

@@ -580,6 +580,7 @@ export class MigrationGenerator {
     };
     const kind = field.kind;
     switch (kind) {
+      case undefined:
       case 'primitive':
         switch (field.type) {
           case 'Boolean':
@@ -645,3 +646,15 @@ export class MigrationGenerator {
     }
   }
 }
+
+export const getMigrationDate = () => {
+  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}`;
+};