@stryke/prisma-trpc-generator 0.2.0 → 0.2.1

package/dist/chunk-6UJ53OQ6.js

@@ -0,0 +1,19 @@
+import {
+  generate
+} from "./chunk-GQ7ABBSV.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/index.ts
+import { generatorHandler } from "@prisma/generator-helper";
+generatorHandler({
+  onManifest: /* @__PURE__ */ __name(() => ({
+    defaultOutput: "./generated",
+    prettyName: "Prisma tRPC Generator",
+    requiresGenerators: [
+      "prisma-client-js"
+    ]
+  }), "onManifest"),
+  onGenerate: generate
+});

package/dist/chunk-GQ7ABBSV.js

@@ -0,0 +1,160 @@
+import {
+  configSchema
+} from "./chunk-V6DNCMCB.js";
+import {
+  generateBaseRouter,
+  generateCreateRouterImport,
+  generateProcedure,
+  generateRPCImport,
+  generateRouterImport,
+  generateRouterSchemaImports,
+  generateShieldImport,
+  getInputTypeByOpName,
+  resolveModelsComments
+} from "./chunk-RYVIOFDO.js";
+import {
+  project
+} from "./chunk-LVOPI6NH.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/prisma-generator.ts
+import { getDMMF, parseEnvValue } from "@prisma/internals";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+import pluralize from "pluralize";
+import { generate as PrismaTrpcShieldGenerator } from "prisma-trpc-shield-generator/lib/prisma-generator";
+import { generate as PrismaZodGenerator } from "prisma-zod-generator/lib/prisma-generator";
+
+// src/utils/removeDir.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+async function removeDir(dirPath, onlyContent) {
+  const dirEntries = await fs.readdir(dirPath, {
+    withFileTypes: true
+  });
+  await Promise.all(dirEntries.map(async (dirEntry) => {
+    const fullPath = path.join(dirPath, dirEntry.name);
+    return dirEntry.isDirectory() ? removeDir(fullPath, false) : fs.unlink(fullPath);
+  }));
+  if (!onlyContent) {
+    await fs.rmdir(dirPath);
+  }
+}
+__name(removeDir, "removeDir");
+
+// src/prisma-generator.ts
+async function generate(options) {
+  const outputDir = 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 fs2.mkdir(outputDir, {
+    recursive: true
+  });
+  await removeDir(outputDir, true);
+  if (config.withZod) {
+    await PrismaZodGenerator(options);
+  }
+  if (config.withShield === true) {
+    const shieldOutputPath = path2.join(outputDir, "./shield");
+    await PrismaTrpcShieldGenerator({
+      ...options,
+      generator: {
+        ...options.generator,
+        output: {
+          ...options.generator.output,
+          value: shieldOutputPath
+        },
+        config: {
+          ...options.generator.config,
+          contextPath: config.contextPath
+        }
+      }
+    });
+  }
+  const prismaClientProvider = options.otherGenerators.find((it) => parseEnvValue(it.provider) === "prisma-client-js");
+  const prismaClientDmmf = await 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(path2.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(path2.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 = pluralize(model.toLowerCase());
+    generateRouterImport(appRouter, plural, model);
+    const modelRouter = project.createSourceFile(path2.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}})
+    `
+  );
+  appRouter.formatText({
+    indentSize: 2
+  });
+  await project.save();
+}
+__name(generate, "generate");
+
+export {
+  generate
+};

package/dist/chunk-LVOPI6NH.js

@@ -0,0 +1,18 @@
+// src/project.ts
+import { ModuleKind, Project, ScriptTarget } from "ts-morph";
+var compilerOptions = {
+  target: ScriptTarget.ES2019,
+  module: ModuleKind.CommonJS,
+  emitDecoratorMetadata: true,
+  experimentalDecorators: true,
+  esModuleInterop: true
+};
+var project = new Project({
+  compilerOptions: {
+    ...compilerOptions
+  }
+});
+
+export {
+  project
+};

package/dist/chunk-RYVIOFDO.js

@@ -0,0 +1,333 @@
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/helpers.ts
+import { parseEnvValue } from "@prisma/internals";
+
+// src/utils/getRelativePath.ts
+import path from "node:path";
+function getRelativePath(outputPath, filePath, isOutsideOutputPath, schemaPath) {
+  const fromPath = path.join(outputPath, "routers", "helpers");
+  let toPath = path.join(outputPath, filePath);
+  if (isOutsideOutputPath) {
+    const schemaPathSplit = schemaPath?.split(path.sep);
+    const schemaPathWithoutFileAndExtension = schemaPathSplit.slice(0, schemaPathSplit.length - 1).join(path.posix.sep);
+    toPath = path.join(schemaPathWithoutFileAndExtension, filePath);
+  }
+  const newPath = path.relative(fromPath, toPath).split(path.sep).join(path.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 = 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 generateMiddlewareImport = /* @__PURE__ */ __name((sourceFile, options) => {
+  const outputDir = parseEnvValue(options.generator.output);
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: getRelativePath(outputDir, "middleware"),
+    namedImports: [
+      "permissions"
+    ]
+  });
+}, "generateMiddlewareImport");
+var generateRouterImport = /* @__PURE__ */ __name((sourceFile, modelNamePlural, modelNameCamelCase) => {
+  sourceFile.addImportDeclaration({
+    moduleSpecifier: `./${modelNameCamelCase}.router`,
+    namedImports: [
+      `${modelNamePlural}Router`
+    ]
+  });
+}, "generateRouterImport");
+function generateBaseRouter(sourceFile, config, options) {
+  const outputDir = 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");
+
+export {
+  generateCreateRouterImport,
+  generateRPCImport,
+  generateShieldImport,
+  generateMiddlewareImport,
+  generateRouterImport,
+  generateBaseRouter,
+  generateProcedure,
+  generateRouterSchemaImports,
+  getRouterSchemaImportByOpName,
+  getInputTypeByOpName,
+  getProcedureTypeByOpName,
+  resolveModelsComments
+};

package/dist/chunk-SHUYVCID.js

@@ -0,0 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+export {
+  __name
+};

package/dist/chunk-V6DNCMCB.js

@@ -0,0 +1,31 @@
+// src/config.ts
+import { DMMF } from "@prisma/generator-helper";
+import { z } from "zod";
+var configBoolean = z.enum([
+  "true",
+  "false"
+]).transform((arg) => JSON.parse(arg));
+var configMiddleware = z.union([
+  configBoolean,
+  z.string().default("../../../../src/middleware")
+]);
+var configShield = z.union([
+  configBoolean,
+  z.string().default("../../../../src/shield")
+]);
+var modelActionEnum = z.nativeEnum(DMMF.ModelAction);
+var configSchema = z.object({
+  withMiddleware: configMiddleware.default("true"),
+  withShield: configShield.default("true"),
+  withZod: configBoolean.default("true"),
+  contextPath: z.string().default("../../../../src/context"),
+  trpcOptionsPath: z.string().optional(),
+  showModelNameInProcedure: configBoolean.default("true"),
+  generateModelActions: z.string().default(Object.values(DMMF.ModelAction).join(",")).transform((arg) => {
+    return arg.split(",").map((action) => modelActionEnum.parse(action.trim()));
+  })
+});
+
+export {
+  configSchema
+};

package/dist/config.cjs

@@ -1,21 +1,55 @@
 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  configSchema: () => configSchema
+});
+module.exports = __toCommonJS(config_exports);
+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()));
+  })
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configSchema
 });
-exports.configSchema = void 0;
-var _generatorHelper = require("@prisma/generator-helper");
-var _zod = require("zod");
-const e = _zod.z.enum(["true", "false"]).transform(o => JSON.parse(o)),
-  i = _zod.z.union([e, _zod.z.string().default("../../../../src/middleware")]),
-  a = _zod.z.union([e, _zod.z.string().default("../../../../src/shield")]),
-  c = _zod.z.nativeEnum(_generatorHelper.DMMF.ModelAction);
-const configSchema = exports.configSchema = _zod.z.object({
-  withMiddleware: i.default("true"),
-  withShield: a.default("true"),
-  withZod: e.default("true"),
-  contextPath: _zod.z.string().default("../../../../src/context"),
-  trpcOptionsPath: _zod.z.string().optional(),
-  showModelNameInProcedure: e.default("true"),
-  generateModelActions: _zod.z.string().default(Object.values(_generatorHelper.DMMF.ModelAction).join(",")).transform(o => o.split(",").map(r => c.parse(r.trim())))
-});

package/dist/config.js

@@ -0,0 +1,7 @@
+import {
+  configSchema
+} from "./chunk-V6DNCMCB.js";
+import "./chunk-SHUYVCID.js";
+export {
+  configSchema
+};

package/dist/generator.cjs

@@ -1,4 +1,2 @@
-// #! /usr/bin/env node
+#! /usr/bin/env node
 "use strict";
-
-require("./index.cjs");

package/dist/generator.js

@@ -0,0 +1,7 @@
+#! /usr/bin/env node
+import "./chunk-6UJ53OQ6.js";
+import "./chunk-GQ7ABBSV.js";
+import "./chunk-V6DNCMCB.js";
+import "./chunk-RYVIOFDO.js";
+import "./chunk-LVOPI6NH.js";
+import "./chunk-SHUYVCID.js";