@cedarjs/prerender 0.9.1-next.0 → 0.9.1-next.19

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-prerender-media-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-plugin-cedarjs-prerender-media-imports.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/rollup-plugin-cedarjs-prerender-media-imports.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AA6BpC,MAAM,WAAW,4BAA4B;IAC3C,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,GAAE,4BAAiC,GACzC,MAAM,CA0ER"}

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-prerender-media-imports.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import { extname, join, relative, dirname } from "node:path";
+import { ensurePosixPath, getPaths } from "@cedarjs/project-config";
+import { convertToDataUrl } from "./utils.js";
+const defaultExtensions = [
+  ".ico",
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".svg",
+  ".eot",
+  ".otf",
+  ".webp",
+  ".ttf",
+  ".woff",
+  ".woff2",
+  ".cur",
+  ".ani",
+  ".pdf",
+  ".bmp"
+];
+function cedarjsPrerenderMediaImportsPlugin(options = {}) {
+  const extensions = options.extensions || defaultExtensions;
+  let buildManifest = null;
+  return {
+    name: "cedarjs-prerender-media-imports",
+    buildStart() {
+      try {
+        const manifestPath = join(
+          getPaths().web.dist,
+          "client-build-manifest.json"
+        );
+        buildManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      } catch {
+        buildManifest = {};
+      }
+    },
+    resolveId(source, _importer) {
+      const ext = extname(source);
+      if (!ext || !extensions.includes(ext)) {
+        return null;
+      }
+      return {
+        id: source,
+        external: false
+      };
+    },
+    load(id) {
+      const ext = extname(id);
+      if (!ext || !extensions.includes(ext)) {
+        return null;
+      }
+      const importerModule = Array.from(this.getModuleIds()).find(
+        (moduleId) => {
+          const moduleInfo = this.getModuleInfo(moduleId);
+          return moduleInfo?.importedIds?.includes(id);
+        }
+      );
+      let absPath;
+      let viteManifestKey;
+      if (importerModule && importerModule !== "entry.js") {
+        const importerDir = dirname(importerModule);
+        absPath = join(importerDir, id);
+        viteManifestKey = ensurePosixPath(relative(getPaths().web.src, absPath));
+      } else {
+        const normalizedId = id.startsWith("./") ? id.slice(2) : id;
+        absPath = join(getPaths().web.src, normalizedId);
+        viteManifestKey = ensurePosixPath(normalizedId);
+      }
+      const copiedAssetPath = buildManifest?.[viteManifestKey]?.file;
+      let assetSrc;
+      if (copiedAssetPath) {
+        assetSrc = copiedAssetPath;
+      } else {
+        assetSrc = convertToDataUrl(absPath);
+      }
+      return `export default ${JSON.stringify(assetSrc)};`;
+    }
+  };
+}
+export {
+  cedarjsPrerenderMediaImportsPlugin
+};

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-routes-auto-loader.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'rollup';
+export interface PluginOptions {
+    forPrerender?: boolean;
+}
+export declare function cedarjsRoutesAutoLoaderPlugin(): Plugin;
+//# sourceMappingURL=rollup-plugin-cedarjs-routes-auto-loader.d.ts.map

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-routes-auto-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-plugin-cedarjs-routes-auto-loader.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/rollup-plugin-cedarjs-routes-auto-loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAYpC,MAAM,WAAW,aAAa;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAuBD,wBAAgB,6BAA6B,IAAI,MAAM,CAoJtD"}

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-routes-auto-loader.js

@@ -0,0 +1,117 @@
+import path from "path";
+import { createFilter } from "@rollup/pluginutils";
+import {
+  ensurePosixPath,
+  getPaths,
+  importStatementPath,
+  processPagesDir
+} from "@cedarjs/project-config";
+import { dedent } from "./utils.js";
+function getPathRelativeToSrc(maybeAbsolutePath) {
+  if (!path.isAbsolute(maybeAbsolutePath)) {
+    return maybeAbsolutePath;
+  }
+  return `./${path.relative(getPaths().web.src, maybeAbsolutePath)}`;
+}
+function withRelativeImports(page) {
+  return {
+    ...page,
+    relativeImport: ensurePosixPath(getPathRelativeToSrc(page.importPath))
+  };
+}
+function cedarjsRoutesAutoLoaderPlugin() {
+  let pages = processPagesDir().map(withRelativeImports);
+  const duplicatePageImportNames = /* @__PURE__ */ new Set();
+  const sortedPageImportNames = pages.map((page) => page.importName).sort();
+  for (let i = 0; i < sortedPageImportNames.length - 1; i++) {
+    if (sortedPageImportNames[i + 1] === sortedPageImportNames[i]) {
+      duplicatePageImportNames.add(sortedPageImportNames[i]);
+    }
+  }
+  if (duplicatePageImportNames.size > 0) {
+    const dirList = Array.from(duplicatePageImportNames).map((name) => `'${name}'`).join(", ");
+    throw new Error(
+      `Unable to find only a single file ending in 'Page.{js,jsx,ts,tsx}' in the following page directories: ${dirList}`
+    );
+  }
+  const filter = createFilter(["**/src/Routes.{tsx,jsx,js}"]);
+  return {
+    name: "cedarjs-routes-auto-loader",
+    buildStart() {
+      pages = processPagesDir().map(withRelativeImports);
+    },
+    transform(code, id) {
+      if (!filter(id)) {
+        return null;
+      }
+      let currentPages = [...pages];
+      const importRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+      let match;
+      const excludedPages = /* @__PURE__ */ new Set();
+      while ((match = importRegex.exec(code)) !== null) {
+        const [_fullMatch, defaultImportName, importPath] = match;
+        const importPathWithoutExtension = importPath.replace(
+          /\.(js|jsx|ts|tsx)$/,
+          ""
+        );
+        const normalizedPathBase = importPathWithoutExtension.replace(
+          /\/[^/]+$/,
+          ""
+        );
+        const normalizedPathFull = importPathWithoutExtension;
+        const userImportRelativePaths = [
+          getPathRelativeToSrc(importStatementPath(normalizedPathBase)),
+          getPathRelativeToSrc(importStatementPath(normalizedPathFull))
+        ];
+        const pageThatUserImported = currentPages.find((page) => {
+          const pageRelativeImport = page.relativeImport.replace(
+            /\.(js|jsx|ts|tsx)$/,
+            ""
+          );
+          const importNameMatches = page.importName === defaultImportName;
+          const pathMatches = userImportRelativePaths.some(
+            (path2) => pageRelativeImport === ensurePosixPath(path2) || pageRelativeImport.endsWith(`/${path2.split("/").pop()}`)
+          );
+          return importNameMatches || pathMatches;
+        });
+        if (pageThatUserImported) {
+          excludedPages.add(pageThatUserImported.importName);
+          currentPages = currentPages.filter(
+            (page) => page !== pageThatUserImported
+          );
+        }
+      }
+      if (currentPages.length === 0) {
+        return { code, map: null };
+      }
+      const imports = [];
+      const declarations = [];
+      imports.push(`import { lazy } from 'react'`);
+      for (const { importName, relativeImport } of currentPages) {
+        if (excludedPages.has(importName)) {
+          continue;
+        }
+        imports.push(
+          `import __cedarjs_prerender__${importName} from '${relativeImport}';`
+        );
+        const declaration = dedent(8)`const ${importName} = {
+          name: "${importName}",
+          prerenderLoader: (name) => ({ default: __cedarjs_prerender__${importName} }),
+          LazyComponent: lazy(() => import("${relativeImport}"))
+        }`;
+        declarations.push(declaration);
+      }
+      const autoLoaderCode = imports.join("\n") + "\n\n" + declarations.join("\n\n");
+      const finalCode = `${autoLoaderCode}
+
+${code}`;
+      return {
+        code: finalCode,
+        map: null
+      };
+    }
+  };
+}
+export {
+  cedarjsRoutesAutoLoaderPlugin
+};

package/dist/build-and-import/rollupPlugins/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function convertToDataUrl(assetPath: string): string;
+export declare function dedent(indentLevel: number): (strings: TemplateStringsArray, ...values: any[]) => string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/build-and-import/rollupPlugins/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/utils.ts"],"names":[],"mappings":"AASA,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,UASjD;AAED,wBAAgB,MAAM,CAAC,WAAW,EAAE,MAAM,aACvB,oBAAoB,aAAa,GAAG,EAAE,YAuCxD"}

package/dist/build-and-import/rollupPlugins/utils.js

@@ -0,0 +1,43 @@
+import fs from "fs";
+import mime from "mime-types";
+function convertToDataUrl(assetPath) {
+  try {
+    const base64AssetContents = fs.readFileSync(assetPath, "base64");
+    const mimeType = mime.lookup(assetPath);
+    return `data:${mimeType};base64,${base64AssetContents}`;
+  } catch {
+    console.warn(`Could not read file ${assetPath} for conversion to data uri`);
+    return "";
+  }
+}
+function dedent(indentLevel) {
+  return (strings, ...values) => {
+    let result = strings[0];
+    for (let i = 0; i < values.length; i++) {
+      result += values[i] + strings[i + 1];
+    }
+    const lines = result.split("\n");
+    while (lines.length > 0 && lines[0].trim() === "") {
+      lines.shift();
+    }
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+      lines.pop();
+    }
+    const minIndent = indentLevel;
+    const dedentedLines = lines.map((line) => {
+      if (line.trim() === "") {
+        return "";
+      }
+      const match = line.match(/^(\s*)/);
+      if (match && match[1].length >= minIndent) {
+        return line.slice(minIndent);
+      }
+      return line;
+    });
+    return dedentedLines.join("\n");
+  };
+}
+export {
+  convertToDataUrl,
+  dedent
+};

package/dist/build-and-import/utils.d.ts

@@ -0,0 +1,14 @@
+/** Match .mjs, .cts, .ts, .jsx etc */
+export declare const JS_EXT_RE: RegExp;
+export type RequireFunction = (outfile: string, ctx: {
+    format: 'cjs' | 'esm';
+}) => any;
+export declare function getPkgType(): any;
+export declare const getRandomId: () => string;
+export declare function isValidJsFile(filepath: string): boolean;
+/**
+ * Converts a file path to a URL path (file://...)
+ * Without this, absolute paths can't be imported on Windows
+ */
+export declare function makeFilePath(path: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/build-and-import/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/build-and-import/utils.ts"],"names":[],"mappings":"AAIA,sCAAsC;AACtC,eAAO,MAAM,SAAS,QAA2B,CAAA;AAEjD,MAAM,MAAM,eAAe,GAAG,CAC5B,OAAO,EAAE,MAAM,EACf,GAAG,EAAE;IAAE,MAAM,EAAE,KAAK,GAAG,KAAK,CAAA;CAAE,KAC3B,GAAG,CAAA;AAER,wBAAgB,UAAU,QAYzB;AAED,eAAO,MAAM,WAAW,cAEvB,CAAA;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,WAE7C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,UAExC"}

package/dist/build-and-import/utils.js

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const JS_EXT_RE = /\.([mc]?[tj]s|[tj]sx)$/;
+function getPkgType() {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.resolve("package.json"), "utf-8")
+    );
+    return pkg.type;
+  } catch {
+  }
+  return void 0;
+}
+const getRandomId = () => {
+  return Math.random().toString(36).substring(2, 15);
+};
+function isValidJsFile(filepath) {
+  return JS_EXT_RE.test(filepath);
+}
+function makeFilePath(path2) {
+  return pathToFileURL(path2).href;
+}
+export {
+  JS_EXT_RE,
+  getPkgType,
+  getRandomId,
+  isValidJsFile,
+  makeFilePath
+};

package/dist/detection/{index.d.ts → detection.d.ts}

@@ -8,4 +8,4 @@ export declare const detectPrerenderRoutes: () => {
     filePath: string | undefined;
     pageIdentifier: string | undefined;
 }[];
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=detection.d.ts.map

package/dist/detection/detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detection.d.ts","sourceRoot":"","sources":["../../src/detection/detection.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB;;;;;;;;;GAsBjC,CAAA"}

package/dist/detection/detection.js

@@ -0,0 +1,24 @@
+import { getPaths } from "@cedarjs/project-config";
+import { getProject } from "@cedarjs/structure";
+const detectPrerenderRoutes = () => {
+  const rwProject = getProject(getPaths().base);
+  const routes = rwProject.getRouter().routes;
+  const prerenderRoutes = routes.filter((route) => route.prerender).map((route) => ({
+    name: route.isNotFound ? "404" : route.name,
+    // `path` will be updated/expanded later where route parameters will be
+    // replaced with actual values
+    path: route.isNotFound ? "/404" : route.path,
+    // `routePath` is always the path specified on the <Route> component
+    // (or the special /404 path)
+    routePath: route.isNotFound ? "/404" : route.path,
+    hasParams: route.hasParameters,
+    id: route.id,
+    isNotFound: route.isNotFound,
+    filePath: route.page?.filePath,
+    pageIdentifier: route.page_identifier_str
+  }));
+  return prerenderRoutes;
+};
+export {
+  detectPrerenderRoutes
+};

package/dist/errors.js

@@ -1,29 +1,4 @@
-"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);
-var errors_exports = {};
-__export(errors_exports, {
-  GqlHandlerImportError: () => GqlHandlerImportError,
-  JSONParseError: () => JSONParseError,
-  PrerenderGqlError: () => PrerenderGqlError
-});
-module.exports = __toCommonJS(errors_exports);
-var import_graphql = require("graphql");
+import { print } from "graphql";
 class PrerenderGqlError extends Error {
   stack;
   constructor(message) {
@@ -40,13 +15,12 @@ class GqlHandlerImportError extends Error {
 }
 class JSONParseError extends Error {
   constructor({ query, variables, result }) {
-    const message = "Could not parse the GraphQL response.\n  Request: " + (0, import_graphql.print)(query).split("\n").join("\n  ") + "\n  Variables: " + JSON.stringify(variables) + "\n  Response: " + result;
+    const message = "Could not parse the GraphQL response.\n  Request: " + print(query).split("\n").join("\n  ") + "\n  Variables: " + JSON.stringify(variables) + "\n  Response: " + result;
     super(message);
   }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   GqlHandlerImportError,
   JSONParseError,
   PrerenderGqlError
-});
+};

package/dist/graphql/graphql.d.ts

@@ -1,19 +1,19 @@
 import type { DocumentNode } from 'graphql';
+import type { NodeRunner } from './node-runner.js';
 /**
  * Loads the graphql server, with all the user's settings
  * And execute the query against it
  *
  * Note that this function does NOT throw errors, even when
- * there is a GraphQL error. Instead, it returns the result with the graphql error.
- *
- * @returns {Promise<QueryResult>}
+ * there is a GraphQL error. Instead, it returns the result with the graphql
+ * error.
  */
-export declare function executeQuery(gqlHandler: (args: any) => Promise<any>, query: DocumentNode, variables?: Record<string, unknown>): Promise<any>;
+export declare function executeQuery(nodeRunner: NodeRunner, gqlHandler: (args: any) => Promise<any>, query: DocumentNode, variables?: Record<string, unknown>): Promise<any>;
 /**
  * Finds the graphql handler, returns a function
  * that can be used to execute queries against it
  *
  * Throws GqlHandlerImportError, so that we can warn the user (but not blow up)
  */
-export declare function getGqlHandler(): Promise<(operation: Record<string, unknown>) => Promise<any>>;
+export declare function getGqlHandler(nodeRunner: NodeRunner): Promise<(operation: Record<string, unknown>) => Promise<any>>;
 //# sourceMappingURL=graphql.d.ts.map

package/dist/graphql/graphql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/graphql/graphql.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAgB3C;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EACvC,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,gBAkCpC;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,wBAMN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mBAUnD"}
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/graphql/graphql.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAS3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AASlD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EACvC,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,gBAmCpC;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,UAAU,EAAE,UAAU,uBAM7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mBAUnD"}

package/dist/graphql/graphql.js

@@ -1,53 +1,19 @@
-"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);
-var graphql_exports = {};
-__export(graphql_exports, {
-  executeQuery: () => executeQuery,
-  getGqlHandler: () => getGqlHandler
-});
-module.exports = __toCommonJS(graphql_exports);
-var import_path = __toESM(require("path"));
-var import_graphql = require("graphql");
-var import_project_config = require("@cedarjs/project-config");
-var import_graphql2 = require("@cedarjs/web/dist/graphql.js");
-var import_errors = require("../errors");
-async function executeQuery(gqlHandler, query, variables) {
-  const config = (0, import_project_config.getConfig)();
-  const operationName = (0, import_graphql2.getOperationName)(query);
+import path from "path";
+import { print } from "graphql";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { getOperationName } from "@cedarjs/web/dist/graphql.js";
+import { GqlHandlerImportError } from "../errors.js";
+async function executeQuery(nodeRunner, gqlHandler, query, variables) {
+  const config = getConfig();
+  const operationName = getOperationName(query);
   const operation = {
     operationName,
-    query: (0, import_graphql.print)(query),
+    query: print(query),
     variables
   };
   if (config.graphql.trustedDocuments) {
-    const documentsPath = import_path.default.join((0, import_project_config.getPaths)().web.graphql, "graphql");
-    const documents = require(documentsPath);
+    const documentsPath = path.join(getPaths().web.graphql, "graphql");
+    const documents = await nodeRunner.importFile(documentsPath);
     const documentName = operationName[0].toUpperCase() + operationName.slice(1) + "Document";
     const queryHash = documents?.[documentName]?.__meta__?.hash;
     operation.query = void 0;
@@ -61,16 +27,16 @@ async function executeQuery(gqlHandler, query, variables) {
   const handlerResult = await gqlHandler(operation);
   return handlerResult?.body;
 }
-async function getGqlHandler() {
-  const gqlPath = import_path.default.join((0, import_project_config.getPaths)().api.functions, "graphql");
+async function getGqlHandler(nodeRunner) {
+  const gqlPath = path.join(getPaths().api.functions, "graphql");
   try {
-    const { handler } = require(gqlPath);
+    const { handler } = await nodeRunner.importFile(gqlPath);
     return async (operation) => {
       return await handler(buildApiEvent(operation), buildContext());
     };
   } catch {
     return () => {
-      throw new import_errors.GqlHandlerImportError(
+      throw new GqlHandlerImportError(
         `Unable to import GraphQL handler at ${gqlPath}`
       );
     };
@@ -145,8 +111,7 @@ function buildContext() {
     }
   };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   executeQuery,
   getGqlHandler
-});
+};

package/dist/graphql/node-runner.d.ts

@@ -0,0 +1,11 @@
+import type { UserConfig } from 'vite';
+export declare class NodeRunner {
+    private viteServer?;
+    private runner?;
+    private readonly customViteConfig;
+    constructor(customViteConfig?: UserConfig);
+    init(): Promise<void>;
+    importFile(filePath: string): Promise<any>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=node-runner.d.ts.map

package/dist/graphql/node-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-runner.d.ts","sourceRoot":"","sources":["../../src/graphql/node-runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiB,UAAU,EAAE,MAAM,MAAM,CAAA;AAsDrD,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAC,CAA2B;IAC9C,OAAO,CAAC,MAAM,CAAC,CAA4B;IAC3C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAY;gBAEjC,gBAAgB,GAAE,UAAe;IAIvC,IAAI;IA6BJ,UAAU,CAAC,QAAQ,EAAE,MAAM;IAQ3B,KAAK;CAGZ"}

package/dist/graphql/node-runner.js

@@ -0,0 +1,90 @@
+import { createServer, version as viteVersion, mergeConfig } from "vite";
+import { ViteNodeRunner } from "vite-node/client";
+import { ViteNodeServer } from "vite-node/server";
+import { installSourcemapsSupport } from "vite-node/source-map";
+import { getPaths } from "@cedarjs/project-config";
+import {
+  cedarCellTransform,
+  cedarjsDirectoryNamedImportPlugin,
+  cedarjsJobPathInjectorPlugin,
+  cedarSwapApolloProvider
+} from "@cedarjs/vite";
+import { cedarAutoImportsPlugin } from "./vite-plugin-cedar-auto-import.js";
+import { cedarImportDirPlugin } from "./vite-plugin-cedar-import-dir.js";
+async function createViteServer(customConfig = {}) {
+  const defaultConfig = {
+    mode: "production",
+    optimizeDeps: {
+      // This is recommended in the vite-node readme
+      noDiscovery: true,
+      include: void 0
+    },
+    resolve: {
+      alias: [
+        {
+          find: /^src\/(.*?)(\.([jt]sx?))?$/,
+          replacement: getPaths().api.src + "/$1"
+        }
+      ]
+    },
+    plugins: [
+      cedarImportDirPlugin(),
+      cedarAutoImportsPlugin(),
+      cedarjsDirectoryNamedImportPlugin(),
+      cedarCellTransform(),
+      cedarjsJobPathInjectorPlugin(),
+      cedarSwapApolloProvider()
+    ]
+  };
+  const mergedConfig = mergeConfig(defaultConfig, customConfig);
+  const server = await createServer(mergedConfig);
+  if (Number(viteVersion.split(".")[0]) < 6) {
+    await server.pluginContainer.buildStart({});
+  }
+  return server;
+}
+class NodeRunner {
+  viteServer = void 0;
+  runner = void 0;
+  customViteConfig;
+  constructor(customViteConfig = {}) {
+    this.customViteConfig = customViteConfig;
+  }
+  async init() {
+    this.viteServer = await createViteServer(this.customViteConfig);
+    const nodeServer = new ViteNodeServer(this.viteServer, {
+      transformMode: {
+        ssr: [/.*/],
+        web: [/\/web\//]
+      },
+      deps: {
+        fallbackCJS: true
+      }
+    });
+    installSourcemapsSupport({
+      getSourceMap: (source) => nodeServer?.getSourceMap(source)
+    });
+    this.runner = new ViteNodeRunner({
+      root: this.viteServer.config.root,
+      base: this.viteServer.config.base,
+      fetchModule(id) {
+        return nodeServer.fetchModule(id);
+      },
+      resolveId(id, importer) {
+        return nodeServer.resolveId(id, importer);
+      }
+    });
+  }
+  async importFile(filePath) {
+    if (!this.runner) {
+      await this.init();
+    }
+    return this.runner?.executeFile(filePath);
+  }
+  async close() {
+    await this.viteServer?.close();
+  }
+}
+export {
+  NodeRunner
+};

package/dist/graphql/vite-plugin-cedar-auto-import.d.ts

@@ -0,0 +1,2 @@
+export declare function cedarAutoImportsPlugin(): any[];
+//# sourceMappingURL=vite-plugin-cedar-auto-import.d.ts.map

package/dist/graphql/vite-plugin-cedar-auto-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-cedar-auto-import.d.ts","sourceRoot":"","sources":["../../src/graphql/vite-plugin-cedar-auto-import.ts"],"names":[],"mappings":"AAWA,wBAAgB,sBAAsB,UA2ErC"}