@baeta/plugin-prisma 0.0.2

package/lib/print/prisma-output.ts

@@ -0,0 +1,86 @@
+import { filterEmpty } from '../../utils/string';
+import { DMMF } from '../dmmf';
+import { ModelsOperationsMap } from '../model-operations';
+import { printObject } from './object';
+import { mapPrismaTypeToScalar } from './prisma-scalar';
+import { printType } from './type';
+
+export function printPrismaOutput(outputType: DMMF.OutputType) {
+  const content = outputType.fields.map((field) => printOutputTypeField(field));
+  return printObject('type', outputType.name, content);
+}
+
+export function printPrismaOperation(
+  operations: ModelsOperationsMap,
+  field: DMMF.SchemaField
+) {
+  const operation = operations[field.name];
+
+  if (!operation) {
+    return;
+  }
+
+  const args = printOutputFieldArgs(field.args);
+  const output = printOutputFieldReturnType(field);
+  return `${operation.operation}${args}: ${output}`;
+}
+
+function printOutputTypeField(field: DMMF.SchemaField) {
+  const args = printOutputFieldArgs(field.args);
+  const returnType = printOutputFieldReturnType(field);
+  return `${field.name}${args}: ${returnType}`;
+}
+
+function printOutputFieldArgs(args: DMMF.SchemaArg[]) {
+  const argList = filterEmpty(args.map((arg) => printOutputFieldArg(arg)));
+
+  if (argList.length === 0) {
+    return '';
+  }
+
+  return `(${argList.join(', ')})`;
+}
+
+function printOutputFieldArg(arg: DMMF.SchemaArg) {
+  const type = printOutputFieldArgType(arg);
+
+  if (!type) {
+    return;
+  }
+
+  return `${arg.name}: ${type}`;
+}
+
+function printOutputFieldArgType(arg: DMMF.SchemaArg) {
+  const inputType = arg.inputTypes[0];
+
+  if (!inputType) {
+    return;
+  }
+
+  let type = inputType.type.toString();
+
+  if (inputType.location === 'scalar') {
+    type = mapPrismaTypeToScalar(type);
+  }
+
+  if (inputType.isList) {
+    type = `[${type}!]`;
+  }
+
+  if (arg.isRequired) {
+    type += '!';
+  }
+
+  return type;
+}
+
+function printOutputFieldReturnType(field: DMMF.SchemaField) {
+  const outputType = field.outputType;
+
+  return printType(outputType.type.toString(), {
+    kind: outputType.location,
+    list: outputType.isList,
+    required: !field.isNullable,
+  });
+}

package/lib/print/prisma-scalar.ts

@@ -0,0 +1,46 @@
+export enum PrismaScalars {
+  string = 'String',
+  boolean = 'Boolean',
+  int = 'Int',
+  float = 'Float',
+  dateTime = 'DateTime',
+  json = 'Json',
+  bigInt = 'BigInt',
+  decimal = 'Decimal',
+  bytes = 'Bytes',
+}
+
+export function mapPrismaTypeToScalar(scalar: string) {
+  switch (scalar) {
+    case PrismaScalars.string: {
+      return 'String';
+    }
+    case PrismaScalars.boolean: {
+      return 'Boolean';
+    }
+    case PrismaScalars.int: {
+      return 'Int';
+    }
+    case PrismaScalars.float: {
+      return 'Float';
+    }
+    case PrismaScalars.dateTime: {
+      return 'DateTime';
+    }
+    case PrismaScalars.json: {
+      return 'Json';
+    }
+    case PrismaScalars.bigInt: {
+      return 'BigInt';
+    }
+    case PrismaScalars.decimal: {
+      return 'Decimal';
+    }
+    case PrismaScalars.bytes: {
+      return 'Bytes';
+    }
+    default: {
+      throw new Error(`Unrecognized scalar type: ${scalar}`);
+    }
+  }
+}

package/lib/print/type.ts

@@ -0,0 +1,37 @@
+import { mapPrismaTypeToScalar } from './prisma-scalar';
+
+interface ScalarOptions {
+  kind?: string;
+  list?: boolean;
+  required?: boolean;
+}
+
+export function printType(name: string, options: ScalarOptions = {}) {
+  let type = name;
+
+  if (options.kind === 'scalar' && name !== 'ID') {
+    type = mapPrismaTypeToScalar(type);
+  }
+
+  if (options.list) {
+    type = `[${type}!]`;
+  }
+
+  if (options.required) {
+    type += '!';
+  }
+
+  return type;
+}
+
+export const scalars = [
+  'scalar DateTime',
+  'scalar BigInt',
+  'scalar Json',
+  'scalar Decimal',
+  'scalar Bytes',
+];
+
+export function printScalars() {
+  return scalars.join('\n');
+}

package/lib/resolver-builder/index.ts

@@ -0,0 +1 @@
+export * from './resolver-builder';

package/lib/resolver-builder/resolver-builder-files.ts

@@ -0,0 +1,69 @@
+import { File } from '@baeta/plugin';
+import { join } from 'path';
+import { Casing, changeCase } from '../../utils/casing';
+import { printModule, printModuleExport } from '../print/module';
+import { printPrismaModule } from '../print/module-prisma';
+import { ModuleResolvers, ModuleResolversMap } from './resolver-builder';
+
+const tag = 'prisma-resolver';
+
+export interface ModuleFileOptions {
+  root: string;
+  casing: Casing;
+  namespace: string;
+  filename: string;
+  createExport?: boolean;
+}
+
+export function createModuleFiles(map: ModuleResolversMap, options: ModuleFileOptions) {
+  const files: File[] = [];
+
+  for (const model of Object.values(map)) {
+    if (!model) {
+      continue;
+    }
+
+    const modulePath = createModulePath(
+      model,
+      options.root,
+      options.namespace,
+      options.casing
+    );
+
+    files.push(createModuleResolvers(model, modulePath, options.filename));
+
+    if (options.createExport !== false) {
+      files.push(createModuleResolversExport(modulePath, options.filename));
+    }
+  }
+
+  files.push(createPrismaModule(options.root));
+
+  return files;
+}
+
+function createModulePath(
+  model: ModuleResolvers,
+  rootDir: string,
+  namespace: string,
+  moduleCasing: Casing
+) {
+  const moduleDir = changeCase(model.name, moduleCasing);
+  return join(rootDir, moduleDir, namespace);
+}
+
+function createModuleResolvers(model: ModuleResolvers, dir: string, filename: string) {
+  const filepath = join(dir, filename);
+  const content = printModule(model);
+  return new File(filepath, content, tag);
+}
+
+function createModuleResolversExport(dir: string, filename: string) {
+  const filepath = join(dir, 'index.ts');
+  const content = printModuleExport(filename);
+  return new File(filepath, content, tag);
+}
+
+function createPrismaModule(dir: string) {
+  return new File(join(dir, 'prisma/resolvers.ts'), printPrismaModule(), tag);
+}

package/lib/resolver-builder/resolver-builder.ts

@@ -0,0 +1,80 @@
+import { concat, mergeDeepWith } from 'ramda';
+import { Store } from '../context';
+import { GenerateOptions } from '../generator';
+import { findModelByOperationSchema, ModelOperations } from '../model-operations';
+import { ModelRelation } from '../model-relations';
+import { createVisitorBuilder } from '../visitor';
+import { createModuleFiles } from './resolver-builder-files';
+
+export interface ModuleResolvers {
+  name: string;
+  queries: ModelOperations[];
+  mutations: ModelOperations[];
+  relations: ModelRelation[];
+}
+
+export type ModuleResolversMap = Record<string, ModuleResolvers | undefined>;
+
+export function createResolversBuilder(store: Store, options: GenerateOptions) {
+  const { operationsMap, relationsMap } = store;
+
+  const modelDefinitions: ModuleResolversMap = {};
+
+  function pushDefinition(model: string, data: Partial<ModuleResolvers>) {
+    const current: ModuleResolvers = modelDefinitions[model] ?? {
+      name: model,
+      queries: [],
+      mutations: [],
+      relations: [],
+    };
+    modelDefinitions[model] = mergeDeepWith(concat, current, data);
+  }
+
+  const visitor = createVisitorBuilder();
+
+  visitor.onModel((model) => {
+    const relations = relationsMap[model.name];
+    if (!relations) {
+      return;
+    }
+
+    pushDefinition(model.name, {
+      relations,
+    });
+  });
+
+  visitor.onOutputType((outputType) => {
+    for (const field of outputType.fields) {
+      const type = outputType.name;
+      const model = findModelByOperationSchema(operationsMap, field);
+      const operations = operationsMap[field.name];
+
+      if (!model || !operations) {
+        continue;
+      }
+
+      if (type === 'Query') {
+        pushDefinition(model, { queries: [operations] });
+      }
+
+      if (type === 'Mutation') {
+        pushDefinition(model, { mutations: [operations] });
+      }
+    }
+  });
+
+  function compose() {
+    return createModuleFiles(modelDefinitions, {
+      root: options.modulesDir,
+      casing: options.casing,
+      filename: 'resolvers.ts',
+      namespace: options.resolverNamespace,
+      createExport: options.resolverExport,
+    });
+  }
+
+  return {
+    compose,
+    visitor,
+  };
+}

package/lib/schema-builder/index.ts

@@ -0,0 +1 @@
+export * from './schema-builder';

package/lib/schema-builder/schema-builder-files.ts

@@ -0,0 +1,150 @@
+import { File } from '@baeta/plugin';
+import { join } from 'path';
+import { Casing, changeCase } from '../../utils/casing';
+import { filterEmpty } from '../../utils/string';
+import { printObject } from '../print/object';
+import {
+  GlobalSchemaDefinition,
+  ModuleDefinitionMap,
+  ModuleSchemaDefinition,
+} from './schema-builder';
+
+const tag = 'prisma-sdl';
+
+export interface SchemaFileOptions {
+  root: string;
+  casing: Casing;
+  namespace: string;
+}
+
+export function createGlobalSchemas(
+  definition: GlobalSchemaDefinition,
+  options: SchemaFileOptions
+) {
+  const dir = options.root + '/prisma';
+
+  const files = [
+    createSchemaFile(
+      dir,
+      createName('prisma', 'enums', options.casing),
+      definition.enums
+    ),
+    createSchemaFile(
+      dir,
+      createName('prisma', 'inputs', options.casing),
+      definition.inputTypes
+    ),
+    createSchemaFile(
+      dir,
+      createName('prisma', 'outputs', options.casing),
+      definition.outputTypes
+    ),
+    createSchemaFile(
+      dir,
+      createName('prisma', 'scalars', options.casing),
+      definition.scalars
+    ),
+    createSchemaFile(
+      dir,
+      createName('prisma', 'directives', options.casing),
+      definition.directives
+    ),
+  ];
+
+  return filterEmpty(files);
+}
+
+export function createModuleSchemas(
+  definitionMap: ModuleDefinitionMap,
+  options: SchemaFileOptions
+) {
+  const definitions = Object.values(definitionMap);
+  return definitions.map((definition) => createModuleSchema(definition, options)).flat();
+}
+
+function createModuleSchema(
+  definition: ModuleSchemaDefinition | undefined,
+  options: SchemaFileOptions
+) {
+  if (!definition) {
+    return [];
+  }
+
+  const name = definition.name;
+  const dir = createSchemaPath(
+    definition,
+    options.root,
+    options.namespace,
+    options.casing
+  );
+
+  const files = [
+    createSchemaFile(dir, createName(name, 'model', options.casing), definition.model),
+    createSchemaFile(dir, createName(name, 'enums', options.casing), definition.enums),
+    createSchemaFile(
+      dir,
+      createName(name, 'input', options.casing),
+      definition.inputTypes
+    ),
+    createSchemaFile(
+      dir,
+      createName(name, 'output', options.casing),
+      definition.outputTypes
+    ),
+    createSDLOperationFile(
+      'Query',
+      dir,
+      createName(name, 'query', options.casing),
+      definition.queries
+    ),
+    createSDLOperationFile(
+      'Mutation',
+      dir,
+      createName(name, 'mutation', options.casing),
+      definition.mutations
+    ),
+  ];
+
+  return filterEmpty(files);
+}
+
+function createSDLOperationFile(
+  type: string,
+  dir: string,
+  name: string,
+  content: string[]
+) {
+  if (content.length === 0) {
+    return;
+  }
+  const fileContent = printObject('type', type, content);
+  return createSchemaFile(dir, name, fileContent);
+}
+
+function createSchemaFile(dir: string, name: string, content: string | string[]) {
+  if (content.length === 0) {
+    return;
+  }
+  const filepath = join(dir, name);
+  const fileContent = Array.isArray(content) ? content.join('\n\n') : content;
+  return new File(filepath, fileContent, tag);
+}
+
+export function createSchemaPath(
+  definition: ModuleSchemaDefinition,
+  rootDir: string,
+  namespace: string,
+  moduleCasing: Casing
+) {
+  const moduleDir = changeCase(definition.name, moduleCasing);
+  return join(rootDir, moduleDir, namespace);
+}
+
+function createName(name: string, suffix?: string, casing: Casing = 'kebab-case') {
+  const names = [changeCase(name, casing)];
+  if (suffix) {
+    names.push(changeCase(suffix, casing));
+  }
+  names.push('gql');
+  return names.join('.');
+}

package/lib/schema-builder/schema-builder-utils.ts

@@ -0,0 +1,3 @@
+export function isOperation(name: string): name is 'Query' | 'Mutation' {
+  return ['Query', 'Mutation'].includes(name);
+}

package/lib/schema-builder/schema-builder.ts

@@ -0,0 +1,186 @@
+import { buildSchema, validateSchema } from 'graphql';
+import { concat, mergeDeepWith } from 'ramda';
+import { Store } from '../context';
+import { DMMF } from '../dmmf';
+import { GenerateOptions } from '../generator';
+import { findModelByEnum } from '../model-enum';
+import { findModelByInput } from '../model-inputs';
+import { findModelByOperationSchema } from '../model-operations';
+import { findModelByOutput } from '../model-outputs';
+import { directives, printDirectives } from '../print/directive';
+import { printPrismaEnum } from '../print/prisma-enum';
+import { printPrismaEnumModel } from '../print/prisma-enum-model';
+import { printPrismaInput } from '../print/prisma-input';
+import { printPrismaModel } from '../print/prisma-model';
+import { printPrismaOperation, printPrismaOutput } from '../print/prisma-output';
+import { printScalars, scalars } from '../print/type';
+import { createVisitorBuilder } from '../visitor';
+import { createGlobalSchemas, createModuleSchemas } from './schema-builder-files';
+import { isOperation } from './schema-builder-utils';
+
+export interface GlobalSchemaDefinition {
+  enums: string[];
+  scalars: string[];
+  directives: string[];
+  inputTypes: string[];
+  outputTypes: string[];
+}
+
+export interface ModuleSchemaDefinition {
+  name: string;
+  model: string[];
+  enums: string[];
+  queries: string[];
+  mutations: string[];
+  inputTypes: string[];
+  outputTypes: string[];
+}
+
+export type ModuleDefinitionMap = Record<string, ModuleSchemaDefinition | undefined>;
+
+export function createSchemaBuilder(store: Store, options: GenerateOptions) {
+  const { models, inputsMap, outputsMap, operationsMap } = store;
+
+  const moduleDefinitions: ModuleDefinitionMap = {};
+
+  let globalDefinitions: GlobalSchemaDefinition = {
+    enums: [],
+    scalars: scalars,
+    directives: directives,
+    inputTypes: [],
+    outputTypes: [],
+  };
+
+  const schema = [printScalars(), printDirectives()];
+
+  function pushDefinition(model: string, def: Partial<ModuleSchemaDefinition>) {
+    const current = moduleDefinitions[model] ?? {
+      name: model,
+      model: [],
+      queries: [],
+      mutations: [],
+      inputTypes: [],
+      outputTypes: [],
+      enums: [],
+    };
+    moduleDefinitions[model] = mergeDeepWith(concat, current, def);
+  }
+
+  function addToGlobal(def: Partial<GlobalSchemaDefinition>) {
+    globalDefinitions = mergeDeepWith(concat, globalDefinitions, def);
+  }
+
+  function addToSchema(value: string) {
+    schema.push(value);
+  }
+
+  const visitor = createVisitorBuilder();
+
+  visitor.onModel((model) => {
+    const content = printPrismaModel(model);
+    addToSchema(content);
+    pushDefinition(model.name, { model: [content] });
+  });
+
+  visitor.onModelEnum((enumModel) => {
+    const content = printPrismaEnumModel(enumModel);
+    addToSchema(content);
+    addToGlobal({ enums: [content] });
+  });
+
+  visitor.onSchemaEnum((enumType) => {
+    const content = printPrismaEnum(enumType);
+    const model = findModelByEnum(models, enumType);
+
+    addToSchema(content);
+
+    if (!model) {
+      return addToGlobal({ enums: [content] });
+    }
+
+    pushDefinition(model, { enums: [content] });
+  });
+
+  visitor.onInputType((inputType) => {
+    const content = printPrismaInput(inputType);
+    const model = findModelByInput(inputsMap, inputType);
+
+    addToSchema(content);
+
+    if (!model) {
+      return addToGlobal({ inputTypes: [content] });
+    }
+
+    pushDefinition(model, { inputTypes: [content] });
+  });
+
+  visitor.onOutputType((outputType) => {
+    const content = printPrismaOutput(outputType);
+
+    addToSchema(content);
+
+    if (isOperation(outputType.name)) {
+      return handleOperation(outputType, outputType.name);
+    }
+
+    const model = findModelByOutput(outputsMap, outputType);
+
+    if (!model) {
+      return addToGlobal({ outputTypes: [content] });
+    }
+
+    pushDefinition(model, { outputTypes: [content] });
+  });
+
+  function handleOperation(outputType: DMMF.OutputType, operation: 'Query' | 'Mutation') {
+    for (const field of outputType.fields) {
+      const model = findModelByOperationSchema(operationsMap, field);
+
+      if (!model) {
+        continue;
+      }
+
+      const content = printPrismaOperation(operationsMap, field);
+
+      if (!content) {
+        continue;
+      }
+
+      if (operation === 'Query') {
+        pushDefinition(model, {
+          queries: [content],
+        });
+      }
+
+      if (operation === 'Mutation') {
+        pushDefinition(model, {
+          mutations: [content],
+        });
+      }
+    }
+  }
+
+  function validate() {
+    validateSchema(buildSchema(schema.join('\n')));
+  }
+
+  function compose() {
+    validate();
+
+    const fileOptions = {
+      root: options.modulesDir,
+      namespace: options.schemaNamespace,
+      casing: options.casing,
+    };
+
+    return [
+      ...createGlobalSchemas(globalDefinitions, fileOptions),
+      ...createModuleSchemas(moduleDefinitions, fileOptions),
+    ];
+  }
+
+  return {
+    visitor,
+    compose,
+  };
+}