@stryke/prisma-trpc-generator 0.2.0 → 0.2.1

package/dist/prisma-generator.cjs

@@ -1,98 +1,523 @@
 "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");
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// 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
+  }
 });
-exports.generate = generate;
-var _internals = require("@prisma/internals");
-var _nodeFs = require("node:fs");
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _pluralize = _interopRequireDefault(require("pluralize"));
-var _prismaGenerator = require("prisma-trpc-shield-generator/lib/prisma-generator");
-var _prismaGenerator2 = require("prisma-zod-generator/lib/prisma-generator");
-var _config = require("./config.cjs");
-var _helpers = require("./helpers.cjs");
-var _project = require("./project.cjs");
-var _removeDir = _interopRequireDefault(require("./utils/removeDir.cjs"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-async function generate(e) {
-  const o = (0, _internals.parseEnvValue)(e.generator.output),
-    l = _config.configSchema.safeParse(e.generator.config);
-  if (!l.success) throw new Error("Invalid options passed");
-  const t = l.data;
-  if (await _nodeFs.promises.mkdir(o, {
-    recursive: !0
-  }), await (0, _removeDir.default)(o, !0), t.withZod && (await (0, _prismaGenerator2.generate)(e)), t.withShield === !0) {
-    const n = _nodePath.default.join(o, "./shield");
-    await (0, _prismaGenerator.generate)({
-      ...e,
+
+// 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: {
-        ...e.generator,
+        ...options.generator,
         output: {
-          ...e.generator.output,
-          value: n
+          ...options.generator.output,
+          value: shieldOutputPath
         },
         config: {
-          ...e.generator.config,
-          contextPath: t.contextPath
+          ...options.generator.config,
+          contextPath: config.contextPath
         }
       }
     });
   }
-  const F = e.otherGenerators.find(n => (0, _internals.parseEnvValue)(n.provider) === "prisma-client-js"),
-    f = await (0, _internals.getDMMF)({
-      datamodel: e.datamodel,
-      previewFeatures: F.previewFeatures
-    }),
-    R = f.mappings.modelOperations,
-    O = f.datamodel.models,
-    g = [];
-  (0, _helpers.resolveModelsComments)(O, g);
-  const s = _project.project.createSourceFile(_nodePath.default.resolve(o, "routers", "helpers", "createRouter.ts"), void 0, {
-    overwrite: !0
+  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
   });
-  (0, _helpers.generateRPCImport)(s), t.withShield && (0, _helpers.generateShieldImport)(s, e, t.withShield), (0, _helpers.generateBaseRouter)(s, t, e), s.formatText({
+  generateRPCImport(createRouter);
+  if (config.withShield) {
+    generateShieldImport(createRouter, options, config.withShield);
+  }
+  generateBaseRouter(createRouter, config, options);
+  createRouter.formatText({
     indentSize: 2
   });
-  const m = _project.project.createSourceFile(_nodePath.default.resolve(o, "routers", "index.ts"), void 0, {
-    overwrite: !0
+  const appRouter = project.createSourceFile(import_node_path3.default.resolve(outputDir, "routers", `index.ts`), void 0, {
+    overwrite: true
   });
-  (0, _helpers.generateCreateRouterImport)({
-    sourceFile: m
+  generateCreateRouterImport({
+    sourceFile: appRouter
   });
-  const h = [];
-  for (const n of R) {
-    const {
-      model: r,
-      ...w
-    } = n;
-    if (g.includes(r)) continue;
-    const d = Object.keys(w).filter(i => t.generateModelActions.includes(i.replace("One", "")));
-    if (!d.length) continue;
-    const p = (0, _pluralize.default)(r.toLowerCase());
-    (0, _helpers.generateRouterImport)(m, p, r);
-    const a = _project.project.createSourceFile(_nodePath.default.resolve(o, "routers", `${r}.router.ts`), void 0, {
-      overwrite: !0
+  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
     });
-    (0, _helpers.generateCreateRouterImport)({
-      sourceFile: a,
-      config: t
-    }), t.withZod && (0, _helpers.generateRouterSchemaImports)(a, r, d), a.addStatements(`
-      export const ${p}Router = t.router({`);
-    for (const i of d) {
-      const x = w[i],
-        v = i.replace("OrThrow", "");
-      (0, _helpers.generateProcedure)(a, x, (0, _helpers.getInputTypeByOpName)(v, r), r, i, v, t);
+    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);
     }
-    a.addStatements(`
-    })`), a.formatText({
+    modelRouter.addStatements(
+      /* ts */
+      `
+    })`
+    );
+    modelRouter.formatText({
       indentSize: 2
-    }), h.push(`
-      ${r.toLowerCase()}: ${p}Router`);
+    });
+    routerStatements.push(
+      /* ts */
+      `
+      ${model.toLowerCase()}: ${plural}Router`
+    );
   }
-  m.addStatements(`
-    export const appRouter = t.router({${h}})
-    `), m.formatText({
+  appRouter.addStatements(
+    /* ts */
+    `
+    export const appRouter = t.router({${routerStatements}})
+    `
+  );
+  appRouter.formatText({
     indentSize: 2
-  }), await _project.project.save();
-}
+  });
+  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

@@ -0,0 +1,10 @@
+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,19 +1,42 @@
 "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/project.ts
+var project_exports = {};
+__export(project_exports, {
+  project: () => project
 });
-exports.project = void 0;
-var _tsMorph = require("ts-morph");
-const r = {
-  target: _tsMorph.ScriptTarget.ES2019,
-  module: _tsMorph.ModuleKind.CommonJS,
-  emitDecoratorMetadata: !0,
-  experimentalDecorators: !0,
-  esModuleInterop: !0
+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
 };
-const project = exports.project = new _tsMorph.Project({
+var project = new import_ts_morph.Project({
   compilerOptions: {
-    ...r
+    ...compilerOptions
   }
-});
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  project
+});

package/dist/project.js

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