@baeta/plugin-prisma 0.0.2

package/.eslintrc.cjs

@@ -0,0 +1,4 @@
+module.exports = {
+  extends: ['@baeta/eslint-config'],
+  parserOptions: { tsconfigRootDir: __dirname },
+};

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @baeta/plugin-prisma
+
+## 0.0.2
+
+### Patch Changes
+
+- Updated dependencies [[`ffa2fe8`](https://github.com/andreisergiu98/baeta/commit/ffa2fe83df6798375252a01ad14bbd37ffd07d50)]:
+  - @baeta/plugin@0.0.5

package/index.ts

@@ -0,0 +1,47 @@
+import { createPluginFactoryV1, GeneratorCtx } from '@baeta/plugin';
+import { createContext, Store } from './lib/context';
+import { generate } from './lib/generator';
+import { Casing } from './utils/casing';
+
+export interface PrismaPluginOptions {
+  casing?: Casing;
+  schemaNamespace?: string;
+  resolverNamespace?: string;
+  resolverExport?: boolean;
+}
+
+export type PrismaPluginCtx = GeneratorCtx<{
+  prisma: Store;
+}>;
+
+export default createPluginFactoryV1<PrismaPluginOptions, PrismaPluginCtx>({
+  name: 'prisma',
+  watch: (baetaConfig, pluginConfig) => {
+    const root = baetaConfig.graphql.modulesDir || 'src/modules';
+    const modulesMatcher =
+      root + '/*/' + (pluginConfig.schemaNamespace || 'prisma-schema') + '/**';
+
+    const prismaModule = root + '/prisma' + '/**';
+
+    return {
+      include: [],
+      ignore: [modulesMatcher, prismaModule],
+    };
+  },
+  setup: async (params) => {
+    params.ctx.prisma = await createContext();
+    return params.next();
+  },
+  generate: async (params) => {
+    const files = await generate(params.ctx.prisma, {
+      modulesDir: params.ctx.config.graphql.modulesDir || 'src/modules',
+      casing: params.config.casing || 'kebab-case',
+      schemaNamespace: params.config.schemaNamespace || 'prisma-schema',
+      resolverNamespace: params.config.resolverNamespace || 'prisma-resolver',
+      resolverExport: params.config.resolverExport ?? true,
+    });
+    params.ctx.fileManager.add(...files);
+    await params.ctx.fileManager.writeByTag('prisma-sdl');
+    return params.next();
+  },
+});

package/lib/context.ts

@@ -0,0 +1,29 @@
+import { parseDMMF } from './dmmf';
+import { createInputsModelMap } from './model-inputs';
+import { createModelsList } from './model-list';
+import { createModelsOperationsMaps } from './model-operations';
+import { createOutputsModelMaps } from './model-outputs';
+import { createModelRelationsList } from './model-relations';
+
+export type Store = ReturnType<typeof createContext> extends Promise<infer T> ? T : never;
+
+export async function createContext() {
+  const dmmf = await parseDMMF({
+    datamodelPath: 'schema.prisma',
+  });
+
+  const models = createModelsList(dmmf);
+  const inputsMap = createInputsModelMap(dmmf, models);
+  const outputsMap = createOutputsModelMaps(dmmf, models);
+  const relationsMap = createModelRelationsList(dmmf);
+  const operationsMap = createModelsOperationsMaps(dmmf);
+
+  return {
+    dmmf,
+    models,
+    inputsMap,
+    outputsMap,
+    relationsMap,
+    operationsMap,
+  };
+}

package/lib/dmmf.ts

@@ -0,0 +1,8 @@
+import { DMMF } from '@prisma/generator-helper';
+import { getDMMF, GetDMMFOptions } from '@prisma/internals';
+
+export { DMMF };
+
+export function parseDMMF(options: GetDMMFOptions): Promise<DMMF.Document> {
+  return getDMMF(options);
+}

package/lib/generator.ts

@@ -0,0 +1,24 @@
+import { PrismaPluginOptions } from '..';
+import { Store } from './context';
+import { createResolversBuilder } from './resolver-builder';
+import { createSchemaBuilder } from './schema-builder';
+import { visit } from './visitor';
+
+export interface GenerateOptions extends Required<PrismaPluginOptions> {
+  modulesDir: string;
+}
+
+export async function generate(store: Store, options: GenerateOptions) {
+  const schemaBuilder = createSchemaBuilder(store, options);
+  const resolversBuilder = createResolversBuilder(store, options);
+
+  await visit(store.dmmf, [
+    resolversBuilder.visitor.getVisitor(),
+    schemaBuilder.visitor.getVisitor(),
+  ]);
+
+  const resolverFiles = resolversBuilder.compose();
+  const schemaFiles = schemaBuilder.compose();
+
+  return [...resolverFiles, ...schemaFiles];
+}

package/lib/model-entries.ts

@@ -0,0 +1,57 @@
+interface ModelEntry {
+  model: string;
+  modelScore: number;
+  operationName: string;
+}
+type ModelEntryMap = Record<string, ModelEntry | undefined>;
+
+type EntryValue = {
+  model: string;
+};
+
+export type EntryToModelMap = Record<string, EntryValue | undefined>;
+
+export function createEntriesModelMap(models: string[], entries: string[]) {
+  const map: ModelEntryMap = {};
+
+  for (const model of models) {
+    updateEntriesForModel(map, model, entries);
+  }
+
+  return normalizeResult(map);
+}
+
+function updateEntriesForModel(map: ModelEntryMap, model: string, entries: string[]) {
+  for (const input of entries) {
+    if (!input.startsWith(model) && input !== 'Aggregate' + model) {
+      continue;
+    }
+
+    const currentScore = model.length;
+
+    const modelInput = map[input];
+
+    if (modelInput && modelInput.modelScore > currentScore) {
+      continue;
+    }
+
+    map[input] = {
+      model,
+      operationName: input,
+      modelScore: currentScore,
+    };
+  }
+}
+
+function normalizeResult(value: ModelEntryMap) {
+  const result: EntryToModelMap = {};
+
+  for (const input of Object.values(value)) {
+    if (!input) {
+      continue;
+    }
+    result[input.operationName] = { model: input.model };
+  }
+
+  return result;
+}

package/lib/model-enum.ts

@@ -0,0 +1,17 @@
+import { DMMF } from './dmmf';
+
+export function findModelByEnum(models: string[], enumType: DMMF.SchemaEnum) {
+  for (const model of models) {
+    if (!enumType.name.startsWith(model)) {
+      continue;
+    }
+
+    if (model + 'ScalarFieldEnum' === enumType.name) {
+      return model;
+    }
+
+    if (model + 'OrderByRelevanceFieldEnum' === enumType.name) {
+      return model;
+    }
+  }
+}

package/lib/model-inputs.ts

@@ -0,0 +1,32 @@
+import { DMMF } from './dmmf';
+import { createEntriesModelMap, EntryToModelMap } from './model-entries';
+
+export function createInputsModelMap(dmmf: DMMF.Document, models: string[]) {
+  const inputs = createInputsList(dmmf);
+  return createEntriesModelMap(models, inputs);
+}
+
+export function findModelByInput(entries: EntryToModelMap, input: DMMF.InputType) {
+  return entries[input.name]?.model;
+}
+
+function createInputsList(dmmf: DMMF.Document) {
+  return dmmf.schema.inputObjectTypes.prisma.map((el) => el.name);
+}
+
+export function createInputsIgnoreList(dmmf: DMMF.Document) {
+  const ignoreList: string[] = [];
+
+  const inputs = createInputsList(dmmf);
+  const uncheckedInputs = inputs.filter((input) => input.includes('Unchecked'));
+
+  uncheckedInputs.forEach((uncheckedInput) => {
+    const normalized = uncheckedInput.replace('Unchecked', '');
+    const exists = inputs.some((input) => input === normalized);
+    if (exists) {
+      ignoreList.push(uncheckedInput);
+    }
+  });
+
+  return ignoreList;
+}

package/lib/model-list.ts

@@ -0,0 +1,5 @@
+import { DMMF } from './dmmf';
+
+export function createModelsList(dmmf: DMMF.Document) {
+  return dmmf.mappings.modelOperations.map((modelOperations) => modelOperations.model);
+}

package/lib/model-operations.ts

@@ -0,0 +1,65 @@
+import { plural, singular } from 'pluralize';
+import { DMMF } from './dmmf';
+
+export type ModelOperations = {
+  model: string;
+  prisma: string;
+  operation: string;
+};
+
+export type ModelsOperationsMap = Record<string, ModelOperations | undefined>;
+
+export function createModelsOperationsMaps(dmmf: DMMF.Document) {
+  return dmmf.mappings.modelOperations
+    .map((operations) => createModelOperationsMap(operations))
+    .reduce((a, b) => ({ ...a, ...b }));
+}
+
+export function findModelByOperationSchema(
+  map: ModelsOperationsMap,
+  schema: DMMF.SchemaField
+) {
+  return map[schema.name]?.model;
+}
+
+function createModelOperationsMap(mapping: DMMF.ModelMapping) {
+  const model = mapping.model;
+  const operationMap: ModelsOperationsMap = {};
+
+  function addToMap(key: string, operation?: string) {
+    const originalName = mapping[key as keyof DMMF.ModelMapping];
+
+    if (!originalName) {
+      return;
+    }
+
+    operationMap[originalName] = {
+      model,
+      prisma: key,
+      operation: operation ?? originalName,
+    };
+  }
+
+  const keys = Object.keys(mapping);
+  const modelName = model[0].toLocaleLowerCase() + model.slice(1);
+
+  for (const key of keys) {
+    if (key === 'model') {
+      continue;
+    }
+
+    if (key === 'findUnique') {
+      addToMap(key, singular(modelName));
+      continue;
+    }
+
+    if (key === 'findMany') {
+      addToMap(key, plural(modelName));
+      continue;
+    }
+
+    addToMap(key);
+  }
+
+  return operationMap;
+}

package/lib/model-outputs.ts

@@ -0,0 +1,15 @@
+import { DMMF } from './dmmf';
+import { createEntriesModelMap, EntryToModelMap } from './model-entries';
+
+export function createOutputsModelMaps(dmmf: DMMF.Document, models: string[]) {
+  const inputs = createOutputsList(dmmf);
+  return createEntriesModelMap(models, inputs);
+}
+
+export function findModelByOutput(entries: EntryToModelMap, output: DMMF.OutputType) {
+  return entries[output.name]?.model;
+}
+
+function createOutputsList(dmmf: DMMF.Document) {
+  return dmmf.schema.outputObjectTypes.prisma.map((el) => el.name);
+}

package/lib/model-relations.ts

@@ -0,0 +1,35 @@
+import { DMMF } from './dmmf';
+
+export interface ModelRelation {
+  with: string;
+  name: string;
+}
+
+export type ModelRelationsMap = Record<string, ModelRelation[] | undefined>;
+
+export function createModelRelationsList(dmmf: DMMF.Document) {
+  const map: ModelRelationsMap = {};
+
+  for (const model of dmmf.datamodel.models) {
+    map[model.name] = getRelationsFromModel(model);
+  }
+
+  return map;
+}
+
+function getRelationsFromModel(model: DMMF.Model) {
+  const relations: ModelRelation[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind !== 'object') {
+      continue;
+    }
+
+    relations.push({
+      with: field.type,
+      name: field.name,
+    });
+  }
+
+  return relations;
+}

package/lib/print/directive.ts

@@ -0,0 +1,28 @@
+export const directives = [
+  'directive @inputConstraint(minFields: Int, maxFields: Int) on INPUT_OBJECT',
+];
+
+export function printDirectives() {
+  return directives.join('\n');
+}
+
+export function printInputConstraintDirective(
+  minNumFields?: number | null,
+  maxNumFields?: number | null
+) {
+  const args = [];
+
+  if (minNumFields != null) {
+    args.push(`minFields: ${minNumFields}`);
+  }
+
+  if (maxNumFields != null) {
+    args.push(`maxFields: ${maxNumFields}`);
+  }
+
+  if (args.length === 0) {
+    return;
+  }
+
+  return `@inputConstraint(${args.join(', ')})`;
+}

package/lib/print/module-prisma.ts

@@ -0,0 +1,13 @@
+export function printPrismaModule() {
+  const imports = [
+    `import { registerPrismaModule } from "@baeta/prisma";`,
+    `import { createPrismaModule } from "./typedef";`,
+  ].join('\n');
+
+  const content = [
+    `export const prismaModule = createPrismaModule();`,
+    `registerPrismaModule(prismaModule);`,
+  ].join('\n');
+
+  return [imports, content].join('\n');
+}

package/lib/print/module-resolver.ts

@@ -0,0 +1,48 @@
+import { camelCase, upperCaseFirst } from 'change-case-all';
+import { ModelOperations } from '../model-operations';
+import { ModelRelation } from '../model-relations';
+
+export function printResolver(
+  namespace: string,
+  mapping: ModelOperations,
+  prisma: string = 'ctx.prisma'
+) {
+  const prismaModel = camelCase(mapping.model);
+  const prismaMethod = mapping.prisma.replace('One', '');
+  const expectError =
+    mapping.prisma === 'groupBy' ? '//@ts-expect-error difficult to infer\n  ' : '';
+
+  const instruction = `${expectError}return ${prisma}.${prismaModel}.${prismaMethod}(args);`;
+
+  return printFunction(namespace, mapping.operation, instruction);
+}
+
+export function printRelationResolver(
+  model: string,
+  relation: ModelRelation,
+  prisma: string = 'ctx.prisma'
+) {
+  const prismaModel = camelCase(model);
+  const instruction = `return ${prisma}.${prismaModel}.findUnique({where: {id: root.id}}).${relation.name}(args);`;
+
+  return printFunction(model, relation.name, instruction, true);
+}
+
+function printFunction(
+  namespace: string,
+  func: string,
+  content: string,
+  rootArg = false
+) {
+  const args = ['args', 'ctx'];
+
+  if (rootArg) {
+    args.unshift('root');
+  }
+
+  return [
+    `${upperCaseFirst(namespace)}.${func}(({ ${args.join(', ')} }) => {`,
+    `  ${content}`,
+    `});`,
+  ].join('\n');
+}

package/lib/print/module.ts

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

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

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

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

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

@@ -0,0 +1,24 @@
+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',
+  });
+}