@stryke/prisma-trpc-generator 0.2.14 → 0.2.16

package/dist/generator.cjs

@@ -676,8 +676,8 @@ init_cjs_shims();
 
 // src/prisma-generator.ts
 init_cjs_shims();
-var import_node_fs4 = require("node:fs");
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_fs6 = require("node:fs");
+var import_node_path7 = __toESM(require("node:path"), 1);
 var import_pluralize = __toESM(require_pluralize(), 1);
 
 // src/config.ts
@@ -1045,8 +1045,8 @@ function getErrorMap() {
 }
 __name(getErrorMap, "getErrorMap");
 var makeIssue = /* @__PURE__ */ __name((params) => {
-  const { data, path: path6, errorMaps, issueData } = params;
-  const fullPath = [...path6, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -1180,11 +1180,11 @@ var ParseInputLazyPath = class {
   static {
     __name(this, "ParseInputLazyPath");
   }
-  constructor(parent, value, path6, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path6;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -4945,15 +4945,742 @@ init_cjs_shims();
 
 // src/utils/get-jiti.ts
 init_cjs_shims();
-var import_env = require("@stryke/env");
-var import_path = require("@stryke/path");
+
+// ../env/src/get-env-paths.ts
+init_cjs_shims();
+
+// ../path/src/join-paths.ts
+init_cjs_shims();
+var _DRIVE_LETTER_START_RE = /^[A-Z]:\//i;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+__name(normalizeWindowsPath, "normalizeWindowsPath");
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+var _DRIVE_LETTER_RE = /^[A-Z]:$/i;
+var isAbsolute = /* @__PURE__ */ __name(function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}, "isAbsolute");
+var correctPaths = /* @__PURE__ */ __name(function(path7) {
+  if (!path7 || path7.length === 0) {
+    return ".";
+  }
+  path7 = normalizeWindowsPath(path7);
+  const isUNCPath = path7.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path7);
+  const trailingSeparator = path7[path7.length - 1] === "/";
+  path7 = normalizeString(path7, !isPathAbsolute);
+  if (path7.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path7 += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path7)) {
+    path7 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path7}`;
+    }
+    return `//${path7}`;
+  }
+  return isPathAbsolute && !isAbsolute(path7) ? `/${path7}` : path7;
+}, "correctPaths");
+var joinPaths = /* @__PURE__ */ __name(function(...segments) {
+  let path7 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path7.length > 0) {
+      const pathTrailing = path7[path7.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path7 += seg.slice(1);
+      } else {
+        path7 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path7 += seg;
+    }
+  }
+  return correctPaths(path7);
+}, "joinPaths");
+function normalizeString(path7, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path7.length; ++index) {
+    if (index < path7.length) {
+      char = path7[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path7.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path7.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+__name(normalizeString, "normalizeString");
+
+// ../string-format/src/title-case.ts
+init_cjs_shims();
+
+// ../string-format/src/acronyms.ts
+init_cjs_shims();
+var ACRONYMS = [
+  "API",
+  "CPU",
+  "CSS",
+  "DNS",
+  "EOF",
+  "GUID",
+  "HTML",
+  "HTTP",
+  "HTTPS",
+  "ID",
+  "IP",
+  "JSON",
+  "LHS",
+  "OEM",
+  "PP",
+  "QA",
+  "RAM",
+  "RHS",
+  "RPC",
+  "RSS",
+  "SLA",
+  "SMTP",
+  "SQL",
+  "SSH",
+  "SSL",
+  "TCP",
+  "TLS",
+  "TRPC",
+  "TTL",
+  "UDP",
+  "UI",
+  "UID",
+  "UUID",
+  "URI",
+  "URL",
+  "UTF",
+  "VM",
+  "XML",
+  "XSS",
+  "XSRF"
+];
+
+// ../string-format/src/upper-case-first.ts
+init_cjs_shims();
+var upperCaseFirst = /* @__PURE__ */ __name((input) => {
+  return input ? input.charAt(0).toUpperCase() + input.slice(1) : input;
+}, "upperCaseFirst");
+
+// ../string-format/src/title-case.ts
+var titleCase = /* @__PURE__ */ __name((input) => {
+  if (!input) {
+    return "";
+  }
+  return input.split(/(?=[A-Z])|[\s._-]/).map((s) => s.trim()).filter(Boolean).map((s) => ACRONYMS.includes(s) ? s.toUpperCase() : upperCaseFirst(s.toLowerCase())).join(" ");
+}, "titleCase");
+
+// ../type-checks/src/is-string.ts
+init_cjs_shims();
+var isString = /* @__PURE__ */ __name((value) => {
+  try {
+    return typeof value === "string";
+  } catch {
+    return false;
+  }
+}, "isString");
+
+// ../env/src/get-env-paths.ts
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var homedir = import_node_os.default.homedir();
+var tmpdir = import_node_os.default.tmpdir();
+var macos = /* @__PURE__ */ __name((orgId) => {
+  const library = joinPaths(homedir, "Library");
+  return {
+    data: joinPaths(library, "Application Support", orgId),
+    config: joinPaths(library, "Preferences", orgId),
+    cache: joinPaths(library, "Caches", orgId),
+    log: joinPaths(library, "Logs", orgId),
+    temp: joinPaths(tmpdir, orgId)
+  };
+}, "macos");
+var windows = /* @__PURE__ */ __name((orgId) => {
+  const appData = process.env.APPDATA || joinPaths(homedir, "AppData", "Roaming");
+  const localAppData = process.env.LOCALAPPDATA || joinPaths(homedir, "AppData", "Local");
+  const windowsFormattedOrgId = titleCase(orgId).trim().replace(/\s+/g, "");
+  return {
+    // Data/config/cache/log are invented by me as Windows isn't opinionated about this
+    data: joinPaths(localAppData, windowsFormattedOrgId, "Data"),
+    config: joinPaths(appData, windowsFormattedOrgId, "Config"),
+    cache: joinPaths(localAppData, "Cache", orgId),
+    log: joinPaths(localAppData, windowsFormattedOrgId, "Log"),
+    temp: joinPaths(tmpdir, orgId)
+  };
+}, "windows");
+var linux = /* @__PURE__ */ __name((orgId) => {
+  const username = import_node_path.default.basename(homedir);
+  return {
+    data: joinPaths(process.env.XDG_DATA_HOME || joinPaths(homedir, ".local", "share"), orgId),
+    config: joinPaths(process.env.XDG_CONFIG_HOME || joinPaths(homedir, ".config"), orgId),
+    cache: joinPaths(process.env.XDG_CACHE_HOME || joinPaths(homedir, ".cache"), orgId),
+    // https://wiki.debian.org/XDGBaseDirectorySpecification#state
+    log: joinPaths(process.env.XDG_STATE_HOME || joinPaths(homedir, ".local", "state"), orgId),
+    temp: joinPaths(tmpdir, username, orgId)
+  };
+}, "linux");
+function getEnvPaths(options = {}) {
+  let orgId = options.orgId || "storm-software";
+  if (!orgId) {
+    throw new Error("You need to provide an orgId to the `getEnvPaths` function");
+  }
+  if (options.suffix) {
+    orgId += `-${isString(options.suffix) ? options.suffix : "nodejs"}`;
+  }
+  let result = {};
+  if (process.platform === "darwin") {
+    result = macos(orgId);
+  } else if (process.platform === "win32") {
+    result = windows(orgId);
+  } else {
+    result = linux(orgId);
+  }
+  if (process.env.STORM_DATA_DIRECTORY) {
+    result.data = process.env.STORM_DATA_DIRECTORY;
+  } else if (process.env.STORM_CONFIG_DIRECTORY) {
+    result.config = process.env.STORM_CONFIG_DIRECTORY;
+  } else if (process.env.STORM_CACHE_DIRECTORY) {
+    result.cache = process.env.STORM_CACHE_DIRECTORY;
+  } else if (process.env.STORM_LOG_DIRECTORY) {
+    result.log = process.env.STORM_LOG_DIRECTORY;
+  } else if (process.env.STORM_TEMP_DIRECTORY) {
+    result.temp = process.env.STORM_TEMP_DIRECTORY;
+  }
+  if (options.workspaceRoot) {
+    result.cache ??= joinPaths(options.workspaceRoot, "node_modules", ".cache", orgId);
+    result.temp ??= joinPaths(options.workspaceRoot, "tmp", orgId);
+    result.log ??= joinPaths(result.temp, "logs");
+    result.config ??= joinPaths(options.workspaceRoot, ".config", orgId);
+  }
+  return Object.keys(result).reduce((ret, key) => {
+    if (result[key]) {
+      const filePath = result[key];
+      ret[key] = options.appId && options.appId !== options.orgId && options.appId !== options.nestedDir ? joinPaths(filePath, options.appId) : filePath;
+      if (options.nestedDir && options.nestedDir !== options.orgId && options.nestedDir !== options.appId) {
+        ret[key] = joinPaths(ret[key], options.nestedDir);
+      }
+    }
+    return ret;
+  }, {});
+}
+__name(getEnvPaths, "getEnvPaths");
+
+// ../path/src/get-workspace-root.ts
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/@storm-software+config-tools@1.160.6_@storm-software+config@1.110.6/node_modules/@storm-software/config-tools/dist/index.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/@storm-software+config-tools@1.160.6_@storm-software+config@1.110.6/node_modules/@storm-software/config-tools/dist/chunk-K6PUXRK3.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/@storm-software+config-tools@1.160.6_@storm-software+config@1.110.6/node_modules/@storm-software/config-tools/dist/chunk-NQFXB5CV.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/@storm-software+config-tools@1.160.6_@storm-software+config@1.110.6/node_modules/@storm-software/config-tools/dist/chunk-SHUYVCID.js
+init_cjs_shims();
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", {
+  value,
+  configurable: true
+}), "__name");
+
+// ../../node_modules/.pnpm/@storm-software+config-tools@1.160.6_@storm-software+config@1.110.6/node_modules/@storm-software/config-tools/dist/chunk-NQFXB5CV.js
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
+  const _startPath = startPath ?? process.cwd();
+  if (endDirectoryNames.some((endDirName) => (0, import_node_fs.existsSync)((0, import_node_path2.join)(_startPath, endDirName)))) {
+    return _startPath;
+  }
+  if (endFileNames.some((endFileName) => (0, import_node_fs.existsSync)((0, import_node_path2.join)(_startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = (0, import_node_path2.join)(_startPath, "..");
+    return findFolderUp(parent, endFileNames, endDirectoryNames);
+  }
+  return void 0;
+}
+__name(findFolderUp, "findFolderUp");
+__name2(findFolderUp, "findFolderUp");
+
+// ../../node_modules/.pnpm/@storm-software+config-tools@1.160.6_@storm-software+config@1.110.6/node_modules/@storm-software/config-tools/dist/chunk-D6E6GZD2.js
+init_cjs_shims();
+var _DRIVE_LETTER_START_RE2 = /^[A-Za-z]:\//;
+function normalizeWindowsPath2(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE2, (r) => r.toUpperCase());
+}
+__name(normalizeWindowsPath2, "normalizeWindowsPath");
+__name2(normalizeWindowsPath2, "normalizeWindowsPath");
+var _UNC_REGEX2 = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE2 = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE2 = /^[A-Za-z]:$/;
+var correctPaths2 = /* @__PURE__ */ __name2(function(path7) {
+  if (!path7 || path7.length === 0) {
+    return ".";
+  }
+  path7 = normalizeWindowsPath2(path7);
+  const isUNCPath = path7.match(_UNC_REGEX2);
+  const isPathAbsolute = isAbsolute2(path7);
+  const trailingSeparator = path7[path7.length - 1] === "/";
+  path7 = normalizeString2(path7, !isPathAbsolute);
+  if (path7.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path7 += "/";
+  }
+  if (_DRIVE_LETTER_RE2.test(path7)) {
+    path7 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path7}`;
+    }
+    return `//${path7}`;
+  }
+  return isPathAbsolute && !isAbsolute2(path7) ? `/${path7}` : path7;
+}, "correctPaths");
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+__name(cwd, "cwd");
+__name2(cwd, "cwd");
+function normalizeString2(path7, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path7.length; ++index) {
+    if (index < path7.length) {
+      char = path7[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path7.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path7.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+__name(normalizeString2, "normalizeString");
+__name2(normalizeString2, "normalizeString");
+var isAbsolute2 = /* @__PURE__ */ __name2(function(p) {
+  return _IS_ABSOLUTE_RE2.test(p);
+}, "isAbsolute");
+
+// ../../node_modules/.pnpm/@storm-software+config-tools@1.160.6_@storm-software+config@1.110.6/node_modules/@storm-software/config-tools/dist/chunk-K6PUXRK3.js
+var rootFiles = [
+  "storm-workspace.json",
+  "storm-workspace.json",
+  "storm-workspace.yaml",
+  "storm-workspace.yml",
+  "storm-workspace.js",
+  "storm-workspace.ts",
+  ".storm-workspace.json",
+  ".storm-workspace.yaml",
+  ".storm-workspace.yml",
+  ".storm-workspace.js",
+  ".storm-workspace.ts",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "npm-workspace.json",
+  "yarn-workspace.json",
+  "pnpm-workspace.json",
+  "npm-workspace.yaml",
+  "yarn-workspace.yaml",
+  "pnpm-workspace.yaml",
+  "npm-workspace.yml",
+  "yarn-workspace.yml",
+  "pnpm-workspace.yml",
+  "npm-lock.json",
+  "yarn-lock.json",
+  "pnpm-lock.json",
+  "npm-lock.yaml",
+  "yarn-lock.yaml",
+  "pnpm-lock.yaml",
+  "npm-lock.yml",
+  "yarn-lock.yml",
+  "pnpm-lock.yml",
+  "bun.lockb"
+];
+var rootDirectories = [
+  ".storm-workspace",
+  ".nx",
+  ".github",
+  ".vscode",
+  ".verdaccio"
+];
+function findWorkspaceRootSafe(pathInsideMonorepo) {
+  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+    return correctPaths2(process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH);
+  }
+  return correctPaths2(findFolderUp(pathInsideMonorepo ?? process.cwd(), rootFiles, rootDirectories));
+}
+__name(findWorkspaceRootSafe, "findWorkspaceRootSafe");
+__name2(findWorkspaceRootSafe, "findWorkspaceRootSafe");
+function findWorkspaceRoot(pathInsideMonorepo) {
+  const result = findWorkspaceRootSafe(pathInsideMonorepo);
+  if (!result) {
+    throw new Error(`Cannot find workspace root upwards from known path. Files search list includes: 
+${rootFiles.join("\n")}
+Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`);
+  }
+  return result;
+}
+__name(findWorkspaceRoot, "findWorkspaceRoot");
+__name2(findWorkspaceRoot, "findWorkspaceRoot");
+
+// ../path/src/get-parent-path.ts
+init_cjs_shims();
+
+// ../path/src/file-path-fns.ts
+init_cjs_shims();
+
+// ../types/src/base.ts
+init_cjs_shims();
+var $NestedValue = Symbol("NestedValue");
+
+// ../path/src/correct-path.ts
+init_cjs_shims();
+
+// ../path/src/is-file.ts
+init_cjs_shims();
+var import_node_fs2 = require("node:fs");
+function isFile(path7, additionalPath) {
+  return Boolean((0, import_node_fs2.statSync)(additionalPath ? joinPaths(additionalPath, path7) : path7, {
+    throwIfNoEntry: false
+  })?.isFile());
+}
+__name(isFile, "isFile");
+function isDirectory(path7, additionalPath) {
+  return Boolean((0, import_node_fs2.statSync)(additionalPath ? joinPaths(additionalPath, path7) : path7, {
+    throwIfNoEntry: false
+  })?.isDirectory());
+}
+__name(isDirectory, "isDirectory");
+function isAbsolutePath(path7) {
+  return !/^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i.test(path7);
+}
+__name(isAbsolutePath, "isAbsolutePath");
+
+// ../path/src/correct-path.ts
+var _DRIVE_LETTER_START_RE3 = /^[A-Z]:\//i;
+function normalizeWindowsPath3(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE3, (r) => r.toUpperCase());
+}
+__name(normalizeWindowsPath3, "normalizeWindowsPath");
+function normalizeString3(path7, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path7.length; ++index) {
+    if (index < path7.length) {
+      char = path7[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path7.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path7.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+__name(normalizeString3, "normalizeString");
+
+// ../path/src/file-path-fns.ts
+function resolvePath(path7, cwd2 = getWorkspaceRoot()) {
+  const paths = normalizeWindowsPath3(path7).split("/");
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = paths.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path8 = index >= 0 ? paths[index] : cwd2;
+    if (!path8 || path8.length === 0) {
+      continue;
+    }
+    resolvedPath = joinPaths(path8, resolvedPath);
+    resolvedAbsolute = isAbsolutePath(path8);
+  }
+  resolvedPath = normalizeString3(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolutePath(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+}
+__name(resolvePath, "resolvePath");
+function resolvePaths(...paths) {
+  return resolvePath(joinPaths(...paths.map((path7) => normalizeWindowsPath3(path7))));
+}
+__name(resolvePaths, "resolvePaths");
+
+// ../path/src/get-parent-path.ts
+var resolveParentPath = /* @__PURE__ */ __name((path7) => {
+  return resolvePaths(path7, "..");
+}, "resolveParentPath");
+var getParentPath = /* @__PURE__ */ __name((name, cwd2, options) => {
+  const ignoreCase = options?.ignoreCase ?? true;
+  const skipCwd = options?.skipCwd ?? false;
+  const targetType = options?.targetType ?? "both";
+  let dir = cwd2;
+  if (skipCwd) {
+    dir = resolveParentPath(cwd2);
+  }
+  let names = Array.isArray(name) ? name : [
+    name
+  ];
+  if (ignoreCase) {
+    names = names.map((name2) => name2.toLowerCase());
+  }
+  while (true) {
+    const target = names.find((name2) => isFile(joinPaths(dir, name2)) && (targetType === "file" || targetType === "both") || isDirectory(joinPaths(dir, name2)) && (targetType === "directory" || targetType === "both"));
+    if (target) {
+      return joinPaths(dir, target);
+    }
+    const parentDir = resolveParentPath(dir);
+    if (parentDir === dir) {
+      return void 0;
+    }
+    dir = parentDir;
+  }
+}, "getParentPath");
+
+// ../path/src/is-root-dir.ts
+init_cjs_shims();
+var isSystemRoot = /* @__PURE__ */ __name((dir) => {
+  return Boolean(dir === "/" || dir === "c:\\" || dir === "C:\\");
+}, "isSystemRoot");
+
+// ../path/src/get-workspace-root.ts
+var getWorkspaceRoot = /* @__PURE__ */ __name((dir = process.cwd()) => {
+  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+    return process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH;
+  }
+  const root = findWorkspaceRootSafe(dir);
+  if (root) {
+    return root;
+  }
+  let result = getParentPath([
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "nx.json",
+    "knip.json",
+    "pnpm-workspace.yaml",
+    "LICENSE",
+    ".all-contributorsrc",
+    ".whitesource",
+    "syncpack.config.js",
+    "syncpack.json",
+    "socket.yaml",
+    "lefthook.yaml",
+    ".npmrc",
+    ".log4brains.yml",
+    ".huskyrc",
+    ".husky",
+    ".lintstagedrc",
+    ".commitlintrc",
+    "lefthook.yml",
+    ".github",
+    ".nx",
+    ".vscode",
+    "patches"
+  ], dir);
+  if (result) {
+    return result;
+  }
+  result = dir;
+  while (result && !isSystemRoot(result)) {
+    result = getParentPath("storm.json", result, {
+      skipCwd: true
+    });
+    if (result) {
+      return result;
+    }
+  }
+  return dir;
+}, "getWorkspaceRoot");
+
+// src/utils/get-jiti.ts
 var import_jiti = require("jiti");
 var jiti;
 function getJiti() {
   if (!jiti) {
-    const envPaths = (0, import_env.getEnvPaths)();
-    jiti = (0, import_jiti.createJiti)((0, import_path.getWorkspaceRoot)(), {
-      fsCache: (0, import_path.joinPaths)(envPaths.cache, "jiti"),
+    const envPaths = getEnvPaths();
+    jiti = (0, import_jiti.createJiti)(getWorkspaceRoot(), {
+      fsCache: joinPaths(envPaths.cache, "jiti"),
       interopDefault: true
     });
   }
@@ -4973,16 +5700,16 @@ __name(getPrismaGeneratorHelper, "getPrismaGeneratorHelper");
 
 // src/utils/get-relative-path.ts
 init_cjs_shims();
-var import_node_path = __toESM(require("node:path"), 1);
+var import_node_path3 = __toESM(require("node: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);
+  const fromPath = import_node_path3.default.join(outputPath, "routers", "helpers");
+  let toPath = import_node_path3.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 schemaPathSplit = schemaPath?.split(import_node_path3.default.sep);
+    const schemaPathWithoutFileAndExtension = schemaPathSplit.slice(0, schemaPathSplit.length - 1).join(import_node_path3.default.posix.sep);
+    toPath = import_node_path3.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);
+  const newPath = import_node_path3.default.relative(fromPath, toPath).split(import_node_path3.default.sep).join(import_node_path3.default.posix.sep);
   return newPath;
 }
 __name(getRelativePath, "getRelativePath");
@@ -5349,31 +6076,31 @@ var constructShield = /* @__PURE__ */ __name(async ({ queries, mutations, subscr
 
 // src/prisma-shield-generator.ts
 init_cjs_shims();
-var import_node_fs3 = require("node:fs");
-var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_fs5 = require("node:fs");
+var import_node_path6 = __toESM(require("node:path"), 1);
 
 // src/utils/remove-dir.ts
 init_cjs_shims();
-var import_node_fs = require("node:fs");
-var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = __toESM(require("node:path"), 1);
 async function removeDir(dirPath, onlyContent) {
-  const dirEntries = await import_node_fs.promises.readdir(dirPath, {
+  const dirEntries = await import_node_fs3.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);
+    const fullPath = import_node_path4.default.join(dirPath, dirEntry.name);
+    return dirEntry.isDirectory() ? removeDir(fullPath, false) : import_node_fs3.promises.unlink(fullPath);
   }));
   if (!onlyContent) {
-    await import_node_fs.promises.rmdir(dirPath);
+    await import_node_fs3.promises.rmdir(dirPath);
   }
 }
 __name(removeDir, "removeDir");
 
 // src/utils/write-file-safely.ts
 init_cjs_shims();
-var import_node_fs2 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
 
 // src/utils/format-file.ts
 init_cjs_shims();
@@ -5402,10 +6129,10 @@ __name(formatFile, "formatFile");
 
 // src/utils/write-file-safely.ts
 var writeFileSafely = /* @__PURE__ */ __name(async (writeLocation, content) => {
-  import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(writeLocation), {
+  import_node_fs4.default.mkdirSync(import_node_path5.default.dirname(writeLocation), {
     recursive: true
   });
-  import_node_fs2.default.writeFileSync(writeLocation, await formatFile(content));
+  import_node_fs4.default.writeFileSync(writeLocation, await formatFile(content));
 }, "writeFileSafely");
 
 // src/prisma-shield-generator.ts
@@ -5415,7 +6142,7 @@ async function generateShield(options) {
   const results = configSchema.safeParse(options.generator.config);
   if (!results.success) throw new Error("Invalid options passed");
   const config = results.data;
-  await import_node_fs3.promises.mkdir(outputDir, {
+  await import_node_fs5.promises.mkdir(outputDir, {
     recursive: true
   });
   await removeDir(outputDir, true);
@@ -5459,7 +6186,7 @@ async function generateShield(options) {
     mutations,
     subscriptions
   }, config, options);
-  await writeFileSafely(import_node_path4.default.join(outputDir, "shield.ts"), shieldText);
+  await writeFileSafely(import_node_path6.default.join(outputDir, "shield.ts"), shieldText);
 }
 __name(generateShield, "generateShield");
 
@@ -5484,9 +6211,11 @@ async function generate(options) {
   const internals = await getPrismaInternals();
   const outputDir = internals.parseEnvValue(options.generator.output);
   const results = configSchema.safeParse(options.generator.config);
-  if (!results.success) throw new Error("Invalid options passed");
+  if (!results.success) {
+    throw new Error("Invalid options passed");
+  }
   const config = results.data;
-  await import_node_fs4.promises.mkdir(outputDir, {
+  await import_node_fs6.promises.mkdir(outputDir, {
     recursive: true
   });
   await removeDir(outputDir, true);
@@ -5495,7 +6224,7 @@ async function generate(options) {
     await prismaZodGenerator.generate(options);
   }
   if (config.withShield !== false) {
-    const shieldOutputPath = import_node_path5.default.join(outputDir, "./shield");
+    const shieldOutputPath = import_node_path7.default.join(outputDir, "./shield");
     await generateShield({
       ...options,
       generator: {
@@ -5521,7 +6250,7 @@ async function generate(options) {
   const models = prismaClientDmmf.datamodel.models;
   const hiddenModels = [];
   resolveModelsComments(models, hiddenModels);
-  const createRouter = project.createSourceFile(import_node_path5.default.resolve(outputDir, "routers", "helpers", "createRouter.ts"), void 0, {
+  const createRouter = project.createSourceFile(import_node_path7.default.resolve(outputDir, "routers", "helpers", "createRouter.ts"), void 0, {
     overwrite: true
   });
   generateRPCImport(createRouter);
@@ -5532,7 +6261,7 @@ async function generate(options) {
   createRouter.formatText({
     indentSize: 2
   });
-  const appRouter = project.createSourceFile(import_node_path5.default.resolve(outputDir, "routers", `index.ts`), void 0, {
+  const appRouter = project.createSourceFile(import_node_path7.default.resolve(outputDir, "routers", `index.ts`), void 0, {
     overwrite: true
   });
   generateCreateRouterImport({
@@ -5546,7 +6275,7 @@ async function generate(options) {
     if (!modelActions.length) continue;
     const plural = (0, import_pluralize.default)(model.toLowerCase());
     generateRouterImport(appRouter, plural, model);
-    const modelRouter = project.createSourceFile(import_node_path5.default.resolve(outputDir, "routers", `${model}.router.ts`), void 0, {
+    const modelRouter = project.createSourceFile(import_node_path7.default.resolve(outputDir, "routers", `${model}.router.ts`), void 0, {
       overwrite: true
     });
     generateCreateRouterImport({