@baeta/plugin-prisma 0.0.2 → 0.0.13

package/dist/index.cjs

@@ -0,0 +1,49 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// lib/client-generator.ts
+var _pluginexec = require('@baeta/plugin-exec');
+var _promises = require('fs/promises');
+var _path = require('path');
+async function compareSchemas(current, generated) {
+  const [currentSchema, generatedSchema] = await Promise.all([
+    _promises.readFile.call(void 0, _path.resolve.call(void 0, process.cwd(), current), "utf-8"),
+    _promises.readFile.call(void 0, _path.resolve.call(void 0, process.cwd(), generated), "utf-8").catch(() => null)
+  ]);
+  return currentSchema === generatedSchema;
+}
+function createPrismaClientPlugin(options) {
+  const { prismaSchema, generateCommand, generatedSchemaPath } = options;
+  const schema = _path.resolve.call(void 0, process.cwd(), prismaSchema);
+  const skip = async (ctx) => {
+    if (ctx.watching && ctx.changedFile !== schema) {
+      return true;
+    }
+    if (!ctx.watching && generatedSchemaPath) {
+      return compareSchemas(prismaSchema, generatedSchemaPath);
+    }
+    return false;
+  };
+  return _pluginexec.createExecPlugin.call(void 0, {
+    name: "prisma-client",
+    actionName: "Prisma client",
+    exec: _nullishCoalesce(generateCommand, () => ( "prisma generate")),
+    watch: () => {
+      return {
+        include: [_path.resolve.call(void 0, process.cwd(), prismaSchema)],
+        ignore: []
+      };
+    },
+    skip
+  });
+}
+
+// index.ts
+var prisma_default = prismaPlugin;
+function prismaPlugin(options) {
+  if (options.generateClient === false) {
+    return [];
+  }
+  return [createPrismaClientPlugin(options)];
+}
+
+
+
+exports.default = prisma_default; exports.prismaPlugin = prismaPlugin;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import * as _baeta_generator_sdk from '@baeta/generator-sdk';
+
+interface PrismaPluginOptions {
+    prismaSchema: string;
+    generateClient?: boolean;
+    generateCommand?: string;
+    generatedSchemaPath?: string;
+}
+
+declare function prismaPlugin(options: PrismaPluginOptions): _baeta_generator_sdk.GeneratorPluginV1<{}>[];
+
+export { PrismaPluginOptions, prismaPlugin as default, prismaPlugin };

package/dist/index.js

@@ -0,0 +1,49 @@
+// lib/client-generator.ts
+import { createExecPlugin } from "@baeta/plugin-exec";
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+async function compareSchemas(current, generated) {
+  const [currentSchema, generatedSchema] = await Promise.all([
+    readFile(resolve(process.cwd(), current), "utf-8"),
+    readFile(resolve(process.cwd(), generated), "utf-8").catch(() => null)
+  ]);
+  return currentSchema === generatedSchema;
+}
+function createPrismaClientPlugin(options) {
+  const { prismaSchema, generateCommand, generatedSchemaPath } = options;
+  const schema = resolve(process.cwd(), prismaSchema);
+  const skip = async (ctx) => {
+    if (ctx.watching && ctx.changedFile !== schema) {
+      return true;
+    }
+    if (!ctx.watching && generatedSchemaPath) {
+      return compareSchemas(prismaSchema, generatedSchemaPath);
+    }
+    return false;
+  };
+  return createExecPlugin({
+    name: "prisma-client",
+    actionName: "Prisma client",
+    exec: generateCommand ?? "prisma generate",
+    watch: () => {
+      return {
+        include: [resolve(process.cwd(), prismaSchema)],
+        ignore: []
+      };
+    },
+    skip
+  });
+}
+
+// index.ts
+var prisma_default = prismaPlugin;
+function prismaPlugin(options) {
+  if (options.generateClient === false) {
+    return [];
+  }
+  return [createPrismaClientPlugin(options)];
+}
+export {
+  prisma_default as default,
+  prismaPlugin
+};

package/package.json

@@ -1,38 +1,59 @@
 {
   "name": "@baeta/plugin-prisma",
-  "version": "0.0.2",
-  "license": "MIT",
-  "author": "Andrei Pampu <pampu.andrei@pm.me>",
+  "version": "0.0.13",
   "homepage": "https://github.com/andreisergiu98/baeta#readme",
+  "bugs": {
+    "url": "https://github.com/andreisergiu98/baeta/issues"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/andreisergiu98/baeta.git",
     "directory": "plugins/prisma"
   },
-  "bugs": {
-    "url": "https://github.com/andreisergiu98/baeta/issues"
-  },
+  "license": "MIT",
+  "author": "Andrei Pampu <pampu.andrei@pm.me>",
   "type": "module",
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepack": "prep",
+    "postpack": "prep --clean",
+    "types": "tsc --noEmit"
+  },
   "dependencies": {
-    "@baeta/plugin": "^0.0.5",
-    "@prisma/generator-helper": "^4.4.0",
-    "@prisma/internals": "^4.4.0",
-    "@prisma/sdk": "^4.0.0",
-    "change-case-all": "^1.0.15",
-    "pluralize": "^8.0.0",
-    "ramda": "^0.28.0",
-    "tslib": "^2.4.0"
+    "@baeta/generator-sdk": "^0.0.3",
+    "@baeta/plugin-exec": "^0.0.1",
+    "execa": "^6.1.0"
   },
   "devDependencies": {
-    "@baeta/eslint-config": "^0.0.0",
-    "@types/node": "^18.8.1",
-    "@types/pluralize": "^0.0.29",
-    "@types/ramda": "^0.28.15",
-    "eslint": "^8.24.0",
-    "graphql": "^16.6.0",
-    "typescript": "^4.8.3"
-  },
-  "peerDependencies": {
-    "graphql": "^15.3.0 || ^16.0.0"
-  }
+    "@baeta/build-tools": "^0.0.0",
+    "@baeta/tsconfig": "^0.0.0",
+    "@types/node": "^18.11.18",
+    "typescript": "^4.9.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "import": "./dist/index.js",
+        "require": "./dist/index.cjs",
+        "types": "./dist/index.d.ts"
+      }
+    },
+    "types": "dist/index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "types": "dist/index.d.ts"
 }

package/.eslintrc.cjs

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

package/CHANGELOG.md

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

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

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

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

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

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

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

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

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

package/lib/model-operations.ts

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

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

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

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

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

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