@stryke/prisma-trpc-generator 0.2.1 → 0.2.3

package/dist/prisma-generator.cjs

@@ -1,523 +0,0 @@
-"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);
-
-// src/prisma-generator.ts
-var prisma_generator_exports = {};
-__export(prisma_generator_exports, {
-  generate: () => generate
-});
-module.exports = __toCommonJS(prisma_generator_exports);
-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}})
-    `
-  );
-  appRouter.formatText({
-    indentSize: 2
-  });
-  await project.save();
-}
-__name(generate, "generate");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  generate
-});

package/dist/prisma-generator.js

@@ -1,10 +0,0 @@
-import {
-  generate
-} from "./chunk-GQ7ABBSV.js";
-import "./chunk-V6DNCMCB.js";
-import "./chunk-RYVIOFDO.js";
-import "./chunk-LVOPI6NH.js";
-import "./chunk-SHUYVCID.js";
-export {
-  generate
-};

package/dist/project.cjs

@@ -1,42 +0,0 @@
-"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);
-
-// src/project.ts
-var project_exports = {};
-__export(project_exports, {
-  project: () => project
-});
-module.exports = __toCommonJS(project_exports);
-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
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  project
-});

package/dist/project.js

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