@baeta/plugin-prisma 0.0.2 → 0.0.13

package/lib/print/module.ts

@@ -1,65 +0,0 @@
-import { camelCase } from 'change-case-all';
-import { parse } from 'path';
-import { ModuleResolvers } from '../resolver-builder';
-import { printRelationResolver, printResolver } from './module-resolver';
-
-export function printModule(model: ModuleResolvers) {
-  const name = model.name;
-  const moduleName = `${camelCase(name)}Module`;
-
-  const hasQueries = model.queries.length > 0;
-  const hasMutations = model.mutations.length > 0;
-  const hasRelations = model.relations.length > 0;
-
-  const queries = model.queries.map((operations) => printResolver('Query', operations));
-
-  const mutations = model.mutations.map((operations) =>
-    printResolver('Mutation', operations)
-  );
-
-  const relations = model.relations.map((relation) =>
-    printRelationResolver(model.name, relation)
-  );
-
-  return [
-    printImports(name),
-    printInit(moduleName, name),
-    printDestructure(moduleName, model.name, hasQueries, hasMutations, hasRelations),
-    queries.join('\n\n'),
-    mutations.join('\n\n'),
-    relations.join('\n\n'),
-  ].join('\n\n');
-}
-
-export function printModuleExport(filename: string) {
-  const exportFile = parse(filename).name;
-  return `export * from "./${exportFile}";`;
-}
-
-function printImports(name: string) {
-  return [`import { create${name}Module } from "../typedef";`].join('\n');
-}
-
-function printInit(moduleName: string, name: string) {
-  return [`export const ${moduleName} = create${name}Module();`].join('\n');
-}
-
-function printDestructure(
-  moduleName: string,
-  modelName: string,
-  hasQueries: boolean,
-  hasMutations: boolean,
-  hasRelations: boolean
-) {
-  const values = [];
-  if (hasQueries) {
-    values.push('Query');
-  }
-  if (hasMutations) {
-    values.push('Mutation');
-  }
-  if (hasRelations) {
-    values.push(modelName);
-  }
-  return `const { ${values.join(', ')} } = ${moduleName};`;
-}

package/lib/print/object.ts

@@ -1,15 +0,0 @@
-import { filterEmpty, indent } from '../../utils/string';
-
-export function printObject(
-  kind: string,
-  name: string,
-  fields: Array<string | undefined>,
-  directive?: string
-) {
-  const directiveLine = directive ? ` ${directive}` : '';
-  const firstLine = kind + ' ' + name + directiveLine + ' {';
-  const content = filterEmpty(fields).map(indent(2)).join('\n');
-  const lastLine = '}';
-
-  return [firstLine, content, lastLine].join('\n');
-}

package/lib/print/prisma-enum-model.ts

@@ -1,7 +0,0 @@
-import { DMMF } from '../dmmf';
-import { printObject } from './object';
-
-export function printPrismaEnumModel(enumModel: DMMF.DatamodelEnum) {
-  const fields = Object.values(enumModel.values).map((value) => value.name);
-  return printObject('enum', enumModel.name, fields);
-}

package/lib/print/prisma-enum.ts

@@ -1,6 +0,0 @@
-import { DMMF } from '../dmmf';
-import { printObject } from './object';
-
-export function printPrismaEnum(enumType: DMMF.SchemaEnum) {
-  return printObject('enum', enumType.name, enumType.values);
-}

package/lib/print/prisma-input.ts

@@ -1,45 +0,0 @@
-import { DMMF } from '../dmmf';
-import { printInputConstraintDirective } from './directive';
-import { printObject } from './object';
-import { printType } from './type';
-
-export function printPrismaInput(inputType: DMMF.InputType) {
-  const { minNumFields, maxNumFields } = inputType.constraints;
-  const requireConstraint = minNumFields === 1 && inputType.fields.length === 1;
-
-  let directive: string | undefined;
-  if (!requireConstraint) {
-    directive = printInputConstraintDirective(minNumFields, maxNumFields);
-  }
-
-  const fields = inputType.fields.map((field) =>
-    printInputField(field, requireConstraint)
-  );
-
-  return printObject('input', inputType.name, fields, directive);
-}
-
-function printInputField(field: DMMF.SchemaArg, requireConstraint: boolean) {
-  const type = printInputFieldScalar(field, requireConstraint);
-  if (!type) {
-    return;
-  }
-  return `${field.name}: ${type}`;
-}
-
-function printInputFieldScalar(field: DMMF.SchemaArg, requireConstraint: boolean) {
-  const inputTypes = field.inputTypes.filter((inputType) => inputType.type !== 'Null');
-
-  if (inputTypes.length === 0) {
-    return;
-  }
-
-  const inputType = inputTypes[inputTypes.length - 1];
-  const inputTypeName = inputType.type.toString();
-
-  return printType(inputTypeName, {
-    kind: inputType.location,
-    list: inputType.isList,
-    required: (field.isRequired || requireConstraint) && !field.isNullable,
-  });
-}

package/lib/print/prisma-model.ts

@@ -1,24 +0,0 @@
-import { DMMF } from '../dmmf';
-import { printObject } from './object';
-import { printType } from './type';
-
-export function printPrismaModel(model: DMMF.Model) {
-  const fields = model.fields.map((field) => printModelField(field));
-  return printObject('type', model.name, fields);
-}
-
-function printModelField(field: DMMF.Field) {
-  return `${field.name}: ${printFieldScalar(field)}`;
-}
-
-function printFieldScalar(field: DMMF.Field) {
-  let name = field.type;
-  if (field.isId) {
-    name = 'ID';
-  }
-  return printType(name, {
-    kind: field.kind,
-    list: field.isList,
-    required: field.isRequired && field.kind !== 'object',
-  });
-}

package/lib/print/prisma-output.ts

@@ -1,86 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

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

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

@@ -1,69 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

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

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

@@ -1,150 +0,0 @@
-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

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