@stryke/prisma-trpc-generator 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,6 +1,502 @@
-import "./chunk-6UJ53OQ6.js";
-import "./chunk-GQ7ABBSV.js";
-import "./chunk-V6DNCMCB.js";
-import "./chunk-RYVIOFDO.js";
-import "./chunk-LVOPI6NH.js";
-import "./chunk-SHUYVCID.js";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { generatorHandler } from "@prisma/generator-helper";
+
+// src/prisma-generator.ts
+import { getDMMF, parseEnvValue as parseEnvValue2 } from "@prisma/internals";
+import { promises as fs2 } from "node:fs";
+import path3 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/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()));
+  })
+});
+
+// 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 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");
+
+// 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
+  }
+});
+
+// src/utils/removeDir.ts
+import { promises as fs } from "node:fs";
+import path2 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 = path2.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 = parseEnvValue2(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 = path3.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) => parseEnvValue2(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(path3.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(path3.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(path3.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
+generatorHandler({
+  onManifest: /* @__PURE__ */ __name(() => ({
+    defaultOutput: "./generated",
+    prettyName: "Prisma tRPC Generator",
+    requiresGenerators: [
+      "prisma-client-js"
+    ]
+  }), "onManifest"),
+  onGenerate: generate
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stryke/prisma-trpc-generator",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "description": "A fork of the prisma-trpc-generator code to work in ESM.",
   "repository": {
@@ -46,43 +46,39 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "exports": {
-    "./project": {
-      "import": "./dist/project.js",
-      "require": "./dist/project.cjs",
-      "default": "./dist/project.js"
-    },
-    "./prisma-generator": {
-      "import": "./dist/prisma-generator.js",
-      "require": "./dist/prisma-generator.cjs",
-      "default": "./dist/prisma-generator.js"
+    ".": {
+      "import": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
     },
     "./index": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
-    },
-    "./helpers": {
-      "import": "./dist/helpers.js",
-      "require": "./dist/helpers.cjs",
-      "default": "./dist/helpers.js"
+      "import": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
     },
     "./generator": {
-      "import": "./dist/generator.js",
-      "require": "./dist/generator.cjs",
-      "default": "./dist/generator.js"
-    },
-    "./config": {
-      "import": "./dist/config.js",
-      "require": "./dist/config.cjs",
-      "default": "./dist/config.js"
-    },
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
+      "import": {
+        "types": "./dist/generator.d.ts",
+        "default": "./dist/generator.js"
+      },
+      "require": {
+        "types": "./dist/generator.d.cts",
+        "default": "./dist/generator.cjs"
+      },
+      "default": {
+        "types": "./dist/generator.d.ts",
+        "default": "./dist/generator.js"
+      }
     },
     "./package.json": "./package.json"
   },
+  "types": "./dist/index.d.ts",
   "files": ["dist/**/*"],
   "keywords": [
     "stryke",
@@ -98,13 +94,17 @@
   "dependencies": {
     "@prisma/generator-helper": "^6.5.0",
     "@prisma/internals": "^6.5.0",
+    "@prisma/prisma-schema-wasm": "^6.6.0-41.9061db3b0058e3d3731c6fe68a1b77061bed4861",
+    "esbuild": "^0.25.0",
+    "ts-morph": "^25.0.1"
+  },
+  "devDependencies": {
+    "@types/pluralize": "^0.0.33",
     "pluralize": "^8.0.0",
     "prisma-trpc-shield-generator": "^0.1.0",
     "prisma-zod-generator": "^0.8.13",
-    "ts-morph": "^25.0.1",
+    "tsup": "^8.3.5",
     "zod": "^3.24.2"
   },
-  "devDependencies": { "tsup": "^8.3.5" },
-  "publishConfig": { "access": "public" },
-  "sideEffects": false
+  "publishConfig": { "access": "public" }
 }

package/dist/chunk-6UJ53OQ6.js

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