@stryke/prisma-trpc-generator 0.2.0 → 0.2.1

package/dist/helpers.cjs

@@ -1,221 +1,375 @@
 "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 __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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/helpers.ts
+var helpers_exports = {};
+__export(helpers_exports, {
+  generateBaseRouter: () => generateBaseRouter,
+  generateCreateRouterImport: () => generateCreateRouterImport,
+  generateMiddlewareImport: () => generateMiddlewareImport,
+  generateProcedure: () => generateProcedure,
+  generateRPCImport: () => generateRPCImport,
+  generateRouterImport: () => generateRouterImport,
+  generateRouterSchemaImports: () => generateRouterSchemaImports,
+  generateShieldImport: () => generateShieldImport,
+  getInputTypeByOpName: () => getInputTypeByOpName,
+  getProcedureTypeByOpName: () => getProcedureTypeByOpName,
+  getRouterSchemaImportByOpName: () => getRouterSchemaImportByOpName,
+  resolveModelsComments: () => resolveModelsComments
 });
-exports.generateBaseRouter = generateBaseRouter;
-exports.generateMiddlewareImport = exports.generateCreateRouterImport = void 0;
-exports.generateProcedure = generateProcedure;
-exports.generateRouterImport = exports.generateRPCImport = void 0;
-exports.generateRouterSchemaImports = generateRouterSchemaImports;
-exports.getRouterSchemaImportByOpName = exports.getProcedureTypeByOpName = exports.getInputTypeByOpName = exports.generateShieldImport = void 0;
-exports.resolveModelsComments = resolveModelsComments;
-var _internals = require("@prisma/internals");
-var _getRelativePath = _interopRequireDefault(require("./utils/getRelativePath.cjs"));
-var _uncapitalizeFirstLetter = require("./utils/uncapitalizeFirstLetter.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const m = r => r.withShield ? "shieldedProcedure" : r.withMiddleware ? "protectedProcedure" : "publicProcedure";
-const generateCreateRouterImport = ({
-    sourceFile: r,
-    config: e
-  }) => {
-    const t = ["t"];
-    e && t.push(m(e)), r.addImportDeclaration({
-      moduleSpecifier: "./helpers/createRouter",
-      namedImports: t
-    });
-  },
-  generateRPCImport = r => {
-    r.addImportDeclaration({
-      moduleSpecifier: "@trpc/server",
-      namespaceImport: "trpc"
-    });
-  },
-  generateShieldImport = (r, e, t) => {
-    const a = (0, _internals.parseEnvValue)(e.generator.output);
-    let n = (0, _getRelativePath.default)(a, "shield/shield");
-    typeof t == "string" && (n = (0, _getRelativePath.default)(a, t, !0, e.schemaPath)), r.addImportDeclaration({
-      moduleSpecifier: n,
-      namedImports: ["permissions"]
-    });
-  },
-  generateMiddlewareImport = (r, e) => {
-    const t = (0, _internals.parseEnvValue)(e.generator.output);
-    r.addImportDeclaration({
-      moduleSpecifier: (0, _getRelativePath.default)(t, "middleware"),
-      namedImports: ["permissions"]
-    });
-  },
-  generateRouterImport = (r, e, t) => {
-    r.addImportDeclaration({
-      moduleSpecifier: `./${t}.router`,
-      namedImports: [`${e}Router`]
-    });
-  };
-exports.generateRouterImport = generateRouterImport;
-exports.generateMiddlewareImport = generateMiddlewareImport;
-exports.generateShieldImport = generateShieldImport;
-exports.generateRPCImport = generateRPCImport;
-exports.generateCreateRouterImport = generateCreateRouterImport;
-function generateBaseRouter(r, e, t) {
-  const a = (0, _internals.parseEnvValue)(t.generator.output);
-  r.addStatements(`
-  import type { Context } from '${(0, _getRelativePath.default)(a, e.contextPath, !0, t.schemaPath)}';
-  `), e.trpcOptionsPath && r.addStatements(`
-    import trpcOptions from '${(0, _getRelativePath.default)(a, e.trpcOptionsPath, !0, t.schemaPath)}';
-    `), r.addStatements(`
-  export const t = trpc.initTRPC.context<Context>().create(${e.trpcOptionsPath ? "trpcOptions" : ""});
-  `);
-  const n = [];
-  if (e.withMiddleware && typeof e.withMiddleware == "boolean" && (r.addStatements(`
+module.exports = __toCommonJS(helpers_exports);
+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 generateMiddlewareImport = /* @__PURE__ */ __name((sourceFile, options) => {
+  const outputDir = (0, import_internals.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 = (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()
-    });`), n.push({
-    type: "global",
-    value: ".use(globalMiddleware)"
-  })), e.withMiddleware && typeof e.withMiddleware == "string" && (r.addStatements(`
-  import defaultMiddleware from '${(0, _getRelativePath.default)(a, e.withMiddleware, !0, t.schemaPath)}';
-  `), r.addStatements(`
-    export const globalMiddleware = t.middleware(defaultMiddleware);`), n.push({
-    type: "global",
-    value: ".use(globalMiddleware)"
-  })), e.withShield && (r.addStatements(`
-    export const permissionsMiddleware = t.middleware(permissions); `), n.push({
-    type: "shield",
-    value: `
+    });`
+    );
+    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)`
-  })), r.addStatements(`
-    export const publicProcedure = t.procedure; `), n.length > 0) {
-    const s = m(e);
-    n.forEach((o, c) => {
-      c === 0 && r.addStatements(`
-    export const ${s} = t.procedure
-      `), r.addStatements(`
-      .use(${o.type === "shield" ? "permissionsMiddleware" : "globalMiddleware"})
-      `);
+      )
+    });
+  }
+  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"})
+      `
+      );
     });
   }
 }
-function generateProcedure(r, e, t, a, n, s, o) {
-  let c = `input${o.withZod ? "" : " as any"}`;
-  const d = e.replace(a, "");
-  d === "groupBy" && o.withZod && (c = "{ where: input.where, orderBy: input.orderBy, by: input.by, having: input.having, take: input.take, skip: input.skip }"), r.addStatements(`${o.showModelNameInProcedure ? e : d}: ${m(o)}
-  ${o.withZod ? `.input(${t})` : ""}.${getProcedureTypeByOpName(s)}(async ({ ctx, input }) => {
-    const ${e} = await ctx.prisma.${(0, _uncapitalizeFirstLetter.uncapitalizeFirstLetter)(a)}.${n.replace("One", "")}(${c});
-    return ${e};
-  }),`);
+__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};
+  }),`
+  );
 }
-function generateRouterSchemaImports(r, e, t) {
-  r.addStatements([...new Set(t.map(a => getRouterSchemaImportByOpName(a, e)))].join(`
-`));
+__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")
+  );
 }
-const getRouterSchemaImportByOpName = (r, e) => {
-    const t = r.replace("OrThrow", ""),
-      a = getInputTypeByOpName(t, e);
-    return a ? `import { ${a} } from "../schemas/${t}${e}.schema"; ` : "";
-  },
-  getInputTypeByOpName = (r, e) => {
-    let t;
-    switch (r) {
-      case "findUnique":
-        t = `${e}FindUniqueSchema`;
-        break;
-      case "findFirst":
-        t = `${e}FindFirstSchema`;
-        break;
-      case "findMany":
-        t = `${e}FindManySchema`;
-        break;
-      case "findRaw":
-        t = `${e}FindRawObjectSchema`;
-        break;
-      case "createOne":
-        t = `${e}CreateOneSchema`;
-        break;
-      case "createMany":
-        t = `${e}CreateManySchema`;
-        break;
-      case "deleteOne":
-        t = `${e}DeleteOneSchema`;
-        break;
-      case "updateOne":
-        t = `${e}UpdateOneSchema`;
-        break;
-      case "deleteMany":
-        t = `${e}DeleteManySchema`;
-        break;
-      case "updateMany":
-        t = `${e}UpdateManySchema`;
-        break;
-      case "upsertOne":
-        t = `${e}UpsertSchema`;
-        break;
-      case "aggregate":
-        t = `${e}AggregateSchema`;
-        break;
-      case "aggregateRaw":
-        t = `${e}AggregateRawObjectSchema`;
-        break;
-      case "groupBy":
-        t = `${e}GroupBySchema`;
-        break;
-      default:
-        console.log("getInputTypeByOpName: ", {
-          opName: r,
-          modelName: e
-        });
-    }
-    return t;
-  },
-  getProcedureTypeByOpName = r => {
-    let e;
-    switch (r) {
-      case "findUnique":
-      case "findFirst":
-      case "findMany":
-      case "findRaw":
-      case "aggregate":
-      case "aggregateRaw":
-      case "groupBy":
-        e = "query";
-        break;
-      case "createOne":
-      case "createMany":
-      case "deleteOne":
-      case "updateOne":
-      case "deleteMany":
-      case "updateMany":
-      case "upsertOne":
-        e = "mutation";
-        break;
-      default:
-        console.log("getProcedureTypeByOpName: ", {
-          opName: r
-        });
-    }
-    return e;
-  };
-exports.getProcedureTypeByOpName = getProcedureTypeByOpName;
-exports.getInputTypeByOpName = getInputTypeByOpName;
-exports.getRouterSchemaImportByOpName = getRouterSchemaImportByOpName;
-function resolveModelsComments(r, e) {
-  const t = /(?:@@Gen\.)+[A-z]+\(.+\)/,
-    a = /\.+[A-Z]+\(+/i,
-    n = /\(+[A-Z]+:.+\)/i;
-  for (const s of r) if (s.documentation) {
-    const o = s.documentation?.match(t)?.[0];
-    if (o?.match(a)?.[0]?.slice(1, -1) !== "model") continue;
-    const d = o?.match(n)?.[0]?.slice(1, -1),
-      h = {};
-    if (d) {
-      const u = d.split(":").map(i => i.trim()).map(i => i.startsWith("[") ? i : i.split(",")).flat().map(i => i.trim());
-      for (let i = 0; i < u.length; i += 2) {
-        const g = u[i],
-          w = u[i + 1];
-        h[g] = JSON.parse(w);
+__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);
       }
     }
-    h.hide && e.push(s.name);
   }
-}
+}
+__name(resolveModelsComments, "resolveModelsComments");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateBaseRouter,
+  generateCreateRouterImport,
+  generateMiddlewareImport,
+  generateProcedure,
+  generateRPCImport,
+  generateRouterImport,
+  generateRouterSchemaImports,
+  generateShieldImport,
+  getInputTypeByOpName,
+  getProcedureTypeByOpName,
+  getRouterSchemaImportByOpName,
+  resolveModelsComments
+});

package/dist/helpers.js

@@ -0,0 +1,29 @@
+import {
+  generateBaseRouter,
+  generateCreateRouterImport,
+  generateMiddlewareImport,
+  generateProcedure,
+  generateRPCImport,
+  generateRouterImport,
+  generateRouterSchemaImports,
+  generateShieldImport,
+  getInputTypeByOpName,
+  getProcedureTypeByOpName,
+  getRouterSchemaImportByOpName,
+  resolveModelsComments
+} from "./chunk-RYVIOFDO.js";
+import "./chunk-SHUYVCID.js";
+export {
+  generateBaseRouter,
+  generateCreateRouterImport,
+  generateMiddlewareImport,
+  generateProcedure,
+  generateRPCImport,
+  generateRouterImport,
+  generateRouterSchemaImports,
+  generateShieldImport,
+  getInputTypeByOpName,
+  getProcedureTypeByOpName,
+  getRouterSchemaImportByOpName,
+  resolveModelsComments
+};