@smartive/graphql-magic 7.0.1 → 8.1.0

package/src/gqm/codegen.ts

@@ -0,0 +1,47 @@
+import { generate } from '@graphql-codegen/cli';
+import { getSetting } from './settings';
+
+export const generateGraphqlApiTypes = async () => {
+  const generatedFolderPath = await getSetting('generatedFolderPath');
+  await generate({
+    overwrite: true,
+    schema: `${generatedFolderPath}/schema.graphql`,
+    documents: null,
+    generates: {
+      [`${generatedFolderPath}/api/index.ts`]: {
+        plugins: ['typescript', 'typescript-resolvers', { add: { content: `import { DateTime } from 'luxon';` } }],
+      },
+    },
+    config: {
+      scalars: {
+        DateTime: 'DateTime',
+      },
+    },
+  });
+};
+
+export const generateGraphqlClientTypes = async () => {
+  const generatedFolderPath = await getSetting('generatedFolderPath');
+  await generate({
+    schema: `${generatedFolderPath}/schema.graphql`,
+    documents: ['./src/**/*.ts', './src/**/*.tsx'],
+    generates: {
+      [`${generatedFolderPath}/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',
+      },
+    },
+  });
+};

package/src/gqm/index.ts

@@ -0,0 +1,11 @@
+// created from 'create-ts-index'
+
+export * from './codegen';
+export * from './parse-knexfile';
+export * from './parse-models';
+export * from './readline';
+export * from './settings';
+export * from './static-eval';
+export * from './templates';
+export * from './utils';
+export * from './visitor';

package/src/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/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/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/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/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/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/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/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/index.ts

@@ -3,6 +3,7 @@
 export * from './api';
 export * from './client';
 export * from './db';
+export * from './gqm';
 export * from './migrations';
 export * from './models';
 export * from './permissions';

package/src/migrations/generate.ts

@@ -131,7 +131,7 @@ export class MigrationGenerator {
           model,
           model.fields.filter(
             ({ name, ...field }) =>
-              field.kind !== 'raw' &&
+              field.kind !== 'custom' &&
               !this.columns[model.name].some(
                 (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
               )
@@ -198,7 +198,7 @@ export class MigrationGenerator {
           const revisionTable = `${model.name}Revision`;
           const missingRevisionFields = model.fields.filter(
             ({ name, updatable, ...field }) =>
-              field.kind !== 'raw' &&
+              field.kind !== 'custom' &&
               updatable &&
               !this.columns[revisionTable].some(
                 (col) => col.name === (field.kind === 'relation' ? field.foreignKey || `${name}Id` : name)
@@ -210,7 +210,7 @@ export class MigrationGenerator {
           const revisionFieldsToRemove = model.fields.filter(
             ({ name, updatable, generated, ...field }) =>
               !generated &&
-              field.kind !== 'raw' &&
+              field.kind !== 'custom' &&
               !updatable &&
               !(field.kind === 'relation' && field.foreignKey === 'id') &&
               this.columns[revisionTable].some(
@@ -580,6 +580,7 @@ export class MigrationGenerator {
     };
     const kind = field.kind;
     switch (kind) {
+      case undefined:
       case 'primitive':
         switch (field.type) {
           case 'Boolean':
@@ -636,8 +637,8 @@ export class MigrationGenerator {
       case 'json':
         this.writer.write(`table.json('${typeToField(field.type)}')`);
         break;
-      case 'raw':
-        throw new Error("Raw fields aren't stored in the database");
+      case 'custom':
+        throw new Error("Custom fields aren't stored in the database");
       default: {
         const exhaustiveCheck: never = kind;
         throw new Error(exhaustiveCheck);
@@ -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}`;
+};

package/src/models/models.ts

@@ -14,11 +14,15 @@ export type RawModel = {
   | { kind: 'raw-enum'; values: string[] }
   | { kind: 'interface'; fields: ModelField[] }
   | {
-      kind: 'raw';
-      fields: RawObjectField[];
+      kind: 'input';
+      fields: ObjectField[];
     }
   | {
       kind: 'object';
+      fields: ObjectField[];
+    }
+  | {
+      kind: 'entity';
       interfaces?: string[];
       queriable?: boolean;
       listQueriable?: boolean;
@@ -41,8 +45,9 @@ export type ScalarModel = Extract<RawModel, { kind: 'scalar' }>;
 export type EnumModel = Extract<RawModel, { kind: 'enum' }>;
 export type RawEnumModel = Extract<RawModel, { kind: 'raw-enum' }>;
 export type InterfaceModel = Extract<RawModel, { kind: 'interface' }>;
-export type RawObjectModel = Extract<RawModel, { kind: 'raw' }>;
 export type ObjectModel = Extract<RawModel, { kind: 'object' }>;
+export type InputModel = Extract<RawModel, { kind: 'input' }>;
+export type EntityModel = Extract<RawModel, { kind: 'entity' }>;
 
 type BaseNumberType = {
   unit?: 'million';
@@ -81,9 +86,9 @@ type FieldBase2 =
       | { type: 'Upload' }
     ))
   | { kind: 'enum'; type: string; possibleValues?: Value[] }
-  | { kind: 'raw'; type: string };
+  | { kind: 'custom'; type: string };
 
-export type RawObjectField = FieldBase & FieldBase2;
+export type ObjectField = FieldBase & FieldBase2;
 
 export type ModelField = FieldBase &
   (
@@ -149,12 +154,12 @@ export type FloatField = Extract<PrimitiveField, { type: 'Float' }>;
 export type UploadField = Extract<PrimitiveField, { type: 'Upload' }>;
 export type JsonField = Extract<ModelField, { kind: 'json' }>;
 export type EnumField = Extract<ModelField, { kind: 'enum' }>;
-export type RawField = Extract<ModelField, { kind: 'raw' }>;
+export type CustomField = Extract<ModelField, { kind: 'custom' }>;
 export type RelationField = Extract<ModelField, { kind: 'relation' }>;
 
 export type Models = Model[];
 
-export type Model = ObjectModel & {
+export type Model = EntityModel & {
   fieldsByName: Record<string, ModelField>;
   relations: Relation[];
   relationsByName: Record<string, Relation>;