@stryke/prisma-trpc-generator 0.2.1 → 0.2.3

package/dist/generator.cjs

@@ -1,2 +1,525 @@
 #! /usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_generator_helper2 = require("@prisma/generator-helper");
+
+// src/prisma-generator.ts
+var import_internals2 = require("@prisma/internals");
+var import_node_fs2 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_pluralize = __toESM(require("pluralize"), 1);
+var import_prisma_generator = require("prisma-trpc-shield-generator/lib/prisma-generator");
+var import_prisma_generator2 = require("prisma-zod-generator/lib/prisma-generator");
+
+// src/config.ts
+var import_generator_helper = require("@prisma/generator-helper");
+var import_zod = require("zod");
+var configBoolean = import_zod.z.enum([
+  "true",
+  "false"
+]).transform((arg) => JSON.parse(arg));
+var configMiddleware = import_zod.z.union([
+  configBoolean,
+  import_zod.z.string().default("../../../../src/middleware")
+]);
+var configShield = import_zod.z.union([
+  configBoolean,
+  import_zod.z.string().default("../../../../src/shield")
+]);
+var modelActionEnum = import_zod.z.nativeEnum(import_generator_helper.DMMF.ModelAction);
+var configSchema = import_zod.z.object({
+  withMiddleware: configMiddleware.default("true"),
+  withShield: configShield.default("true"),
+  withZod: configBoolean.default("true"),
+  contextPath: import_zod.z.string().default("../../../../src/context"),
+  trpcOptionsPath: import_zod.z.string().optional(),
+  showModelNameInProcedure: configBoolean.default("true"),
+  generateModelActions: import_zod.z.string().default(Object.values(import_generator_helper.DMMF.ModelAction).join(",")).transform((arg) => {
+    return arg.split(",").map((action) => modelActionEnum.parse(action.trim()));
+  })
+});
+
+// src/helpers.ts
+var import_internals = require("@prisma/internals");
+
+// src/utils/getRelativePath.ts
+var import_node_path = __toESM(require("path"), 1);
+function getRelativePath(outputPath, filePath, isOutsideOutputPath, schemaPath) {
+  const fromPath = import_node_path.default.join(outputPath, "routers", "helpers");
+  let toPath = import_node_path.default.join(outputPath, filePath);
+  if (isOutsideOutputPath) {
+    const schemaPathSplit = schemaPath?.split(import_node_path.default.sep);
+    const schemaPathWithoutFileAndExtension = schemaPathSplit.slice(0, schemaPathSplit.length - 1).join(import_node_path.default.posix.sep);
+    toPath = import_node_path.default.join(schemaPathWithoutFileAndExtension, filePath);
+  }
+  const newPath = import_node_path.default.relative(fromPath, toPath).split(import_node_path.default.sep).join(import_node_path.default.posix.sep);
+  return newPath;
+}
+__name(getRelativePath, "getRelativePath");
+
+// src/utils/uncapitalizeFirstLetter.ts
+var uncapitalizeFirstLetter = /* @__PURE__ */ __name((str) => {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}, "uncapitalizeFirstLetter");
+
+// src/helpers.ts
+var getProcedureName = /* @__PURE__ */ __name((config) => {
+  return config.withShield ? "shieldedProcedure" : config.withMiddleware ? "protectedProcedure" : "publicProcedure";
+}, "getProcedureName");
+var generateCreateRouterImport = /* @__PURE__ */ __name(({ sourceFile, config }) => {
+  const imports = [
+    "t"
+  ];
+  if (config) {
+    imports.push(getProcedureName(config));
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "./helpers/createRouter",
+    namedImports: imports
+  });
+}, "generateCreateRouterImport");
+var generateRPCImport = /* @__PURE__ */ __name((sourceFile) => {
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: "@trpc/server",
+    namespaceImport: "trpc"
+  });
+}, "generateRPCImport");
+var generateShieldImport = /* @__PURE__ */ __name((sourceFile, options, value) => {
+  const outputDir = (0, import_internals.parseEnvValue)(options.generator.output);
+  let shieldPath = getRelativePath(outputDir, "shield/shield");
+  if (typeof value === "string") {
+    shieldPath = getRelativePath(outputDir, value, true, options.schemaPath);
+  }
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: shieldPath,
+    namedImports: [
+      "permissions"
+    ]
+  });
+}, "generateShieldImport");
+var generateRouterImport = /* @__PURE__ */ __name((sourceFile, modelNamePlural, modelNameCamelCase) => {
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: `./${modelNameCamelCase}.router`,
+    namedImports: [
+      `${modelNamePlural}Router`
+    ]
+  });
+}, "generateRouterImport");
+function generateBaseRouter(sourceFile, config, options) {
+  const outputDir = (0, import_internals.parseEnvValue)(options.generator.output);
+  sourceFile.addStatements(
+    /* ts */
+    `
+  import type { Context } from '${getRelativePath(outputDir, config.contextPath, true, options.schemaPath)}';
+  `
+  );
+  if (config.trpcOptionsPath) {
+    sourceFile.addStatements(
+      /* ts */
+      `
+    import trpcOptions from '${getRelativePath(outputDir, config.trpcOptionsPath, true, options.schemaPath)}';
+    `
+    );
+  }
+  sourceFile.addStatements(
+    /* ts */
+    `
+  export const t = trpc.initTRPC.context<Context>().create(${config.trpcOptionsPath ? "trpcOptions" : ""});
+  `
+  );
+  const middlewares = [];
+  if (config.withMiddleware && typeof config.withMiddleware === "boolean") {
+    sourceFile.addStatements(
+      /* ts */
+      `
+    export const globalMiddleware = t.middleware(async ({ ctx, next }) => {
+      console.log('inside middleware!')
+      return next()
+    });`
+    );
+    middlewares.push({
+      type: "global",
+      value: (
+        /* ts */
+        `.use(globalMiddleware)`
+      )
+    });
+  }
+  if (config.withMiddleware && typeof config.withMiddleware === "string") {
+    sourceFile.addStatements(
+      /* ts */
+      `
+  import defaultMiddleware from '${getRelativePath(outputDir, config.withMiddleware, true, options.schemaPath)}';
+  `
+    );
+    sourceFile.addStatements(
+      /* ts */
+      `
+    export const globalMiddleware = t.middleware(defaultMiddleware);`
+    );
+    middlewares.push({
+      type: "global",
+      value: (
+        /* ts */
+        `.use(globalMiddleware)`
+      )
+    });
+  }
+  if (config.withShield) {
+    sourceFile.addStatements(
+      /* ts */
+      `
+    export const permissionsMiddleware = t.middleware(permissions); `
+    );
+    middlewares.push({
+      type: "shield",
+      value: (
+        /* ts */
+        `
+      .use(permissions)`
+      )
+    });
+  }
+  sourceFile.addStatements(
+    /* ts */
+    `
+    export const publicProcedure = t.procedure; `
+  );
+  if (middlewares.length > 0) {
+    const procName = getProcedureName(config);
+    middlewares.forEach((middleware, i) => {
+      if (i === 0) {
+        sourceFile.addStatements(
+          /* ts */
+          `
+    export const ${procName} = t.procedure
+      `
+        );
+      }
+      sourceFile.addStatements(
+        /* ts */
+        `
+      .use(${middleware.type === "shield" ? "permissionsMiddleware" : "globalMiddleware"})
+      `
+      );
+    });
+  }
+}
+__name(generateBaseRouter, "generateBaseRouter");
+function generateProcedure(sourceFile, name, typeName, modelName, opType, baseOpType, config) {
+  let input = `input${!config.withZod ? " as any" : ""}`;
+  const nameWithoutModel = name.replace(modelName, "");
+  if (nameWithoutModel === "groupBy" && config.withZod) {
+    input = "{ where: input.where, orderBy: input.orderBy, by: input.by, having: input.having, take: input.take, skip: input.skip }";
+  }
+  sourceFile.addStatements(
+    /* ts */
+    `${config.showModelNameInProcedure ? name : nameWithoutModel}: ${getProcedureName(config)}
+  ${config.withZod ? `.input(${typeName})` : ""}.${getProcedureTypeByOpName(baseOpType)}(async ({ ctx, input }) => {
+    const ${name} = await ctx.prisma.${uncapitalizeFirstLetter(modelName)}.${opType.replace("One", "")}(${input});
+    return ${name};
+  }),`
+  );
+}
+__name(generateProcedure, "generateProcedure");
+function generateRouterSchemaImports(sourceFile, modelName, modelActions) {
+  sourceFile.addStatements(
+    /* ts */
+    [
+      // remove any duplicate import statements
+      ...new Set(modelActions.map((opName) => getRouterSchemaImportByOpName(opName, modelName)))
+    ].join("\n")
+  );
+}
+__name(generateRouterSchemaImports, "generateRouterSchemaImports");
+var getRouterSchemaImportByOpName = /* @__PURE__ */ __name((opName, modelName) => {
+  const opType = opName.replace("OrThrow", "");
+  const inputType = getInputTypeByOpName(opType, modelName);
+  return inputType ? `import { ${inputType} } from "../schemas/${opType}${modelName}.schema"; ` : "";
+}, "getRouterSchemaImportByOpName");
+var getInputTypeByOpName = /* @__PURE__ */ __name((opName, modelName) => {
+  let inputType;
+  switch (opName) {
+    case "findUnique":
+      inputType = `${modelName}FindUniqueSchema`;
+      break;
+    case "findFirst":
+      inputType = `${modelName}FindFirstSchema`;
+      break;
+    case "findMany":
+      inputType = `${modelName}FindManySchema`;
+      break;
+    case "findRaw":
+      inputType = `${modelName}FindRawObjectSchema`;
+      break;
+    case "createOne":
+      inputType = `${modelName}CreateOneSchema`;
+      break;
+    case "createMany":
+      inputType = `${modelName}CreateManySchema`;
+      break;
+    case "deleteOne":
+      inputType = `${modelName}DeleteOneSchema`;
+      break;
+    case "updateOne":
+      inputType = `${modelName}UpdateOneSchema`;
+      break;
+    case "deleteMany":
+      inputType = `${modelName}DeleteManySchema`;
+      break;
+    case "updateMany":
+      inputType = `${modelName}UpdateManySchema`;
+      break;
+    case "upsertOne":
+      inputType = `${modelName}UpsertSchema`;
+      break;
+    case "aggregate":
+      inputType = `${modelName}AggregateSchema`;
+      break;
+    case "aggregateRaw":
+      inputType = `${modelName}AggregateRawObjectSchema`;
+      break;
+    case "groupBy":
+      inputType = `${modelName}GroupBySchema`;
+      break;
+    default:
+      console.log("getInputTypeByOpName: ", {
+        opName,
+        modelName
+      });
+  }
+  return inputType;
+}, "getInputTypeByOpName");
+var getProcedureTypeByOpName = /* @__PURE__ */ __name((opName) => {
+  let procType;
+  switch (opName) {
+    case "findUnique":
+    case "findFirst":
+    case "findMany":
+    case "findRaw":
+    case "aggregate":
+    case "aggregateRaw":
+    case "groupBy":
+      procType = "query";
+      break;
+    case "createOne":
+    case "createMany":
+    case "deleteOne":
+    case "updateOne":
+    case "deleteMany":
+    case "updateMany":
+    case "upsertOne":
+      procType = "mutation";
+      break;
+    default:
+      console.log("getProcedureTypeByOpName: ", {
+        opName
+      });
+  }
+  return procType;
+}, "getProcedureTypeByOpName");
+function resolveModelsComments(models, hiddenModels) {
+  const modelAttributeRegex = /(?:@@Gen\.)+[A-z]+\(.+\)/;
+  const attributeNameRegex = /\.+[A-Z]+\(+/i;
+  const attributeArgsRegex = /\(+[A-Z]+:.+\)/i;
+  for (const model of models) {
+    if (model.documentation) {
+      const attribute = model.documentation?.match(modelAttributeRegex)?.[0];
+      const attributeName = attribute?.match(attributeNameRegex)?.[0]?.slice(1, -1);
+      if (attributeName !== "model") continue;
+      const rawAttributeArgs = attribute?.match(attributeArgsRegex)?.[0]?.slice(1, -1);
+      const parsedAttributeArgs = {};
+      if (rawAttributeArgs) {
+        const rawAttributeArgsParts = rawAttributeArgs.split(":").map((it) => it.trim()).map((part) => part.startsWith("[") ? part : part.split(",")).flat().map((it) => it.trim());
+        for (let i = 0; i < rawAttributeArgsParts.length; i += 2) {
+          const key = rawAttributeArgsParts[i];
+          const value = rawAttributeArgsParts[i + 1];
+          parsedAttributeArgs[key] = JSON.parse(value);
+        }
+      }
+      if (parsedAttributeArgs.hide) {
+        hiddenModels.push(model.name);
+      }
+    }
+  }
+}
+__name(resolveModelsComments, "resolveModelsComments");
+
+// src/project.ts
+var import_ts_morph = require("ts-morph");
+var compilerOptions = {
+  target: import_ts_morph.ScriptTarget.ES2019,
+  module: import_ts_morph.ModuleKind.CommonJS,
+  emitDecoratorMetadata: true,
+  experimentalDecorators: true,
+  esModuleInterop: true
+};
+var project = new import_ts_morph.Project({
+  compilerOptions: {
+    ...compilerOptions
+  }
+});
+
+// src/utils/removeDir.ts
+var import_node_fs = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+async function removeDir(dirPath, onlyContent) {
+  const dirEntries = await import_node_fs.promises.readdir(dirPath, {
+    withFileTypes: true
+  });
+  await Promise.all(dirEntries.map(async (dirEntry) => {
+    const fullPath = import_node_path2.default.join(dirPath, dirEntry.name);
+    return dirEntry.isDirectory() ? removeDir(fullPath, false) : import_node_fs.promises.unlink(fullPath);
+  }));
+  if (!onlyContent) {
+    await import_node_fs.promises.rmdir(dirPath);
+  }
+}
+__name(removeDir, "removeDir");
+
+// src/prisma-generator.ts
+async function generate(options) {
+  const outputDir = (0, import_internals2.parseEnvValue)(options.generator.output);
+  const results = configSchema.safeParse(options.generator.config);
+  if (!results.success) throw new Error("Invalid options passed");
+  const config = results.data;
+  await import_node_fs2.promises.mkdir(outputDir, {
+    recursive: true
+  });
+  await removeDir(outputDir, true);
+  if (config.withZod) {
+    await (0, import_prisma_generator2.generate)(options);
+  }
+  if (config.withShield === true) {
+    const shieldOutputPath = import_node_path3.default.join(outputDir, "./shield");
+    await (0, import_prisma_generator.generate)({
+      ...options,
+      generator: {
+        ...options.generator,
+        output: {
+          ...options.generator.output,
+          value: shieldOutputPath
+        },
+        config: {
+          ...options.generator.config,
+          contextPath: config.contextPath
+        }
+      }
+    });
+  }
+  const prismaClientProvider = options.otherGenerators.find((it) => (0, import_internals2.parseEnvValue)(it.provider) === "prisma-client-js");
+  const prismaClientDmmf = await (0, import_internals2.getDMMF)({
+    datamodel: options.datamodel,
+    previewFeatures: prismaClientProvider?.previewFeatures
+  });
+  const modelOperations = prismaClientDmmf.mappings.modelOperations;
+  const models = prismaClientDmmf.datamodel.models;
+  const hiddenModels = [];
+  resolveModelsComments(models, hiddenModels);
+  const createRouter = project.createSourceFile(import_node_path3.default.resolve(outputDir, "routers", "helpers", "createRouter.ts"), void 0, {
+    overwrite: true
+  });
+  generateRPCImport(createRouter);
+  if (config.withShield) {
+    generateShieldImport(createRouter, options, config.withShield);
+  }
+  generateBaseRouter(createRouter, config, options);
+  createRouter.formatText({
+    indentSize: 2
+  });
+  const appRouter = project.createSourceFile(import_node_path3.default.resolve(outputDir, "routers", `index.ts`), void 0, {
+    overwrite: true
+  });
+  generateCreateRouterImport({
+    sourceFile: appRouter
+  });
+  const routerStatements = [];
+  for (const modelOperation of modelOperations) {
+    const { model, ...operations } = modelOperation;
+    if (hiddenModels.includes(model)) continue;
+    const modelActions = Object.keys(operations).filter((opType) => config.generateModelActions.includes(opType.replace("One", "")));
+    if (!modelActions.length) continue;
+    const plural = (0, import_pluralize.default)(model.toLowerCase());
+    generateRouterImport(appRouter, plural, model);
+    const modelRouter = project.createSourceFile(import_node_path3.default.resolve(outputDir, "routers", `${model}.router.ts`), void 0, {
+      overwrite: true
+    });
+    generateCreateRouterImport({
+      sourceFile: modelRouter,
+      config
+    });
+    if (config.withZod) {
+      generateRouterSchemaImports(modelRouter, model, modelActions);
+    }
+    modelRouter.addStatements(
+      /* ts */
+      `
+      export const ${plural}Router = t.router({`
+    );
+    for (const opType of modelActions) {
+      const opNameWithModel = operations[opType];
+      const baseOpType = opType.replace("OrThrow", "");
+      generateProcedure(modelRouter, opNameWithModel, getInputTypeByOpName(baseOpType, model), model, opType, baseOpType, config);
+    }
+    modelRouter.addStatements(
+      /* ts */
+      `
+    })`
+    );
+    modelRouter.formatText({
+      indentSize: 2
+    });
+    routerStatements.push(
+      /* ts */
+      `
+      ${model.toLowerCase()}: ${plural}Router`
+    );
+  }
+  appRouter.addStatements(
+    /* ts */
+    `
+    export const appRouter = t.router({${routerStatements.join()}})
+    `
+  );
+  appRouter.formatText({
+    indentSize: 2
+  });
+  await project.save();
+}
+__name(generate, "generate");
+
+// src/index.ts
+(0, import_generator_helper2.generatorHandler)({
+  onManifest: /* @__PURE__ */ __name(() => ({
+    defaultOutput: "./generated",
+    prettyName: "Prisma tRPC Generator",
+    requiresGenerators: [
+      "prisma-client-js"
+    ]
+  }), "onManifest"),
+  onGenerate: generate
+});

package/dist/generator.d.cts

@@ -0,0 +1 @@
+#! /usr/bin/env node

package/dist/generator.d.ts

@@ -0,0 +1 @@
+#! /usr/bin/env node