@cedarjs/project-config 7.0.1-next.467 → 7.1.0-rc.32

package/dist/cjs/index.js

@@ -0,0 +1,782 @@
+"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 __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+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/prismaClientOutputDirsWorkerUrl.ts
+var prismaClientOutputDirsWorkerUrl_exports = {};
+__export(prismaClientOutputDirsWorkerUrl_exports, {
+  prismaClientOutputDirsWorkerUrl: () => prismaClientOutputDirsWorkerUrl
+});
+var import_meta, prismaClientOutputDirsWorkerUrl;
+var init_prismaClientOutputDirsWorkerUrl = __esm({
+  "src/prismaClientOutputDirsWorkerUrl.ts"() {
+    "use strict";
+    import_meta = {};
+    prismaClientOutputDirsWorkerUrl = new URL(
+      "./prismaClientOutputDirsWorker.js",
+      import_meta.url
+    );
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  TargetEnum: () => TargetEnum,
+  createPrismaClientFileMatcher: () => createPrismaClientFileMatcher,
+  ensurePosixPath: () => ensurePosixPath,
+  findUp: () => findUp,
+  getAppRouteHook: () => getAppRouteHook,
+  getBaseDir: () => getBaseDir,
+  getBaseDirFromFile: () => getBaseDirFromFile,
+  getBuiltDocumentFile: () => getBuiltDocumentFile,
+  getBuiltServerEntryFile: () => getBuiltServerEntryFile,
+  getConfig: () => getConfig,
+  getConfigPath: () => getConfigPath,
+  getDataMigrationsPath: () => getDataMigrationsPath,
+  getDbDir: () => getDbDir,
+  getEnvVarDefinitions: () => getEnvVarDefinitions,
+  getGeneratedDataDirPath: () => getGeneratedDataDirPath,
+  getMigrationsPath: () => getMigrationsPath,
+  getPaths: () => getPaths,
+  getPrismaClientOutputDirs: () => getPrismaClientOutputDirs,
+  getPrismaClientOutputDirsIsolated: () => getPrismaClientOutputDirsIsolated,
+  getPrismaDatasourceProvider: () => getPrismaDatasourceProvider,
+  getPrismaSchemas: () => getPrismaSchemas,
+  getRawConfig: () => getRawConfig,
+  getRouteHookForPage: () => getRouteHookForPage,
+  getSchemaPath: () => getSchemaPath,
+  importStatementPath: () => importStatementPath,
+  isTypeScriptProject: () => isTypeScriptProject,
+  loadPrismaConfig: () => loadPrismaConfig,
+  parsePort: () => parsePort,
+  processPagesDir: () => processPagesDir,
+  projectIsEsm: () => projectIsEsm,
+  projectRootIsEsm: () => projectRootIsEsm,
+  projectSideIsEsm: () => projectSideIsEsm,
+  readEnvVar: () => readEnvVar,
+  resolveFile: () => resolveFile,
+  resolveGeneratedPrismaClient: () => resolveGeneratedPrismaClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_deepmerge = __toESM(require("deepmerge"), 1);
+var toml = __toESM(require("smol-toml"), 1);
+var import_string_env_interpolation = require("string-env-interpolation");
+
+// src/findUp.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_path = __toESM(require("path"), 1);
+function findUp(file, startingDirectory = process.cwd()) {
+  const possibleFilepath = import_path.default.join(startingDirectory, file);
+  if (import_node_fs.default.existsSync(possibleFilepath)) {
+    return possibleFilepath;
+  }
+  const parentDirectory = import_path.default.dirname(startingDirectory);
+  if (parentDirectory === startingDirectory) {
+    return null;
+  }
+  return findUp(file, parentDirectory);
+}
+
+// src/configPath.ts
+var CONFIG_FILE_NAMES = ["cedar.toml", "redwood.toml"];
+var getConfigPathCache = /* @__PURE__ */ new Map();
+var getConfigPath = (cwd = process.env.CEDAR_CWD ?? process.env.RWJS_CWD ?? process.cwd()) => {
+  const cachedPath = getConfigPathCache.get(cwd);
+  if (cachedPath) {
+    return cachedPath;
+  }
+  const configPath = findUp("cedar.toml", cwd) || findUp("redwood.toml", cwd);
+  if (!configPath) {
+    throw new Error(
+      `Could not find a "${CONFIG_FILE_NAMES.join('" or "')}" file, are you sure you're in a Cedar project?`
+    );
+  }
+  getConfigPathCache.set(cwd, configPath);
+  return configPath;
+};
+
+// src/config.ts
+var TargetEnum = /* @__PURE__ */ ((TargetEnum2) => {
+  TargetEnum2["NODE"] = "node";
+  TargetEnum2["BROWSER"] = "browser";
+  TargetEnum2["REACT_NATIVE"] = "react-native";
+  TargetEnum2["ELECTRON"] = "electron";
+  return TargetEnum2;
+})(TargetEnum || {});
+var DEFAULT_CONFIG = {
+  web: {
+    title: "Cedar App",
+    port: 8910,
+    path: "./web",
+    target: "browser" /* BROWSER */,
+    includeEnvironmentVariables: [],
+    apiUrl: "/.api/functions",
+    fastRefresh: true,
+    a11y: true,
+    sourceMap: false
+  },
+  api: {
+    title: "Cedar App",
+    port: 8911,
+    path: "./api",
+    target: "node" /* NODE */,
+    prismaConfig: "./api/prisma.config.cjs",
+    prismaGenerateArgs: [],
+    serverConfig: "./api/server.config.js",
+    debugPort: void 0
+  },
+  graphql: {
+    fragments: false,
+    trustedDocuments: false,
+    includeScalars: { File: true }
+  },
+  browser: {
+    open: false
+  },
+  generate: {
+    tests: true,
+    stories: true,
+    nestScaffoldByModel: true
+  },
+  notifications: {
+    versionUpdates: []
+  },
+  studio: {
+    basePort: 4318,
+    graphiql: {
+      authImpersonation: {
+        authProvider: void 0,
+        userId: void 0,
+        email: void 0,
+        jwtSecret: "secret"
+      }
+    }
+  },
+  test: {
+    autoConsentToDbReset: false
+  },
+  experimental: {
+    opentelemetry: {
+      enabled: false,
+      wrapApi: true
+    },
+    cli: {
+      autoInstall: true,
+      plugins: [
+        {
+          package: "@cedarjs/cli-storybook-vite"
+        },
+        {
+          package: "@cedarjs/cli-data-migrate"
+        }
+      ]
+    },
+    useSDLCodeGenForGraphQLTypes: false,
+    streamingSsr: {
+      enabled: false
+    },
+    rsc: {
+      enabled: false
+    },
+    realtime: {
+      enabled: false
+    },
+    reactCompiler: {
+      enabled: false,
+      lintOnly: false
+    },
+    packagesWorkspace: {
+      enabled: false
+    },
+    gqlorm: {
+      enabled: false,
+      organizationModel: "Organization",
+      membershipModel: "Membership",
+      membershipUserField: "userId",
+      membershipOrganizationField: "organizationId"
+    }
+  }
+};
+function getConfig(configPath) {
+  const config = (0, import_deepmerge.default)(DEFAULT_CONFIG, getRawConfig(configPath));
+  return config;
+}
+function getRawConfig(configPath = getConfigPath()) {
+  try {
+    return toml.parse((0, import_string_env_interpolation.env)(import_node_fs2.default.readFileSync(configPath, "utf8")));
+  } catch (e) {
+    throw new Error(`Could not parse "${configPath}": ${e}`);
+  }
+}
+
+// src/envVars.ts
+function readEnvVar(name, { deprecatedAlias }) {
+  return process.env[name] || process.env[deprecatedAlias] || void 0;
+}
+function parsePort(value, envVarName) {
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(
+      `Invalid ${envVarName} env var value: "${value}". Must be an integer.`
+    );
+  }
+  const port = Number(trimmed);
+  if (port > 65535) {
+    throw new Error(
+      `Invalid ${envVarName} env var value: "${value}". Must be between 0 and 65535.`
+    );
+  }
+  return port;
+}
+
+// src/generatedDataDir.ts
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+function getGeneratedDataDirPath(cwd = process.env.CEDAR_CWD ?? process.env.RWJS_CWD ?? process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  const projectRoot = import_node_path.default.dirname(configPath);
+  const rootDotCedarDir = import_node_path.default.join(projectRoot, ".cedar");
+  const rootDotRedwoodDir = import_node_path.default.join(projectRoot, ".redwood");
+  const generatedDirPath = import_node_fs3.default.existsSync(rootDotCedarDir) ? rootDotCedarDir : import_node_fs3.default.existsSync(rootDotRedwoodDir) ? rootDotRedwoodDir : rootDotCedarDir;
+  return generatedDirPath;
+}
+
+// src/paths.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var getBaseDir = (configPath = getConfigPath()) => {
+  return import_path2.default.dirname(configPath);
+};
+var getBaseDirFromFile = (file) => {
+  return getBaseDir(getConfigPath(import_path2.default.dirname(file)));
+};
+var resolveFile = (filePath, extensions = [".js", ".tsx", ".ts", ".jsx", ".mjs", ".mts", ".cjs"]) => {
+  for (const extension of extensions) {
+    const p = `${filePath}${extension}`;
+    if (import_node_fs4.default.existsSync(p)) {
+      return p;
+    }
+  }
+  return null;
+};
+var getPathsCache = /* @__PURE__ */ new Map();
+function getPaths(BASE_DIR = getBaseDir()) {
+  if (getPathsCache.has(BASE_DIR)) {
+    return getPathsCache.get(BASE_DIR);
+  }
+  const routes = resolveFile(import_path2.default.join(BASE_DIR, "web/src/Routes"));
+  const { prismaConfig: prismaConfigFromConfig } = getConfig(
+    getConfigPath(BASE_DIR)
+  ).api;
+  const prismaConfigBase = import_path2.default.join(
+    BASE_DIR,
+    prismaConfigFromConfig.replace(/\.[^.]+$/, "")
+  );
+  const prismaConfig = resolveFile(prismaConfigBase) || import_path2.default.join(BASE_DIR, prismaConfigFromConfig);
+  const viteConfig = resolveFile(
+    import_path2.default.join(BASE_DIR, "web/vite.config")
+  );
+  const generatedBase = getGeneratedDataDirPath(BASE_DIR);
+  const paths = {
+    base: BASE_DIR,
+    generated: {
+      base: generatedBase,
+      schema: import_path2.default.join(generatedBase, "schema.graphql"),
+      types: {
+        includes: import_path2.default.join(generatedBase, "types/includes"),
+        mirror: import_path2.default.join(generatedBase, "types/mirror")
+      },
+      prebuild: import_path2.default.join(generatedBase, "prebuild")
+    },
+    scripts: import_path2.default.join(BASE_DIR, "scripts"),
+    packages: import_path2.default.join(BASE_DIR, "packages"),
+    generatorTemplates: import_path2.default.join(BASE_DIR, "generatorTemplates"),
+    api: {
+      base: import_path2.default.join(BASE_DIR, "api"),
+      prismaConfig,
+      functions: import_path2.default.join(BASE_DIR, "api/src/functions"),
+      graphql: import_path2.default.join(BASE_DIR, "api/src/graphql"),
+      lib: import_path2.default.join(BASE_DIR, "api/src/lib"),
+      config: import_path2.default.join(BASE_DIR, "api/src/config"),
+      services: import_path2.default.join(BASE_DIR, "api/src/services"),
+      directives: import_path2.default.join(BASE_DIR, "api/src/directives"),
+      subscriptions: import_path2.default.join(BASE_DIR, "api/src/subscriptions"),
+      src: import_path2.default.join(BASE_DIR, "api/src"),
+      dist: import_path2.default.join(BASE_DIR, "api/dist"),
+      types: import_path2.default.join(BASE_DIR, "api/types"),
+      models: import_path2.default.join(BASE_DIR, "api/src/models"),
+      mail: import_path2.default.join(BASE_DIR, "api/src", "mail"),
+      jobs: import_path2.default.join(BASE_DIR, "api/src/jobs"),
+      distJobs: import_path2.default.join(BASE_DIR, "api/dist/jobs"),
+      jobsConfig: resolveFile(import_path2.default.join(BASE_DIR, "api/src/lib", "jobs")),
+      distJobsConfig: resolveFile(
+        import_path2.default.join(BASE_DIR, "api/dist", "lib", "jobs")
+      ),
+      logger: resolveFile(import_path2.default.join(BASE_DIR, "api/src/lib", "logger"))
+    },
+    web: {
+      routes,
+      base: import_path2.default.join(BASE_DIR, "web"),
+      pages: import_path2.default.join(BASE_DIR, "web/src/pages/"),
+      components: import_path2.default.join(BASE_DIR, "web/src/components"),
+      layouts: import_path2.default.join(BASE_DIR, "web/src/layouts/"),
+      src: import_path2.default.join(BASE_DIR, "web/src"),
+      storybook: import_path2.default.join(BASE_DIR, "web/.storybook"),
+      app: resolveFile(import_path2.default.join(BASE_DIR, "web/src/App")),
+      document: resolveFile(import_path2.default.join(BASE_DIR, "web/src/Document")),
+      html: import_path2.default.join(BASE_DIR, "web/index.html"),
+      config: import_path2.default.join(BASE_DIR, "web/config"),
+      viteConfig,
+      postcss: import_path2.default.join(BASE_DIR, "web/config/postcss.config.cjs"),
+      storybookConfig: import_path2.default.join(BASE_DIR, "web/.storybook/main.js"),
+      storybookPreviewConfig: resolveFile(
+        import_path2.default.join(BASE_DIR, "web/.storybook/preview")
+      ),
+      storybookManagerConfig: import_path2.default.join(BASE_DIR, "web/.storybook/manager.js"),
+      dist: import_path2.default.join(BASE_DIR, "web/dist"),
+      distBrowser: import_path2.default.join(BASE_DIR, "web/dist/browser"),
+      distRsc: import_path2.default.join(BASE_DIR, "web/dist/rsc"),
+      distSsr: import_path2.default.join(BASE_DIR, "web/dist/ssr"),
+      distSsrDocument: import_path2.default.join(BASE_DIR, "web/dist/ssr/Document"),
+      distSsrEntryServer: import_path2.default.join(BASE_DIR, "web/dist/ssr/entry.server"),
+      distRouteHooks: import_path2.default.join(BASE_DIR, "web/dist/ssr/routeHooks"),
+      distRscEntries: import_path2.default.join(BASE_DIR, "web/dist/rsc/entries.mjs"),
+      routeManifest: import_path2.default.join(BASE_DIR, "web/dist/ssr/route-manifest.json"),
+      types: import_path2.default.join(BASE_DIR, "web/types"),
+      entryClient: resolveFile(import_path2.default.join(BASE_DIR, "web/src/entry.client")),
+      // new vite/stream entry point for client
+      entryServer: resolveFile(import_path2.default.join(BASE_DIR, "web/src/entry.server")),
+      graphql: import_path2.default.join(BASE_DIR, "web/src/graphql")
+    }
+  };
+  import_node_fs4.default.mkdirSync(paths.generated.types.includes, { recursive: true });
+  import_node_fs4.default.mkdirSync(paths.generated.types.mirror, { recursive: true });
+  getPathsCache.set(BASE_DIR, paths);
+  return paths;
+}
+var getRouteHookForPage = (pagePath) => {
+  if (!pagePath) {
+    return null;
+  }
+  return import_fast_glob.default.sync("*.routeHooks.{js,ts,tsx,jsx}", {
+    absolute: true,
+    cwd: import_path2.default.dirname(pagePath)
+    // the page's folder
+  }).at(0) || null;
+};
+var getAppRouteHook = (forProd = false) => {
+  const rwPaths = getPaths();
+  if (forProd) {
+    const distAppRouteHook = import_path2.default.join(
+      rwPaths.web.distRouteHooks,
+      "App.routeHooks.js"
+    );
+    try {
+      import_node_fs4.default.statSync(distAppRouteHook).isFile();
+      return distAppRouteHook;
+    } catch {
+      return null;
+    }
+  }
+  return resolveFile(import_path2.default.join(rwPaths.web.src, "App.routeHooks"));
+};
+function getBuiltServerEntryFile() {
+  const entryServer = getPaths().web.distSsrEntryServer;
+  const resolvedEntryServer = resolveFile(entryServer);
+  if (!resolvedEntryServer) {
+    throw new Error("Server entry file not found (" + entryServer + ")");
+  }
+  return resolvedEntryServer;
+}
+function getBuiltDocumentFile() {
+  const document = getPaths().web.distSsrDocument;
+  const resolvedDocument = resolveFile(document);
+  if (!resolvedDocument) {
+    throw new Error("Document file not found (" + document + ")");
+  }
+  return resolvedDocument;
+}
+var processPagesDir = (webPagesDir = getPaths().web.pages) => {
+  const pagePaths = import_fast_glob.default.sync("**/*Page.{js,jsx,ts,tsx}", {
+    cwd: webPagesDir,
+    ignore: ["node_modules"]
+  });
+  return pagePaths.map((pagePath) => {
+    const p = import_path2.default.parse(pagePath);
+    const importName = p.dir.replace(/\//g, "");
+    const importPath = importStatementPath(
+      import_path2.default.join(webPagesDir, p.dir, p.name)
+    );
+    const importStatement = `const ${importName} = { name: '${importName}', loader: import('${importPath}') }`;
+    return {
+      importName,
+      constName: importName,
+      importPath,
+      path: import_path2.default.join(webPagesDir, pagePath),
+      importStatement
+    };
+  });
+};
+var ensurePosixPath = (path7) => {
+  let posixPath = path7;
+  if (process.platform === "win32") {
+    if (/^[A-Z]:\\/.test(path7)) {
+      const drive = path7[0].toLowerCase();
+      posixPath = `/${drive}/${path7.substring(3)}`;
+    }
+    posixPath = posixPath.replace(/\\/g, "/");
+  }
+  return posixPath;
+};
+var importStatementPath = (path7) => {
+  let importPath = path7;
+  if (process.platform === "win32") {
+    importPath = importPath.replaceAll("\\", "/");
+  }
+  return importPath;
+};
+function packageJsonIsEsm(packageJsonPath) {
+  const packageJsonContents = JSON.parse(
+    import_node_fs4.default.readFileSync(packageJsonPath, "utf-8")
+  );
+  return packageJsonContents.type === "module";
+}
+function projectRootIsEsm() {
+  return packageJsonIsEsm(import_path2.default.join(getPaths().base, "package.json"));
+}
+function projectSideIsEsm(side) {
+  const cedarProjectPaths = getPaths();
+  return packageJsonIsEsm(
+    import_path2.default.join(cedarProjectPaths[side].base, "package.json")
+  );
+}
+function projectIsEsm() {
+  if (!projectRootIsEsm()) {
+    return false;
+  }
+  for (const side of ["api", "web"]) {
+    if (!projectSideIsEsm(side)) {
+      return false;
+    }
+  }
+  return true;
+}
+var isTypeScriptProject = () => {
+  const paths = getPaths();
+  return import_node_fs4.default.existsSync(import_path2.default.join(paths.web.base, "tsconfig.json")) || import_node_fs4.default.existsSync(import_path2.default.join(paths.api.base, "tsconfig.json"));
+};
+
+// src/prisma.ts
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var import_node_worker_threads = require("node:worker_threads");
+
+// src/packageManager.ts
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var packageManagerCache;
+function getPackageManager() {
+  if (packageManagerCache) {
+    return packageManagerCache;
+  }
+  const base = getPaths().base;
+  packageManagerCache = "yarn";
+  const envPackageManager = process.env.npm_config_user_agent?.split(" ")[0]?.split("/")[0];
+  if (isPackageManager(envPackageManager)) {
+    packageManagerCache = envPackageManager;
+  } else if (import_node_fs5.default.existsSync(import_node_path2.default.join(base, "yarn.lock"))) {
+    packageManagerCache = "yarn";
+  } else if (import_node_fs5.default.existsSync(import_node_path2.default.join(base, "pnpm-lock.yaml"))) {
+    packageManagerCache = "pnpm";
+  } else if (import_node_fs5.default.existsSync(import_node_path2.default.join(base, "package-lock.json"))) {
+    packageManagerCache = "npm";
+  }
+  return packageManagerCache;
+}
+function isPackageManager(pm) {
+  return pm === "yarn" || pm === "npm" || pm === "pnpm";
+}
+function prettyPrintCedarCommand(args) {
+  const packageManager = getPackageManager();
+  const packageManagerBin = packageManager === "npm" ? "npx" : packageManager;
+  return `${packageManagerBin} cedar ${args.join(" ")}`;
+}
+
+// src/prisma.ts
+var configCache = /* @__PURE__ */ new Map();
+async function loadPrismaConfig(prismaConfigPath) {
+  if (!import_node_fs6.default.existsSync(prismaConfigPath)) {
+    throw new Error(`Prisma config file not found at: ${prismaConfigPath}`);
+  }
+  if (configCache.has(prismaConfigPath)) {
+    return configCache.get(prismaConfigPath);
+  }
+  const configUrl = (0, import_node_url.pathToFileURL)(prismaConfigPath).href;
+  let config;
+  try {
+    const mod = require(prismaConfigPath);
+    config = mod.default || mod;
+    if (!config) {
+      throw new Error("Prisma config must have a default export");
+    }
+    configCache.set(prismaConfigPath, config);
+  } catch (error) {
+    throw new Error(
+      `Failed to load Prisma config from ${prismaConfigPath}: ${error}`
+    );
+  }
+  return config;
+}
+async function getSchemaPath(prismaConfigPath) {
+  const config = await loadPrismaConfig(prismaConfigPath);
+  const configDir = import_node_path3.default.dirname(prismaConfigPath);
+  if (config.schema) {
+    return import_node_path3.default.isAbsolute(config.schema) ? config.schema : import_node_path3.default.resolve(configDir, config.schema);
+  }
+  return import_node_path3.default.join(configDir, "schema.prisma");
+}
+async function getPrismaSchemas() {
+  const mod = require("@prisma/internals");
+  const { createSchemaPathInput, getSchemaWithPath } = mod.default || mod;
+  const schemaPath = await getSchemaPath(getPaths().api.prismaConfig);
+  const schemaPathInput = createSchemaPathInput({
+    baseDir: import_node_fs6.default.lstatSync(schemaPath).isDirectory() ? schemaPath : import_node_path3.default.dirname(schemaPath),
+    schemaPathFromConfig: schemaPath
+  });
+  return getSchemaWithPath({ schemaPath: schemaPathInput });
+}
+async function getPrismaDatasourceProvider() {
+  const mod = await import("@prisma/internals");
+  const { getConfig: getConfig3 } = mod.default || mod;
+  const { schemas } = await getPrismaSchemas();
+  const config = await getConfig3({ datamodel: schemas });
+  return config.datasources[0].activeProvider;
+}
+async function getMigrationsPath(prismaConfigPath) {
+  const config = await loadPrismaConfig(prismaConfigPath);
+  const configDir = import_node_path3.default.dirname(prismaConfigPath);
+  if (config.migrations?.path) {
+    return import_node_path3.default.isAbsolute(config.migrations.path) ? config.migrations.path : import_node_path3.default.resolve(configDir, config.migrations.path);
+  }
+  const schemaPath = await getSchemaPath(prismaConfigPath);
+  const schemaDir = import_node_fs6.default.statSync(schemaPath).isDirectory() ? schemaPath : import_node_path3.default.dirname(schemaPath);
+  return import_node_path3.default.join(schemaDir, "migrations");
+}
+async function getDbDir(prismaConfigPath) {
+  const schemaPath = await getSchemaPath(prismaConfigPath);
+  if (import_node_fs6.default.existsSync(schemaPath) && import_node_fs6.default.statSync(schemaPath).isDirectory()) {
+    return schemaPath;
+  }
+  return import_node_path3.default.dirname(schemaPath);
+}
+async function getDataMigrationsPath(prismaConfigPath) {
+  const migrationsPath = await getMigrationsPath(prismaConfigPath);
+  const migrationsDir = import_node_path3.default.dirname(migrationsPath);
+  return import_node_path3.default.join(migrationsDir, "dataMigrations");
+}
+async function getPrismaClientOutputDirs() {
+  try {
+    const mod = await import("@prisma/internals");
+    const { getConfig: getConfig3 } = mod.default || mod;
+    const { schemas, schemaRootDir } = await getPrismaSchemas();
+    const config = await getConfig3({ datamodel: schemas });
+    return config.generators.filter(
+      (generator) => ["prisma-client", "prisma-client-js"].includes(
+        generator.provider.value ?? ""
+      )
+    ).map((generator) => generator.output?.value).filter((output) => Boolean(output)).map(
+      (output) => import_node_path3.default.isAbsolute(output) ? output : import_node_path3.default.resolve(schemaRootDir, output)
+    );
+  } catch {
+    return [];
+  }
+}
+async function getPrismaClientOutputDirsIsolated() {
+  const { prismaClientOutputDirsWorkerUrl: prismaClientOutputDirsWorkerUrl2 } = await Promise.resolve().then(() => (init_prismaClientOutputDirsWorkerUrl(), prismaClientOutputDirsWorkerUrl_exports));
+  return new Promise((resolve) => {
+    const worker = new import_node_worker_threads.Worker(prismaClientOutputDirsWorkerUrl2);
+    worker.once("message", (outputDirs) => {
+      resolve(
+        Array.isArray(outputDirs) ? outputDirs.filter((dir) => typeof dir === "string") : []
+      );
+      void worker.terminate();
+    });
+    worker.once("error", () => resolve([]));
+    worker.once("exit", () => resolve([]));
+  });
+}
+function createPrismaClientFileMatcher(resolveOutputDirs = getPrismaClientOutputDirsIsolated) {
+  let outputDirs;
+  const getOutputDirs = () => {
+    outputDirs ??= resolveOutputDirs();
+    return outputDirs;
+  };
+  return {
+    load: async () => {
+      await getOutputDirs();
+    },
+    matches: async (filePath) => {
+      return (await getOutputDirs()).some((dir) => {
+        const relativePath = import_node_path3.default.relative(dir, filePath);
+        return relativePath !== "" && !relativePath.startsWith("..") && !import_node_path3.default.isAbsolute(relativePath);
+      });
+    }
+  };
+}
+async function resolveGeneratedPrismaClient() {
+  let generatorOutputPath;
+  let ext = "ts";
+  try {
+    const prismaInternalsMod = require("@prisma/internals");
+    const { getConfig: getConfig3 } = prismaInternalsMod.default || prismaInternalsMod;
+    const { schemas, schemaRootDir } = await getPrismaSchemas();
+    const config = await getConfig3({ datamodel: schemas });
+    const generator = config.generators.find((entry) => entry.name === "client") ?? config.generators[0];
+    const output = generator?.output?.value;
+    const generatedFileExtension = generator?.config?.generatedFileExtension;
+    const resolvedExtension = Array.isArray(generatedFileExtension) ? generatedFileExtension[0] : generatedFileExtension;
+    if (typeof resolvedExtension === "string" && resolvedExtension.length > 0) {
+      ext = resolvedExtension;
+    }
+    if (output) {
+      generatorOutputPath = import_node_path3.default.isAbsolute(output) ? output : import_node_path3.default.resolve(schemaRootDir, output);
+    }
+  } catch {
+  }
+  const prismaClientEntry = typeof generatorOutputPath === "string" ? import_node_path3.default.join(generatorOutputPath, "client." + ext) : void 0;
+  if (!prismaClientEntry || !import_node_fs6.default.existsSync(prismaClientEntry)) {
+    const checked = prismaClientEntry ?? "(could not determine output path)";
+    const pmCommand = prettyPrintCedarCommand(["prisma", "generate"]);
+    return {
+      clientPath: prismaClientEntry,
+      error: `Could not find generated Prisma client entry. Checked: ${checked}. Run \`${pmCommand}\` and try again.`
+    };
+  }
+  return {
+    clientPath: prismaClientEntry,
+    error: void 0
+  };
+}
+
+// src/envVarDefinitions.ts
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function getEnvVarDefinitions() {
+  const rwConfig = (0, import_project_config.getConfig)();
+  const rwPaths = (0, import_project_config.getPaths)();
+  return {
+    RWJS_ENV: {
+      RWJS_API_GRAPHQL_URL: rwConfig.web.apiGraphQLUrl ?? rwConfig.web.apiUrl + "/graphql",
+      RWJS_API_URL: rwConfig.web.apiUrl,
+      __REDWOOD__APP_TITLE: rwConfig.web.title || import_node_path4.default.basename(rwPaths.base),
+      RWJS_EXP_STREAMING_SSR: rwConfig.experimental.streamingSsr?.enabled,
+      RWJS_EXP_RSC: rwConfig.experimental?.rsc?.enabled
+    },
+    RWJS_DEBUG_ENV: {
+      RWJS_SRC_ROOT: rwPaths.web.src,
+      REDWOOD_ENV_EDITOR: JSON.stringify(process.env.REDWOOD_ENV_EDITOR)
+    },
+    // Vite can automatically expose environment variables, but we
+    // disable that in `buildFeServer.ts` by setting `envFile: false`
+    // because we want to use our own logic for loading .env,
+    // .env.defaults, etc
+    // The two object spreads below will expose all environment
+    // variables listed in cedar.toml and all environment variables
+    // that are prefixed with REDWOOD_ENV_
+    ...Object.fromEntries(
+      rwConfig.web.includeEnvironmentVariables.flatMap((envName) => [
+        [`import.meta.env.${envName}`, JSON.stringify(process.env[envName])],
+        [`process.env.${envName}`, JSON.stringify(process.env[envName])]
+      ])
+    ),
+    ...Object.entries(process.env).reduce(
+      (acc, [key, value]) => {
+        if (key.startsWith("REDWOOD_ENV_")) {
+          acc[`import.meta.env.${key}`] = JSON.stringify(value);
+          acc[`process.env.${key}`] = JSON.stringify(value);
+        }
+        return acc;
+      },
+      {}
+    )
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CONFIG,
+  TargetEnum,
+  createPrismaClientFileMatcher,
+  ensurePosixPath,
+  findUp,
+  getAppRouteHook,
+  getBaseDir,
+  getBaseDirFromFile,
+  getBuiltDocumentFile,
+  getBuiltServerEntryFile,
+  getConfig,
+  getConfigPath,
+  getDataMigrationsPath,
+  getDbDir,
+  getEnvVarDefinitions,
+  getGeneratedDataDirPath,
+  getMigrationsPath,
+  getPaths,
+  getPrismaClientOutputDirs,
+  getPrismaClientOutputDirsIsolated,
+  getPrismaDatasourceProvider,
+  getPrismaSchemas,
+  getRawConfig,
+  getRouteHookForPage,
+  getSchemaPath,
+  importStatementPath,
+  isTypeScriptProject,
+  loadPrismaConfig,
+  parsePort,
+  processPagesDir,
+  projectIsEsm,
+  projectRootIsEsm,
+  projectSideIsEsm,
+  readEnvVar,
+  resolveFile,
+  resolveGeneratedPrismaClient
+});