@cedarjs/internal 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/ast.d.ts

@@ -17,6 +17,7 @@ export declare const getNamedExports: (ast: types.Node) => NamedExports[];
  */
 export declare const getGqlQueries: (ast: types.Node) => string[];
 export declare const getCellGqlQuery: (ast: types.Node) => undefined;
+export declare const getCellGqlFragment: (ast: types.Node) => undefined;
 export declare const hasDefaultExport: (ast: types.Node) => boolean;
 export declare const getDefaultExportLocation: (ast: types.Node) => {
     line: number;

package/dist/ast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAmBnC,eAAO,MAAM,SAAS,GAAI,UAAU,MAAM,KAAG,KAAK,CAAC,IAyBlD,CAAA;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAA;IACrD,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AACD;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,KAAK,CAAC,IAAI,KAAG,YAAY,EA4D7D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,KAAK,CAAC,IAAI,aAY5C,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,KAAK,KAAK,CAAC,IAAI,cA8B9C,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,KAAK,KAAK,CAAC,IAAI,KAAG,OASlD,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,KAAK,KAAK,CAAC,IAAI,KACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IA0CrC,CAAA"}
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAYnC,eAAO,MAAM,SAAS,GAAI,UAAU,MAAM,KAAG,KAAK,CAAC,IAyBlD,CAAA;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,CAAA;IACrD,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AACD;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,KAAK,CAAC,IAAI,KAAG,YAAY,EA4D7D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,KAAK,CAAC,IAAI,aAY5C,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,KAAK,KAAK,CAAC,IAAI,cA8B9C,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,KAAK,KAAK,CAAC,IAAI,cA8BjD,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,KAAK,KAAK,CAAC,IAAI,KAAG,OASlD,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,KAAK,KAAK,CAAC,IAAI,KACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IA0CrC,CAAA"}

package/dist/ast.js

@@ -115,6 +115,26 @@ const getCellGqlQuery = (ast) => {
   });
   return cellQuery;
 };
+const getCellGqlFragment = (ast) => {
+  let cellFragment = void 0;
+  traverse(ast, {
+    ExportNamedDeclaration({ node }) {
+      if (node.exportKind === "value" && types.isVariableDeclaration(node.declaration)) {
+        const exportedFragmentNode = node.declaration.declarations.find(
+          (d) => {
+            return types.isIdentifier(d.id) && d.id.name === "FRAGMENT" && types.isTaggedTemplateExpression(d.init);
+          }
+        );
+        if (exportedFragmentNode) {
+          const templateExpression = exportedFragmentNode.init;
+          cellFragment = templateExpression.quasi.quasis[0].value.raw;
+        }
+      }
+      return;
+    }
+  });
+  return cellFragment;
+};
 const hasDefaultExport = (ast) => {
   let exported = false;
   traverse(ast, {
@@ -154,6 +174,7 @@ const getDefaultExportLocation = (ast) => {
 };
 export {
   fileToAst,
+  getCellGqlFragment,
   getCellGqlQuery,
   getDefaultExportLocation,
   getGqlQueries,

package/dist/build/api-graphql-transforms.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Extracts the options argument from createGraphQLHandler calls and stores
+ * them in an exported variable. Returns the transformed code, or null if no
+ * transformation was needed.
+ *
+ * Transforms:
+ *   export const handler = createGraphQLHandler({ options })
+ * into:
+ *   export const __cedar_graphqlOptions = { options }
+ *   export const handler = createGraphQLHandler(__cedar_graphqlOptions)
+ */
+export declare function applyGraphqlOptionsExtract(code: string): string | null;
+/**
+ * Injects the auto-generated gqlorm backend into graphql.ts at build time.
+ *
+ * When `experimental.gqlorm.enabled = true` and `.cedar/gqlorm/backend.ts`
+ * exists, this function:
+ *
+ * 1. Adds imports at the top of graphql.ts:
+ *      import * as __gqlorm_sdl__ from '../../../.cedar/gqlorm/backend'
+ *      import { db as __gqlorm_db__ } from 'src/lib/db'
+ *
+ * 2. Inserts a statement immediately before the `createGraphQLHandler` call:
+ *      Object.assign(sdls, {
+ *        __gqlorm__: {
+ *          schema: __gqlorm_sdl__.schema,
+ *          resolvers: __gqlorm_sdl__.createGqlormResolvers(__gqlorm_db__),
+ *        },
+ *      })
+ *
+ * Returns the transformed code, or null if no transformation was needed.
+ */
+export declare function applyGqlormInject(code: string, id: string, dbExt?: '.ts' | '.js'): string | null;
+//# sourceMappingURL=api-graphql-transforms.d.ts.map

package/dist/build/api-graphql-transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-graphql-transforms.d.ts","sourceRoot":"","sources":["../../src/build/api-graphql-transforms.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA8GtE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,KAAK,GAAE,KAAK,GAAG,KAAa,GAC3B,MAAM,GAAG,IAAI,CAmFf"}

package/dist/build/api-graphql-transforms.js

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseSync, Visitor } from "oxc-parser";
+import {
+  getConfig,
+  getPaths,
+  importStatementPath
+} from "@cedarjs/project-config";
+const GRAPHQL_OPTIONS_ERROR_PREFIX = "Could not read the GraphQL options in api/src/functions/graphql. Cedar needs to statically extract them so the api server can serve /graphql and its health endpoint. ";
+const GRAPHQL_OPTIONS_ERROR_SUFFIX = " Expected a single `createGraphQLHandler({ ... })` call with the options passed directly as an object, an identifier, a call, or a ternary.";
+function applyGraphqlOptionsExtract(code) {
+  if (code.includes("__cedar_graphqlOptions")) {
+    return null;
+  }
+  const { program } = parseSync("graphql.ts", code, {
+    // lang is only a parse hint; 'ts' also parses JS (the graphql handler can
+    // be graphql.js in JS projects), so this is safe for both file types.
+    lang: "ts",
+    sourceType: "module"
+  });
+  const importNames = /* @__PURE__ */ new Set();
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration") {
+      if (node.source.value !== "@cedarjs/graphql-server") {
+        continue;
+      }
+      for (const specifier of node.specifiers) {
+        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "createGraphQLHandler") {
+          importNames.add(specifier.local.name);
+        }
+      }
+    }
+  }
+  if (importNames.size === 0) {
+    return null;
+  }
+  const callExpressionPaths = [];
+  new Visitor({
+    CallExpression(node) {
+      if (node.callee.type === "Identifier" && importNames.has(node.callee.name)) {
+        callExpressionPaths.push(node);
+      }
+    }
+  }).visit(program);
+  if (callExpressionPaths.length > 1) {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + "Found more than one call to createGraphQLHandler." + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  const callExpression = callExpressionPaths[0];
+  if (!callExpression) {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + "createGraphQLHandler is imported but never called." + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  const options = callExpression.arguments[0];
+  if (!options) {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + "createGraphQLHandler was called without any options." + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  if (options.type !== "Identifier" && options.type !== "ObjectExpression" && options.type !== "CallExpression" && options.type !== "ConditionalExpression") {
+    throw new Error(
+      GRAPHQL_OPTIONS_ERROR_PREFIX + `The options argument is a ${options.type}, which can't be read statically.` + GRAPHQL_OPTIONS_ERROR_SUFFIX
+    );
+  }
+  const optionsStart = options.start;
+  const optionsEnd = options.end;
+  const lineStart = code.lastIndexOf("\n", callExpression.start) + 1;
+  const indentMatch = /^[ \t]*/.exec(code.slice(lineStart));
+  const indent = indentMatch ? indentMatch[0] : "";
+  const optionsConst = `${indent}export const __cedar_graphqlOptions = ${code.slice(
+    optionsStart,
+    optionsEnd
+  )}
+`;
+  const before = code.slice(0, lineStart);
+  const between = code.slice(lineStart, optionsStart);
+  const after = code.slice(optionsEnd);
+  return before + optionsConst + between + "__cedar_graphqlOptions" + after;
+}
+function applyGqlormInject(code, id, dbExt = ".ts") {
+  if (code.includes("__gqlorm_sdl__")) {
+    return null;
+  }
+  if (!code.includes("createGraphQLHandler")) {
+    return null;
+  }
+  if (!getConfig().experimental?.gqlorm?.enabled) {
+    return null;
+  }
+  const backendPathWithoutExt = path.join(
+    getPaths().generated.base,
+    "gqlorm",
+    "backend"
+  );
+  if (!fs.existsSync(backendPathWithoutExt + ".ts")) {
+    return null;
+  }
+  const handlerPattern = /^export\s+const\s+(\w+)\s*=\s*createGraphQLHandler\s*\(/m;
+  const handlerMatch = handlerPattern.exec(code);
+  if (!handlerMatch) {
+    return null;
+  }
+  const handlerLineStart = code.lastIndexOf("\n", handlerMatch.index) + 1;
+  const relPath = importStatementPath(
+    path.relative(path.dirname(id), backendPathWithoutExt)
+  ) + ".ts";
+  const dbSrcPath = path.join(getPaths().api.src, "lib", "db");
+  const relDbPath = importStatementPath(path.relative(path.dirname(id), dbSrcPath)) + dbExt;
+  const importDb = `import { db as __gqlorm_db__ } from '${relDbPath}'`;
+  const importSdl = `import * as __gqlorm_sdl__ from '${relPath}'`;
+  const importsToAdd = `${importDb}
+${importSdl}
+`;
+  const sdlsMutation = `Object.assign(sdls, {
+    __gqlorm__: {
+      schema: __gqlorm_sdl__.schema,
+      resolvers: __gqlorm_sdl__.createGqlormResolvers(__gqlorm_db__),
+    },
+  })
+  `;
+  const transformed = importsToAdd + code.slice(0, handlerLineStart) + sdlsMutation + code.slice(handlerLineStart);
+  return transformed;
+}
+export {
+  applyGqlormInject,
+  applyGraphqlOptionsExtract
+};

package/dist/build/api.d.ts

@@ -1,6 +1,9 @@
 import type { BuildOptions } from 'esbuild';
+export { applySrcAlias } from './src-alias.js';
+export { applyImportExtensions } from './import-extensions.js';
 export declare const buildApi: () => Promise<import("esbuild").BuildResult<BuildOptions>>;
 export declare const rebuildApi: () => Promise<import("esbuild").BuildResult<BuildOptions>>;
 export declare const cleanApiBuild: () => Promise<void>;
-export declare const transpileApi: (files: string[]) => Promise<import("esbuild").BuildResult<BuildOptions>>;
+export declare const buildApiWithVite: () => Promise<import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher>;
+export declare function fixSourceMaps(distDir: string, srcDir: string): Promise<void>;
 //# sourceMappingURL=api.d.ts.map

package/dist/build/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/build/api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAgB,YAAY,EAAe,MAAM,SAAS,CAAA;AAatE,eAAO,MAAM,QAAQ,4DAOpB,CAAA;AAED,eAAO,MAAM,UAAU,4DAQtB,CAAA;AAED,eAAO,MAAM,aAAa,qBAGzB,CAAA;AAiCD,eAAO,MAAM,YAAY,GAAU,OAAO,MAAM,EAAE,yDAEjD,CAAA"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/build/api.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,YAAY,EAAe,MAAM,SAAS,CAAA;AAwCtE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAI9D,eAAO,MAAM,QAAQ,4DAIpB,CAAA;AAED,eAAO,MAAM,UAAU,4DAStB,CAAA;AAED,eAAO,MAAM,aAAa,qBAGzB,CAAA;AA8UD,eAAO,MAAM,gBAAgB,iHA+D5B,CAAA;AAcD,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAoDf"}

package/dist/build/api.js

@@ -1,11 +1,37 @@
 import fs from "node:fs";
+import path from "node:path";
 import { build, context } from "esbuild";
+import MagicString from "magic-string";
+import { build as viteBuild, normalizePath } from "vite";
+import tsPathsMod from "vite-tsconfig-paths";
+const tsconfigPaths = (
+  // @ts-expect-error – .default only exists at runtime in CJS double-wrap
+  // interop
+  tsPathsMod.default?.default || tsPathsMod.default || tsPathsMod
+);
 import {
-  getApiSideBabelPlugins,
+  getApiSideBabelConfigPath,
+  getApiSideBabelPluginsForVite,
   transformWithBabel
 } from "@cedarjs/babel-config";
-import { getConfig, getPaths, projectSideIsEsm } from "@cedarjs/project-config";
+import { getConfig, getPaths, resolveFile } from "@cedarjs/project-config";
 import { findApiFiles } from "../files.js";
+import {
+  applyGqlormInject,
+  applyGraphqlOptionsExtract
+} from "./api-graphql-transforms.js";
+import { applyAutoImports } from "./auto-import.js";
+import { applyDirectoryNamedImport } from "./directory-named-import.js";
+import { cedarApiGraphqlPlugin } from "./esbuild-plugin-api-graphql.js";
+import { applyOtelWrapping } from "./esbuild-plugin-cedar-otel-wrapping.js";
+import { applyHandlerAlsWrapping } from "./esbuild-plugin-handler-als-wrapping.js";
+import { applyImportDir } from "./import-dir.js";
+import { applyImportExtensions } from "./import-extensions.js";
+import { applyJobPathInjector } from "./job-path-injector.js";
+import { applySrcAlias } from "./src-alias.js";
+import { applyTsconfigPaths } from "./tsconfig-paths.js";
+import { applySrcAlias as applySrcAlias2 } from "./src-alias.js";
+import { applyImportExtensions as applyImportExtensions2 } from "./import-extensions.js";
 let BUILD_CTX = null;
 const buildApi = async () => {
   BUILD_CTX?.dispose();
@@ -17,7 +43,10 @@ const rebuildApi = async () => {
   if (!BUILD_CTX) {
     BUILD_CTX = await context(getEsbuildOptions(apiFiles));
   }
-  return BUILD_CTX.rebuild();
+  const result = await BUILD_CTX.rebuild();
+  const cedarPaths = getPaths();
+  await fixSourceMaps(cedarPaths.api.dist, cedarPaths.api.src);
+  return result;
 };
 const cleanApiBuild = async () => {
   const cedarPaths = getPaths();
@@ -26,40 +55,294 @@ const cleanApiBuild = async () => {
 const runCedarBabelTransformsPlugin = {
   name: "cedar-esbuild-babel-transform",
   setup(build2) {
-    const cedarConfig = getConfig();
     build2.onLoad({ filter: /\.(js|ts|tsx|jsx)$/ }, async (args) => {
-      const transformedCode = await transformWithBabel(
+      let fileContents = await fs.promises.readFile(args.path, "utf-8");
+      fileContents = applySrcAlias(
+        fileContents,
+        path.dirname(
+          path.relative(build2.initialOptions.absWorkingDir + "/src", args.path)
+        )
+      );
+      fileContents = applyTsconfigPaths(
+        fileContents,
         args.path,
-        getApiSideBabelPlugins({
-          openTelemetry: cedarConfig.experimental.opentelemetry.enabled && cedarConfig.experimental.opentelemetry.wrapApi,
-          projectIsEsm: projectSideIsEsm("api")
-        })
+        getPaths().api.base
       );
-      if (transformedCode?.code) {
+      fileContents = applyDirectoryNamedImport(fileContents, args.path);
+      fileContents = applyAutoImports(fileContents);
+      fileContents = applyImportDir(fileContents, args.path)?.code ?? fileContents;
+      fileContents = applyJobPathInjector(fileContents, args.path, getPaths().api.jobs) ?? fileContents;
+      const normalizedPath = normalizePath(args.path);
+      const cedarPaths = getPaths();
+      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;
+      }
+      code = applyImportExtensions(code, args.path);
+      const functionsDir = normalizePath(cedarPaths.api.functions);
+      if (normalizedPath.startsWith(functionsDir + "/")) {
+        code = applyHandlerAlsWrapping(code) ?? code;
+      }
+      if (normalizedPath.startsWith(normalizePath(cedarPaths.api.src) + "/")) {
+        code = applyOtelWrapping(code, args.path, cedarPaths.api.src) ?? code;
+      }
+      return {
+        contents: code,
+        // Babel output is always plain JS. Without Babel the contents are
+        // still TypeScript/JSX, so pick the loader matching the file's
+        // extension and let esbuild do the stripping.
+        loader: apiBabelConfigPath ? "js" : getEsbuildLoader(args.path)
+      };
+    });
+  }
+};
+function getEsbuildLoader(filePath) {
+  switch (path.extname(filePath)) {
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    default:
+      return "js";
+  }
+}
+function createImportDirVitePlugin() {
+  return {
+    name: "cedar-internal-import-dir",
+    enforce: "pre",
+    transform(code, id) {
+      if (!/\.(js|ts|tsx|jsx)$/.test(id)) {
+        return null;
+      }
+      if (id.includes("node_modules")) {
+        return null;
+      }
+      const result = applyImportDir(code, id);
+      if (!result) {
+        return null;
+      }
+      return { code: result.code, map: result.map };
+    }
+  };
+}
+function createDirectoryNamedImportVitePlugin() {
+  return {
+    name: "cedar-internal-directory-named-import",
+    enforce: "pre",
+    resolveId(id, importer) {
+      if (!id.startsWith(".") || !importer) {
+        return null;
+      }
+      if (importer.includes("node_modules")) {
+        return null;
+      }
+      const absolutePath = path.resolve(path.dirname(importer), id);
+      if (resolveFile(absolutePath)) {
+        return null;
+      }
+      const indexPath = path.join(absolutePath, "index");
+      const resolvedIndex = resolveFile(indexPath);
+      if (resolvedIndex) {
+        return normalizePath(resolvedIndex);
+      }
+      const basename = path.basename(absolutePath);
+      const dirNamedPath = path.join(absolutePath, basename);
+      const resolvedDirNamed = resolveFile(dirNamedPath);
+      if (resolvedDirNamed) {
+        return normalizePath(resolvedDirNamed);
+      }
+      return null;
+    }
+  };
+}
+function createCedarViteApiPlugin() {
+  const cedarConfig = getConfig();
+  return {
+    name: "cedar-vite-api-babel-transform",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!/\.(js|ts|tsx|jsx)$/.test(id)) {
+        return null;
+      }
+      if (id.includes("node_modules")) {
+        return null;
+      }
+      const cedarPaths = getPaths();
+      if (!normalizePath(id).startsWith(normalizePath(cedarPaths.api.base))) {
+        return null;
+      }
+      let sourceCode = code;
+      const normalizedId = normalizePath(id);
+      sourceCode = applySrcAlias(
+        sourceCode,
+        path.dirname(path.relative(cedarPaths.api.src, id))
+      );
+      sourceCode = applyAutoImports(sourceCode);
+      sourceCode = applyJobPathInjector(sourceCode, id, cedarPaths.api.jobs) ?? sourceCode;
+      if (normalizedId.endsWith("/graphql.ts") || normalizedId.endsWith("/graphql.js")) {
+        sourceCode = applyGraphqlOptionsExtract(sourceCode) ?? sourceCode;
+        sourceCode = applyGqlormInject(sourceCode, id) ?? sourceCode;
+      }
+      const apiBabelConfigPath = getApiSideBabelConfigPath();
+      const transformedCode = apiBabelConfigPath ? await transformWithBabel(
+        sourceCode,
+        id,
+        getApiSideBabelPluginsForVite(),
+        true,
+        true
+      ) : null;
+      if (apiBabelConfigPath && !transformedCode?.code) {
+        throw new Error(`Could not transform file: ${id}`);
+      }
+      let outputCode = transformedCode?.code ?? sourceCode;
+      if (cedarConfig.experimental?.opentelemetry?.enabled && cedarConfig.experimental?.opentelemetry?.wrapApi) {
+        outputCode = applyOtelWrapping(outputCode, id, cedarPaths.api.src) ?? outputCode;
+      }
+      outputCode = applyImportExtensions(outputCode, id);
+      const functionsDir = normalizePath(cedarPaths.api.functions);
+      if (normalizedId.startsWith(functionsDir + "/")) {
+        outputCode = applyHandlerAlsWrapping(outputCode) ?? outputCode;
+      }
+      if (!transformedCode) {
+        if (outputCode === code) {
+          return null;
+        }
         return {
-          contents: transformedCode.code,
-          loader: "js"
+          code: outputCode,
+          map: new MagicString(code).generateMap({ hires: true })
         };
       }
-      throw new Error(`Could not transform file: ${args.path}`);
-    });
+      return {
+        code: outputCode,
+        map: transformedCode.map ?? null
+      };
+    }
+  };
+}
+const buildApiWithVite = async () => {
+  const cedarPaths = getPaths();
+  const apiFiles = findApiFiles();
+  const input = {};
+  for (const f of apiFiles) {
+    const key = path.relative(cedarPaths.api.src, f).replace(/\.(ts|tsx|mts|js|jsx|mjs)$/, "");
+    input[key] = f;
   }
+  return viteBuild({
+    root: cedarPaths.api.base,
+    logLevel: "warn",
+    build: {
+      ssr: true,
+      sourcemap: true,
+      outDir: cedarPaths.api.dist,
+      rollupOptions: {
+        input,
+        output: {
+          format: "es",
+          preserveModules: true,
+          preserveModulesRoot: cedarPaths.api.src,
+          entryFileNames: "[name].js",
+          // Directives (and other entry modules) intentionally use both named
+          // and default exports (e.g. `export const schema` + `export default`).
+          // Tell Rollup to expect this so it doesn't warn about mixed exports.
+          exports: "named"
+        },
+        external: (id) => {
+          if (id.startsWith("node:")) {
+            return true;
+          }
+          if (!id.startsWith(".") && !path.isAbsolute(id)) {
+            return true;
+          }
+          return false;
+        }
+      }
+    },
+    // cedarImportDirPlugin must run before the Babel transform so glob imports
+    // are expanded before Babel sees the code.  The Babel import-dir plugin is
+    // not part of getApiSideBabelPluginsForVite(); this inline Vite plugin is
+    // its replacement for this code path (both CJS and ESM output via Rollup).
+    // tsconfigPaths resolves user-defined tsconfig.json `paths` aliases; it
+    // replaces the Babel module-resolver's tsconfig-paths handling for this
+    // code path.
+    plugins: [
+      tsconfigPaths(),
+      createImportDirVitePlugin(),
+      createDirectoryNamedImportVitePlugin(),
+      createCedarViteApiPlugin()
+    ]
+  });
 };
 const transpileApi = async (files) => {
-  return build(getEsbuildOptions(files));
+  const result = await build(getEsbuildOptions(files));
+  const cedarPaths = getPaths();
+  await fixSourceMaps(cedarPaths.api.dist, cedarPaths.api.src);
+  return result;
 };
+async function fixSourceMaps(distDir, srcDir) {
+  let entries;
+  try {
+    entries = await fs.promises.readdir(distDir, {
+      recursive: true,
+      withFileTypes: true
+    });
+  } catch {
+    return;
+  }
+  const mapFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".js.map")).map((e) => path.join(e.parentPath ?? e.path, e.name));
+  await Promise.all(
+    mapFiles.map(async (mapFile) => {
+      try {
+        const raw = await fs.promises.readFile(mapFile, "utf8");
+        const map = JSON.parse(raw);
+        if (!Array.isArray(map.sources) || map.sources.length === 0) {
+          return;
+        }
+        const jsFile = mapFile.slice(0, -4);
+        const baseName = path.relative(distDir, jsFile).replace(/\.js$/, "");
+        const srcFile = [".ts", ".tsx", ".jsx", ".js"].map((ext) => path.join(srcDir, baseName + ext)).find((f) => fs.existsSync(f));
+        if (!srcFile) {
+          return;
+        }
+        const correctRelPath = normalizePath(
+          path.relative(path.dirname(mapFile), srcFile)
+        );
+        if (map.sources[0] === correctRelPath) {
+          return;
+        }
+        map.sources = [correctRelPath];
+        await fs.promises.writeFile(mapFile, JSON.stringify(map), "utf8");
+      } catch {
+      }
+    })
+  );
+}
 function getEsbuildOptions(files) {
   const cedarPaths = getPaths();
-  const format = projectSideIsEsm("api") ? "esm" : "cjs";
   return {
     absWorkingDir: cedarPaths.api.base,
     entryPoints: files,
     platform: "node",
-    target: "node20",
-    format,
+    target: "node24",
+    format: "esm",
     allowOverwrite: true,
     bundle: false,
-    plugins: [runCedarBabelTransformsPlugin],
+    // Registration order matters: cedarApiGraphqlPlugin (narrow filter) must
+    // come first so it claims graphql.ts before runCedarBabelTransformsPlugin
+    // (broad filter) can. See the NOTE on cedarApiGraphqlPlugin.
+    plugins: [cedarApiGraphqlPlugin, runCedarBabelTransformsPlugin],
     outdir: cedarPaths.api.dist,
     // setting this to 'true' will generate an external sourcemap x.js.map
     // AND set the sourceMappingURL comment
@@ -68,8 +351,11 @@ function getEsbuildOptions(files) {
   };
 }
 export {
+  applyImportExtensions2 as applyImportExtensions,
+  applySrcAlias2 as applySrcAlias,
   buildApi,
+  buildApiWithVite,
   cleanApiBuild,
-  rebuildApi,
-  transpileApi
+  fixSourceMaps,
+  rebuildApi
 };

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

@@ -0,0 +1,10 @@
+/**
+ * Injects imports for `gql` and `context` into API source files that reference
+ * them without importing them. Uses an oxc-parser AST walk to check bindings,
+ * so local declarations never receive a conflicting import.
+ *
+ * This replaces `babel-plugin-auto-import` for the esbuild API build path,
+ * matching the behavior of `cedarAutoImportsPlugin` in Vite builds.
+ */
+export declare function applyAutoImports(code: string): string;
+//# sourceMappingURL=auto-import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auto-import.d.ts","sourceRoot":"","sources":["../../src/build/auto-import.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBrD"}