@cedarjs/project-config 7.0.0-rc.128 → 7.0.1-next.305

package/dist/cjs/index.js

@@ -1,701 +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 __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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
-  TargetEnum: () => TargetEnum,
-  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,
-  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");
-
-// 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 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,
-  ensurePosixPath,
-  findUp,
-  getAppRouteHook,
-  getBaseDir,
-  getBaseDirFromFile,
-  getBuiltDocumentFile,
-  getBuiltServerEntryFile,
-  getConfig,
-  getConfigPath,
-  getDataMigrationsPath,
-  getDbDir,
-  getEnvVarDefinitions,
-  getGeneratedDataDirPath,
-  getMigrationsPath,
-  getPaths,
-  getPrismaDatasourceProvider,
-  getPrismaSchemas,
-  getRawConfig,
-  getRouteHookForPage,
-  getSchemaPath,
-  importStatementPath,
-  isTypeScriptProject,
-  loadPrismaConfig,
-  parsePort,
-  processPagesDir,
-  projectIsEsm,
-  projectRootIsEsm,
-  projectSideIsEsm,
-  readEnvVar,
-  resolveFile,
-  resolveGeneratedPrismaClient
-});

package/dist/cjs/package.json

@@ -1 +0,0 @@
-{"type":"commonjs"}