@cedarjs/internal 5.0.6 → 5.0.7-next.186

package/dist/build/directory-named-import.js

@@ -0,0 +1,26 @@
+import path from "node:path";
+import { importStatementPath, resolveFile } from "@cedarjs/project-config";
+const RELATIVE_IMPORT_RE = /^(\s*(?:import|export)\s[^'"]*?)(['"])(\.\.?\/[^'"]+)\2/gm;
+function applyDirectoryNamedImport(code, filePath) {
+  const fileDir = path.dirname(filePath);
+  return code.replace(
+    RELATIVE_IMPORT_RE,
+    (match, prefix, quote, importPath) => {
+      const absolutePath = path.join(fileDir, importPath);
+      if (resolveFile(absolutePath)) {
+        return match;
+      }
+      if (resolveFile(path.join(absolutePath, "index"))) {
+        return `${prefix}${quote}${importStatementPath(importPath + "/index")}${quote}`;
+      }
+      const basename = path.basename(absolutePath);
+      if (resolveFile(path.join(absolutePath, basename))) {
+        return `${prefix}${quote}${importStatementPath(importPath + "/" + basename)}${quote}`;
+      }
+      return match;
+    }
+  );
+}
+export {
+  applyDirectoryNamedImport
+};

package/dist/build/esbuild-plugin-api-graphql.d.ts

@@ -0,0 +1,6 @@
+import type { PluginBuild } from 'esbuild';
+export declare const cedarApiGraphqlPlugin: {
+    name: string;
+    setup(build: PluginBuild): void;
+};
+//# sourceMappingURL=esbuild-plugin-api-graphql.d.ts.map

package/dist/build/esbuild-plugin-api-graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-plugin-api-graphql.d.ts","sourceRoot":"","sources":["../../src/build/esbuild-plugin-api-graphql.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAsB1C,eAAO,MAAM,qBAAqB;;iBAEnB,WAAW;CAiHzB,CAAA"}

package/dist/build/esbuild-plugin-api-graphql.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  getApiSideBabelConfigPath,
+  getApiSideBabelPluginsForVite,
+  transformWithBabel
+} from "@cedarjs/babel-config";
+import { getConfig, getPaths, projectSideIsEsm } from "@cedarjs/project-config";
+import {
+  applyGqlormInject,
+  applyGraphqlOptionsExtract
+} from "./api-graphql-transforms.js";
+import { applyAutoImports } from "./auto-import.js";
+import { applyDirectoryNamedImport } from "./directory-named-import.js";
+import { applyOtelWrapping } from "./esbuild-plugin-cedar-otel-wrapping.js";
+import { applyHandlerAlsWrapping } from "./esbuild-plugin-handler-als-wrapping.js";
+import { applyEsmExtensions } from "./esm-extensions.js";
+import { applyImportDir } from "./import-dir.js";
+import { applySrcAlias } from "./src-alias.js";
+import { applyTsconfigPaths } from "./tsconfig-paths.js";
+const cedarApiGraphqlPlugin = {
+  name: "cedar-api-graphql",
+  setup(build) {
+    build.onLoad({ filter: /[/\\]graphql\.(ts|js)$/ }, async (args) => {
+      const cedarConfig = getConfig();
+      let fileContents = await fs.promises.readFile(args.path, "utf-8");
+      fileContents = applySrcAlias(
+        fileContents,
+        path.dirname(
+          path.relative(build.initialOptions.absWorkingDir + "/src", args.path)
+        )
+      );
+      fileContents = applyTsconfigPaths(
+        fileContents,
+        args.path,
+        getPaths().api.base
+      );
+      fileContents = applyDirectoryNamedImport(fileContents, args.path);
+      fileContents = applyGraphqlOptionsExtract(fileContents) ?? fileContents;
+      fileContents = applyGqlormInject(fileContents, args.path, ".js") ?? fileContents;
+      fileContents = applyAutoImports(fileContents);
+      fileContents = applyImportDir(fileContents, args.path)?.code ?? fileContents;
+      const apiBabelConfigPath = getApiSideBabelConfigPath();
+      let code = fileContents;
+      if (apiBabelConfigPath) {
+        const transformedCode = await transformWithBabel(
+          fileContents,
+          args.path,
+          getApiSideBabelPluginsForVite(),
+          "inline",
+          true
+        );
+        if (!transformedCode?.code) {
+          throw new Error(`Could not transform file: ${args.path}`);
+        }
+        code = transformedCode.code;
+      }
+      if (projectSideIsEsm("api")) {
+        code = applyEsmExtensions(code, args.path);
+      }
+      if (cedarConfig.experimental?.opentelemetry?.enabled && cedarConfig.experimental?.opentelemetry?.wrapApi) {
+        code = applyOtelWrapping(code, args.path, getPaths().api.src) ?? code;
+      }
+      code = applyHandlerAlsWrapping(code, {
+        projectIsEsm: projectSideIsEsm("api")
+      }) ?? code;
+      return {
+        contents: code,
+        // Babel output is always plain JS. Without Babel the contents are
+        // still TypeScript when the source file is graphql.ts, so pick the
+        // matching loader and let esbuild do the stripping. (The onLoad
+        // filter only matches .ts and .js files.)
+        loader: !apiBabelConfigPath && args.path.endsWith(".ts") ? "ts" : "js"
+      };
+    });
+  }
+};
+export {
+  cedarApiGraphqlPlugin
+};

package/dist/build/esbuild-plugin-cedar-otel-wrapping.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Standalone esbuild equivalent of the Vite cedarOtelWrappingPlugin. Applied
+ * inline in the esbuild API build and the standalone-Vite API build so neither
+ * path depends on a Babel OTel plugin.
+ *
+ * For each `export const fn = (async?) (...) => {...}` in an API file, this
+ * wraps it with an OpenTelemetry span.
+ *
+ * Keep this in sync with
+ * packages/vite/src/plugins/vite-plugin-cedar-otel-wrapping.ts.
+ */
+export declare function applyOtelWrapping(code: string, filename: string, apiSrc: string): string | null;
+//# sourceMappingURL=esbuild-plugin-cedar-otel-wrapping.d.ts.map

package/dist/build/esbuild-plugin-cedar-otel-wrapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-plugin-cedar-otel-wrapping.d.ts","sourceRoot":"","sources":["../../src/build/esbuild-plugin-cedar-otel-wrapping.ts"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AAEH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CAmFf"}

package/dist/build/esbuild-plugin-cedar-otel-wrapping.js

@@ -0,0 +1,180 @@
+import path from "node:path";
+import { parseSync } from "oxc-parser";
+function applyOtelWrapping(code, filename, apiSrc) {
+  const relative = path.relative(apiSrc, filename);
+  const apiFolder = relative.split(path.sep)[0] ?? "?";
+  const parseResult = parseSync(filename, code, { sourceType: "module" });
+  const replacements = [];
+  for (const node of parseResult.program.body) {
+    if (node.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    const decl = node.declaration;
+    if (decl?.type !== "VariableDeclaration") {
+      continue;
+    }
+    const declarator = decl.declarations[0];
+    if (!declarator) {
+      continue;
+    }
+    const fn = declarator.init;
+    if (fn?.type !== "ArrowFunctionExpression") {
+      continue;
+    }
+    if (declarator.id.type !== "Identifier") {
+      continue;
+    }
+    const fnName = declarator.id.name;
+    const innerArgs = buildInnerArgs(fn.params);
+    if (innerArgs === null) {
+      continue;
+    }
+    const fnHeader = code.slice(fn.start, fn.body.start);
+    const originalFnSrc = code.slice(fn.start, fn.end);
+    const isAsync = fn.async;
+    const awaitKw = isAsync ? "await " : "";
+    const asyncKw = isAsync ? "async " : "";
+    replacements.push({
+      start: node.start,
+      end: node.end,
+      src: buildWrappedExport(
+        fnName,
+        fnHeader,
+        originalFnSrc,
+        innerArgs,
+        awaitKw,
+        asyncKw,
+        apiFolder,
+        filename
+      )
+    });
+  }
+  if (replacements.length === 0) {
+    return null;
+  }
+  let output = code;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const r = replacements[i];
+    output = output.slice(0, r.start) + r.src + output.slice(r.end);
+  }
+  return `import { trace as OTEL_TRACE } from '@opentelemetry/api'
+` + output;
+}
+function buildInnerArgs(params) {
+  const args = [];
+  for (const param of params) {
+    if (param.type === "RestElement" || param.type === "ArrayPattern" || param.type === "TSParameterProperty") {
+      return null;
+    }
+    if (param.type === "Identifier") {
+      args.push(param.name);
+      continue;
+    }
+    if (param.type === "ObjectPattern") {
+      for (const prop of param.properties) {
+        if (prop.type === "RestElement") {
+          return null;
+        }
+        if (prop.key.type !== "Identifier") {
+          return null;
+        }
+        const value = prop.value;
+        if (value.type !== "Identifier" && value.type !== "AssignmentPattern" && value.type !== "ObjectPattern") {
+          return null;
+        }
+        if (value.type === "AssignmentPattern") {
+          if (value.left.type !== "Identifier" && value.left.type !== "ObjectPattern") {
+            return null;
+          }
+        }
+      }
+      const obj = buildObjectCallArg(param);
+      if (obj === null) {
+        return null;
+      }
+      args.push(obj);
+      continue;
+    }
+    if (param.type === "AssignmentPattern") {
+      const ap = param;
+      if (ap.left.type === "Identifier") {
+        args.push(ap.left.name);
+      } else if (ap.left.type === "ObjectPattern") {
+        const obj = buildObjectCallArg(ap.left);
+        if (obj === null) {
+          return null;
+        }
+        args.push(obj);
+      } else {
+        return null;
+      }
+      continue;
+    }
+    return null;
+  }
+  return args.join(", ");
+}
+function buildObjectCallArg(pattern) {
+  const keys = [];
+  for (const prop of pattern.properties) {
+    if (prop.type === "RestElement") {
+      return null;
+    }
+    if (prop.key.type !== "Identifier") {
+      return null;
+    }
+    const keyName = prop.key.name;
+    let valueName = null;
+    if (prop.value.type === "Identifier") {
+      valueName = prop.value.name;
+    } else if (prop.value.type === "AssignmentPattern") {
+      if (prop.value.left.type === "Identifier") {
+        valueName = prop.value.left.name;
+      } else {
+        return null;
+      }
+    } else {
+      return null;
+    }
+    if (valueName !== keyName) {
+      keys.push(`${keyName}: ${valueName}`);
+    } else {
+      keys.push(keyName);
+    }
+  }
+  return `{ ${keys.join(", ")} }`;
+}
+function buildWrappedExport(fnName, fnHeader, originalFnSrc, innerArgs, awaitKw, asyncKw, apiFolder, filename) {
+  const privateName = `__${fnName}`;
+  const spanName = `redwoodjs:api:${apiFolder}:${fnName}`;
+  return `export const ${fnName} = ${fnHeader}{
+  const ${privateName} = ${originalFnSrc}
+  const OTEL_TRACER = OTEL_TRACE.getTracer('redwoodjs')
+  const OTEL_RESULT = ${awaitKw}OTEL_TRACER.startActiveSpan(
+    '${spanName}',
+    ${asyncKw}(span) => {
+      span.setAttribute('code.function', '${fnName}')
+      span.setAttribute('code.filepath', ${JSON.stringify(filename)})
+      try {
+        const OTEL_INNER_RESULT = ${awaitKw}${privateName}(${innerArgs})
+        span.end()
+        return OTEL_INNER_RESULT
+      } catch (error) {
+        span.recordException(error)
+        span.setStatus({
+          code: 2,
+          message:
+            error?.message?.split('\\n')[0] ??
+            error?.toString()?.split('\\n')[0],
+        })
+        span.end()
+        throw error
+      }
+    }
+  )
+  return OTEL_RESULT
+}`;
+}
+export {
+  applyOtelWrapping
+};

package/dist/build/esbuild-plugin-handler-als-wrapping.d.ts

@@ -0,0 +1,4 @@
+export declare function applyHandlerAlsWrapping(code: string, { projectIsEsm }?: {
+    projectIsEsm?: boolean;
+}): string | null;
+//# sourceMappingURL=esbuild-plugin-handler-als-wrapping.d.ts.map

package/dist/build/esbuild-plugin-handler-als-wrapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-plugin-handler-als-wrapping.d.ts","sourceRoot":"","sources":["../../src/build/esbuild-plugin-handler-als-wrapping.ts"],"names":[],"mappings":"AAOA,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,EAAE,YAAoB,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACxD,MAAM,GAAG,IAAI,CA0Cf"}

package/dist/build/{esbuild-plugin-cedar-context-wrapping.js → esbuild-plugin-handler-als-wrapping.js}

@@ -1,4 +1,4 @@
-function applyContextWrapping(code, { projectIsEsm = false } = {}) {
+function applyHandlerAlsWrapping(code, { projectIsEsm = false } = {}) {
   const handlerRe = /^export\s+(?:const|let|var)\s+handler(?:[^=]|=>)*?=(?![>=])/m;
   const handlerMatch = handlerRe.exec(code);
   if (!handlerMatch) {
@@ -7,29 +7,29 @@ function applyContextWrapping(code, { projectIsEsm = false } = {}) {
   const afterEquals = code.slice(handlerMatch.index + handlerMatch[0].length).trimStart();
   const isAsync = /^async(?:\s*[\(\*]|\s+function)/.test(afterEquals);
   const storePath = projectIsEsm ? "@cedarjs/context/dist/store.js" : "@cedarjs/context/dist/store";
-  const importStatement = `import { getAsyncStoreInstance as __rw_getAsyncStoreInstance } from '${storePath}'
+  const importStatement = `import { getAsyncStoreInstance as __cedar_getAsyncStoreInstance } from '${storePath}'
 `;
   const handlerStart = handlerMatch.index;
   const before = code.slice(0, handlerStart);
   const after = code.slice(handlerStart);
-  const renamed = after.replace(handlerRe, "const __rw_handler =");
+  const renamed = after.replace(handlerRe, "const __cedar_handler =");
   const wrappedHandler = `
-export const handler = ${isAsync ? "async " : ""}(__rw_event, __rw__context) => {
+export const handler = ${isAsync ? "async " : ""}(__cedar_event, __cedar_context) => {
   // The store will be undefined if no context isolation has been performed yet
-  const __rw_contextStore = __rw_getAsyncStoreInstance().getStore()
-  if (__rw_contextStore === undefined) {
-    return __rw_getAsyncStoreInstance().run(
+  const __cedar_contextStore = __cedar_getAsyncStoreInstance().getStore()
+  if (__cedar_contextStore === undefined) {
+    return __cedar_getAsyncStoreInstance().run(
       new Map(),
-      __rw_handler,
-      __rw_event,
-      __rw__context
+      __cedar_handler,
+      __cedar_event,
+      __cedar_context
     )
   }
-  return __rw_handler(__rw_event, __rw__context)
+  return __cedar_handler(__cedar_event, __cedar_context)
 }
 `;
   return before + importStatement + renamed + wrappedHandler;
 }
 export {
-  applyContextWrapping
+  applyHandlerAlsWrapping
 };

package/dist/build/esm-extensions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * For ESM projects using esbuild with `bundle: false`, rewrites extensionless
+ * relative imports to include `.js` extension so that Node's ESM resolver can
+ * locate the compiled output files at runtime.
+ *
+ * Handles both static imports (`from '../lib/db'`) and dynamic imports
+ * (`import('../lib/db')`).
+ *
+ * Always outputs `.js` because esbuild with `loader: 'js'` compiles all source
+ * files (`.ts`, `.tsx`, `.jsx`) to `.js` output. For a source file `api/src/lib/db.ts`
+ * or `api/src/lib/db.tsx`, the output is always `api/dist/lib/db.js`, so all
+ * import specifiers must use `.js` at runtime.
+ *
+ * This replaces the `resolvePath` hook in `babel-plugin-module-resolver` for
+ * the standalone esbuild build path (`runCedarBabelTransformsPlugin`), which
+ * was previously responsible for this extension-appending behaviour.  Vite
+ * and Rollup resolve extensions themselves during bundling; only the esbuild
+ * `bundle: false` path needs explicit extension suffixes in the source.
+ *
+ * It is a plain function called inline — not an esbuild plugin — following
+ * the same pattern as `applySrcAlias`, `applyTsconfigPaths`, etc.
+ *
+ * Also handles Cedar SDL files whose names include a compound extension:
+ * `contacts.sdl.ts` compiles to `contacts.sdl.js`, so an import specifier
+ * `../graphql/contacts.sdl` (generated by applyImportDir's glob expansion)
+ * is rewritten to `../graphql/contacts.sdl.js`.
+ *
+ * Example: in `api/src/functions/graphql.ts` importing `../lib/db`, this
+ * rewrites it to `../lib/db.js` when `api/src/lib/db.ts` (or `db.tsx`)
+ * exists on disk.
+ */
+export declare function applyEsmExtensions(code: string, fromFile: string): string;
+//# sourceMappingURL=esm-extensions.d.ts.map

package/dist/build/esm-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esm-extensions.d.ts","sourceRoot":"","sources":["../../src/build/esm-extensions.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiEzE"}

package/dist/build/esm-extensions.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+function applyEsmExtensions(code, fromFile) {
+  const fromDir = path.dirname(fromFile);
+  const rewriteImportPath = (importPath, preservePrefix, preserveSuffix) => {
+    const existingExt = path.extname(importPath);
+    const absImport = path.join(fromDir, importPath);
+    if (existingExt && existingExt !== ".js" && existingExt !== ".jsx") {
+      if (fs.existsSync(absImport + ".ts") || fs.existsSync(absImport + ".js") || fs.existsSync(absImport + ".tsx") || fs.existsSync(absImport + ".jsx")) {
+        return preservePrefix + importPath + ".js" + preserveSuffix;
+      }
+      return preservePrefix + importPath + preserveSuffix;
+    }
+    const base = existingExt ? importPath.slice(0, -existingExt.length) : importPath;
+    const absBase = path.join(fromDir, base);
+    if (fs.existsSync(absBase + ".ts") || fs.existsSync(absBase + ".js") || fs.existsSync(absBase + ".tsx") || fs.existsSync(absBase + ".jsx")) {
+      return preservePrefix + base + ".js" + preserveSuffix;
+    }
+    return preservePrefix + importPath + preserveSuffix;
+  };
+  let result = code.replace(
+    /\bfrom\s+(['"])(\.\.?\/[^'"]+)\1/g,
+    (match, quote, importPath) => {
+      return `from ${rewriteImportPath(importPath, quote, quote)}`;
+    }
+  );
+  result = result.replace(
+    /\bimport\s*\(\s*(['"])(\.\.?\/[^'"]+)\1\s*\)/g,
+    (match, quote, importPath) => {
+      return `import(${rewriteImportPath(importPath, quote, quote)})`;
+    }
+  );
+  return result;
+}
+export {
+  applyEsmExtensions
+};

package/dist/build/import-dir.d.ts

@@ -0,0 +1,22 @@
+import type { SourceMap } from 'magic-string';
+/**
+ * Expands glob directory imports such as:
+ *   import services from 'src/services/**\/*.{js,ts}'
+ * into individual namespace imports:
+ *   let services = {}
+ *   import * as services_a from 'src/services/a'
+ *   services.a = services_a
+ *
+ * This is the esbuild-path equivalent of:
+ *   - babel-plugin-redwood-import-dir  (kept for Jest / console / data-migrate)
+ *   - cedarImportDirPlugin             (Vite plugin, for Vite build paths)
+ *
+ * Code duplication between the two non-Babel plugins is intentional.
+ *
+ * Returns the transformed source code, or null if no glob imports were found.
+ */
+export declare function applyImportDir(code: string, filePath: string): {
+    code: string;
+    map?: SourceMap;
+} | null;
+//# sourceMappingURL=import-dir.d.ts.map

package/dist/build/import-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-dir.d.ts","sourceRoot":"","sources":["../../src/build/import-dir.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAI7C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAyE1C"}

package/dist/build/import-dir.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import path from "node:path";
+import MagicString from "magic-string";
+import { getPaths, importStatementPath } from "@cedarjs/project-config";
+function applyImportDir(code, filePath) {
+  if (!code.includes("**")) {
+    return null;
+  }
+  const GLOB_IMPORT_RE = /^import\s+(\w+)\s+from\s+['"]([^'"]+)['"]\s*;?/gm;
+  const s = new MagicString(code);
+  let hasTransformations = false;
+  for (const match of code.matchAll(GLOB_IMPORT_RE)) {
+    const importName = match[1];
+    const sourceValue = match[2];
+    if (!sourceValue.includes("**")) {
+      continue;
+    }
+    const importGlob = importStatementPath(sourceValue);
+    const cwd = importGlob.startsWith("src/") ? getPaths().api.base : path.dirname(filePath);
+    let dirFiles;
+    try {
+      dirFiles = fs.globSync(importGlob, {
+        cwd,
+        exclude: (n) => n.includes(".test.") || n.includes(".scenarios.") || n.includes(".d.ts")
+      });
+    } catch {
+      continue;
+    }
+    const staticGlob = importGlob.split("*")[0];
+    const filePathToVarName = (fp) => fp.replace(staticGlob, "").replace(/\.(js|ts)$/, "").replace(/[^a-zA-Z0-9]/g, "_");
+    hasTransformations = true;
+    let replacement = `let ${importName} = {};
+`;
+    for (const fp of dirFiles) {
+      const { dir: fileDir, name: fileName } = path.parse(fp);
+      const normalizedDir = importStatementPath(fileDir);
+      const varName = filePathToVarName(fp);
+      const nsImport = `${importName}_${varName}`;
+      replacement += `import * as ${nsImport} from '${normalizedDir}/${fileName}';
+`;
+      replacement += `${importName}.${varName} = ${nsImport};
+`;
+    }
+    s.overwrite(
+      match.index,
+      match.index + match[0].length,
+      replacement.trimEnd()
+    );
+  }
+  return hasTransformations ? { code: s.toString(), map: s.generateMap({ hires: true }) } : null;
+}
+export {
+  applyImportDir
+};

package/dist/build/job-path-injector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Injects `path` and `name` properties into `createJob()` definitions so the
+ * jobs runner can locate and identify the job's module at runtime.
+ *
+ * Standalone equivalent of the Vite cedarjsJobPathInjectorPlugin (used by
+ * buildApp and apiDevMiddleware) and the Babel pluginRedwoodJobPathInjector
+ * override they replaced. Applied inline in the esbuild API build and the
+ * standalone-Vite API build so neither path depends on Babel for job path
+ * injection.
+ *
+ * Keep this in sync with
+ * packages/vite/src/plugins/vite-plugin-cedarjs-job-path-injector.ts.
+ */
+export declare function applyJobPathInjector(code: string, filePath: string, jobsDir: string): string | null;
+//# sourceMappingURL=job-path-injector.d.ts.map

package/dist/build/job-path-injector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-path-injector.d.ts","sourceRoot":"","sources":["../../src/build/job-path-injector.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CA8Ff"}

package/dist/build/job-path-injector.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { parseSync } from "oxc-parser";
+function applyJobPathInjector(code, filePath, jobsDir) {
+  if (!code.includes("createJob")) {
+    return null;
+  }
+  let program;
+  try {
+    program = parseSync(filePath, code, { sourceType: "module" }).program;
+  } catch (error) {
+    console.warn("Failed to parse file:", filePath);
+    console.warn(error);
+    return null;
+  }
+  const importPath = path.relative(jobsDir, filePath);
+  const importPathWithoutExtension = importPath.replace(/\.[^/.]+$/, "");
+  const insertions = [];
+  for (const node of program.body) {
+    if (node.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    const decl = node.declaration;
+    if (decl?.type !== "VariableDeclaration") {
+      continue;
+    }
+    for (const declarator of decl.declarations) {
+      if (declarator.id.type !== "Identifier") {
+        continue;
+      }
+      const init = declarator.init;
+      if (init?.type !== "CallExpression") {
+        continue;
+      }
+      const callee = init.callee;
+      if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier" || callee.property.name !== "createJob") {
+        continue;
+      }
+      const configArg = init.arguments[0];
+      if (configArg?.type !== "ObjectExpression") {
+        continue;
+      }
+      const pathProperty = `path: ${JSON.stringify(importPathWithoutExtension)}`;
+      const nameProperty = `name: ${JSON.stringify(declarator.id.name)}`;
+      const lastProperty = configArg.properties.at(-1);
+      if (lastProperty) {
+        insertions.push({
+          pos: lastProperty.end,
+          text: `, ${pathProperty}, ${nameProperty}`
+        });
+      } else {
+        insertions.push({
+          pos: configArg.start + 1,
+          text: `${pathProperty}, ${nameProperty}`
+        });
+      }
+    }
+  }
+  if (insertions.length === 0) {
+    return null;
+  }
+  let result = code;
+  for (const { pos, text } of insertions.sort((a, b) => b.pos - a.pos)) {
+    result = result.slice(0, pos) + text + result.slice(pos);
+  }
+  return result;
+}
+export {
+  applyJobPathInjector
+};

package/dist/build/src-alias.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Rewrites `src/` bare specifiers in source code to relative paths, so that the
+ * esbuild API build (with `bundle: false`) produces output files with
+ * resolvable import paths at runtime.
+ *
+ * This replaces the `babel-plugin-module-resolver` `src: './src'` alias for the
+ * esbuild build paths. It is a plain function called inline from the existing
+ * esbuild `onLoad` handlers — not an esbuild plugin itself.
+ *
+ * For a file at `api/src/functions/graphql.ts` importing `src/lib/db`, this
+ * rewrites it to `../lib/db`.
+ */
+export declare function applySrcAlias(code: string, fromDirRelativeToApiSrc: string): string;
+//# sourceMappingURL=src-alias.d.ts.map

package/dist/build/src-alias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"src-alias.d.ts","sourceRoot":"","sources":["../../src/build/src-alias.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,uBAAuB,EAAE,MAAM,GAC9B,MAAM,CAWR"}

package/dist/build/src-alias.js

@@ -0,0 +1,17 @@
+import path from "node:path";
+import { importStatementPath } from "@cedarjs/project-config";
+function applySrcAlias(code, fromDirRelativeToApiSrc) {
+  return code.replace(
+    /from\s+['"]src\/(.+?)['"]/g,
+    (_match, rest) => {
+      const target = path.relative(fromDirRelativeToApiSrc, rest);
+      const formatted = importStatementPath(
+        target.startsWith(".") ? target : "./" + target
+      );
+      return `from '${formatted}'`;
+    }
+  );
+}
+export {
+  applySrcAlias
+};

package/dist/build/tsconfig-paths.d.ts

@@ -0,0 +1,2 @@
+export declare function applyTsconfigPaths(code: string, filePath: string, cwd: string): string;
+//# sourceMappingURL=tsconfig-paths.d.ts.map

package/dist/build/tsconfig-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig-paths.d.ts","sourceRoot":"","sources":["../../src/build/tsconfig-paths.ts"],"names":[],"mappings":"AA8FA,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAyCR"}