@cedarjs/internal 5.0.6 → 5.0.7-next.219

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,4 +1,6 @@
 import type { BuildOptions } from 'esbuild';
+export { applySrcAlias } from './src-alias.js';
+export { applyEsmExtensions } from './esm-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>;

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

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/build/api.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,YAAY,EAAe,MAAM,SAAS,CAAA;AAiBtE,eAAO,MAAM,QAAQ,4DAIpB,CAAA;AAED,eAAO,MAAM,UAAU,4DAStB,CAAA;AAED,eAAO,MAAM,aAAa,qBAGzB,CAAA;AA8FD,eAAO,MAAM,gBAAgB,iHAqD5B,CAAA;AAcD,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAoDf"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/build/api.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgB,YAAY,EAAe,MAAM,SAAS,CAAA;AA6CtE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAIxD,eAAO,MAAM,QAAQ,4DAIpB,CAAA;AAED,eAAO,MAAM,UAAU,4DAStB,CAAA;AAED,eAAO,MAAM,aAAa,qBAGzB,CAAA;AA0VD,eAAO,MAAM,gBAAgB,iHAiE5B,CAAA;AAcD,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAoDf"}

package/dist/build/api.js

@@ -1,14 +1,42 @@
 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,
+  projectSideIsEsm,
+  resolveFile
+} from "@cedarjs/project-config";
 import { findApiFiles } from "../files.js";
-import { applyContextWrapping } from "./esbuild-plugin-cedar-context-wrapping.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 { applyEsmExtensions } from "./esm-extensions.js";
+import { applyImportDir } from "./import-dir.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 { applyEsmExtensions as applyEsmExtensions2 } from "./esm-extensions.js";
 let BUILD_CTX = null;
 const buildApi = async () => {
   BUILD_CTX?.dispose();
@@ -32,33 +60,124 @@ 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 fileContents = await fs.promises.readFile(args.path, "utf-8");
-      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) {
-        const functionsDir = normalizePath(
-          path.join(getPaths().api.src, "functions")
+      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 isEsm = projectSideIsEsm("api");
+      const apiBabelConfigPath = getApiSideBabelConfigPath();
+      let code = fileContents;
+      if (apiBabelConfigPath) {
+        const transformedCode = await transformWithBabel(
+          fileContents,
+          args.path,
+          getApiSideBabelPluginsForVite(),
+          "inline",
+          true
         );
-        const code = normalizePath(args.path).startsWith(functionsDir + "/") ? applyContextWrapping(transformedCode.code, {
-          projectIsEsm: projectSideIsEsm("api")
-        }) ?? transformedCode.code : transformedCode.code;
-        return {
-          contents: code,
-          loader: "js"
-        };
+        if (!transformedCode?.code) {
+          throw new Error(`Could not transform file: ${args.path}`);
+        }
+        code = transformedCode.code;
+      }
+      if (isEsm) {
+        code = applyEsmExtensions(code, args.path);
+      }
+      const functionsDir = normalizePath(cedarPaths.api.functions);
+      if (normalizedPath.startsWith(functionsDir + "/")) {
+        code = applyHandlerAlsWrapping(code, {
+          projectIsEsm: isEsm
+        }) ?? code;
+      }
+      if (normalizedPath.startsWith(normalizePath(cedarPaths.api.src) + "/")) {
+        code = applyOtelWrapping(code, args.path, cedarPaths.api.src) ?? code;
       }
-      throw new Error(`Could not transform file: ${args.path}`);
+      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();
   const isEsm = projectSideIsEsm("api");
@@ -76,28 +195,55 @@ function createCedarViteApiPlugin() {
       if (!normalizePath(id).startsWith(normalizePath(cedarPaths.api.base))) {
         return null;
       }
-      const transformedCode = await transformWithBabel(
-        code,
+      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,
-        getApiSideBabelPlugins({
-          openTelemetry: cedarConfig.experimental.opentelemetry.enabled && cedarConfig.experimental.opentelemetry.wrapApi,
-          projectIsEsm: isEsm
-        }),
+        getApiSideBabelPluginsForVite(),
+        true,
         true
-      );
-      if (transformedCode?.code) {
-        const functionsDir = normalizePath(
-          path.join(cedarPaths.api.src, "functions")
-        );
-        const code2 = normalizePath(id).startsWith(functionsDir + "/") ? applyContextWrapping(transformedCode.code, {
+      ) : 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;
+      }
+      if (isEsm) {
+        outputCode = applyEsmExtensions(outputCode, id);
+      }
+      const functionsDir = normalizePath(cedarPaths.api.functions);
+      if (normalizedId.startsWith(functionsDir + "/")) {
+        outputCode = applyHandlerAlsWrapping(outputCode, {
           projectIsEsm: isEsm
-        }) ?? transformedCode.code : transformedCode.code;
+        }) ?? outputCode;
+      }
+      if (!transformedCode) {
+        if (outputCode === code) {
+          return null;
+        }
         return {
-          code: code2,
-          map: transformedCode.map ?? null
+          code: outputCode,
+          map: new MagicString(code).generateMap({ hires: true })
         };
       }
-      throw new Error(`Could not transform file: ${id}`);
+      return {
+        code: outputCode,
+        map: transformedCode.map ?? null
+      };
     }
   };
 }
@@ -141,7 +287,19 @@ const buildApiWithVite = async () => {
         }
       }
     },
-    plugins: [createCedarViteApiPlugin()]
+    // 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) => {
@@ -199,7 +357,10 @@ function getEsbuildOptions(files) {
     format,
     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
@@ -208,6 +369,8 @@ function getEsbuildOptions(files) {
   };
 }
 export {
+  applyEsmExtensions2 as applyEsmExtensions,
+  applySrcAlias2 as applySrcAlias,
   buildApi,
   buildApiWithVite,
   cleanApiBuild,

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"}

package/dist/build/auto-import.js

@@ -0,0 +1,120 @@
+import { parseSync, Visitor } from "oxc-parser";
+function applyAutoImports(code) {
+  const result = parseSync("temp.ts", code, {
+    lang: "ts",
+    sourceType: "module"
+  });
+  const needsGql = checkNeeds("gql", result.program, code);
+  const needsContext = checkNeeds("context", result.program, code);
+  let resultCode = code;
+  if (needsGql) {
+    resultCode = "import gql from 'graphql-tag'\n" + resultCode;
+  }
+  if (needsContext) {
+    resultCode = "import { context } from '@cedarjs/context'\n" + resultCode;
+  }
+  return resultCode;
+}
+function bindingInDeclarators(name, declarations) {
+  for (const decl of declarations) {
+    if (bindingPatternContains(decl.id, name)) {
+      return true;
+    }
+  }
+  return false;
+}
+function bindingPatternContains(pattern, name) {
+  if (pattern.type === "Identifier") {
+    return pattern.name === name;
+  }
+  if (pattern.type === "ObjectPattern") {
+    for (const prop of pattern.properties) {
+      if (prop.type === "RestElement") {
+        if (bindingPatternContains(prop.argument, name)) {
+          return true;
+        }
+      } else {
+        if (bindingPatternContains(prop.value, name)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  if (pattern.type === "ArrayPattern") {
+    for (const el of pattern.elements) {
+      if (el) {
+        if (el.type === "RestElement") {
+          if (bindingPatternContains(el.argument, name)) {
+            return true;
+          }
+        } else if (bindingPatternContains(el, name)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  if (pattern.type === "AssignmentPattern") {
+    return bindingPatternContains(pattern.left, name);
+  }
+  return false;
+}
+function checkNeeds(name, program, code) {
+  if (!code.includes(name)) {
+    return false;
+  }
+  let isBound = false;
+  let hasUsage = false;
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration") {
+      for (const specifier of node.specifiers) {
+        if (specifier.type === "ImportSpecifier") {
+          if (specifier.imported.type === "Identifier" && specifier.imported.name === name || specifier.local.name === name) {
+            isBound = true;
+            break;
+          }
+        } else if (specifier.type === "ImportDefaultSpecifier") {
+          if (specifier.local.name === name) {
+            isBound = true;
+            break;
+          }
+        } else if (specifier.type === "ImportNamespaceSpecifier") {
+          if (specifier.local.name === name) {
+            isBound = true;
+            break;
+          }
+        }
+      }
+    }
+    if (node.type === "VariableDeclaration") {
+      if (bindingInDeclarators(name, node.declarations)) {
+        isBound = true;
+      }
+    }
+    if (node.type === "FunctionDeclaration" && node.id?.name === name) {
+      isBound = true;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration) {
+      if (node.declaration.type === "VariableDeclaration") {
+        if (bindingInDeclarators(name, node.declaration.declarations)) {
+          isBound = true;
+        }
+      }
+    }
+  }
+  if (isBound) {
+    return false;
+  }
+  new Visitor({
+    Identifier(node) {
+      if (node.name === name) {
+        hasUsage = true;
+      }
+    }
+  }).visit(program);
+  return hasUsage;
+}
+export {
+  applyAutoImports
+};

package/dist/build/directory-named-import.d.ts

@@ -0,0 +1,2 @@
+export declare function applyDirectoryNamedImport(code: string, filePath: string): string;
+//# sourceMappingURL=directory-named-import.d.ts.map

package/dist/build/directory-named-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-named-import.d.ts","sourceRoot":"","sources":["../../src/build/directory-named-import.ts"],"names":[],"mappings":"AAiCA,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,MAAM,CAyBR"}