Merge pull request #1648 from tailor-platform/fix/namespace-bundle-cache-key

fix(cli): isolate resolver bundle cache keys

Author: dqn

.changeset/quiet-bundles-warm.md

@@ -0,0 +1,5 @@
+---
+"@tailor-platform/sdk": patch
+---
+
+Keep resolver bundle cache entries separate across namespaces.

example/tests/scripts/generate_files.ts

@@ -95,6 +95,13 @@ async function listGeneratedFiles(dirPath: string, depth = 0, maxDepth = 3): Pro
 const generatorsCompatDir = "tests/fixtures/generators";
 const pluginsCompatDir = "tests/fixtures/plugins";
 
+function bundledScriptFileName(kind: string, name: string): string {
+  if (kind !== "resolvers") return name;
+
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex === -1 ? name : name.slice(separatorIndex + 1);
+}
+
 export async function generateCompatFiles(): Promise<void> {
   for (const dir of [generatorsCompatDir, pluginsCompatDir]) {
     if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true });
@@ -122,7 +129,7 @@ export async function generateCompatFiles(): Promise<void> {
       if (scripts.size === 0) continue;
       fs.mkdirSync(dirPath, { recursive: true });
       for (const [name, code] of scripts) {
-        fs.writeFileSync(path.join(dirPath, `${name}.js`), code);
+        fs.writeFileSync(path.join(dirPath, `${bundledScriptFileName(kind, name)}.js`), code);
       }
     }
   }

packages/sdk/src/cli/cache/bundle-cache.test.ts

@@ -190,10 +190,7 @@ describe("createBundleCache", () => {
       expect(entry?.outputFiles).toHaveLength(1);
       expect(entry?.outputFiles[0]?.contentHash).toMatch(/^[0-9a-f]{64}$/);
 
-      // Cache filename replaces the ":" in "kind:name" with "_"
-      const cachedBundlePath = path.join(cacheDir, "bundles", "executor_myExecutor.js");
-      expect(fs.existsSync(cachedBundlePath)).toBe(true);
-      expect(fs.readFileSync(cachedBundlePath, "utf-8")).toBe("bundled executor");
+      expect(store.restoreBundleContent("executor:myExecutor")).toBe("bundled executor");
     });
 
     test("updates existing cache entry on re-save", () => {
@@ -244,6 +241,39 @@ describe("createBundleCache", () => {
       expect(store.getEntry("getUser")).toBeUndefined();
       expect(store.getEntry("resolver")).toBeUndefined();
     });
+
+    test("cache key includes namespace when provided", () => {
+      const store = createCacheStore({ cacheDir });
+      const cache = createBundleCache(store);
+      const firstSourceFile = writeFile("src/first/resolver.ts", "export default {}");
+      const secondSourceFile = writeFile("src/second/resolver.ts", "export default {}");
+
+      cache.save({
+        kind: "resolver",
+        namespace: "first",
+        name: "getUser",
+        sourceFile: firstSourceFile,
+        content: "first bundle",
+        dependencyPaths: [firstSourceFile],
+      });
+      cache.save({
+        kind: "resolver",
+        namespace: "second",
+        name: "getUser",
+        sourceFile: secondSourceFile,
+        content: "second bundle",
+        dependencyPaths: [secondSourceFile],
+      });
+
+      expect(store.getEntry("resolver:first:getUser")).toBeDefined();
+      expect(store.getEntry("resolver:second:getUser")).toBeDefined();
+      expect(cache.tryRestore({ kind: "resolver", namespace: "first", name: "getUser" })).toBe(
+        "first bundle",
+      );
+      expect(cache.tryRestore({ kind: "resolver", namespace: "second", name: "getUser" })).toBe(
+        "second bundle",
+      );
+    });
   });
 });
 
@@ -351,6 +381,47 @@ describe("withCache", () => {
     });
     expect(build).toHaveBeenCalledOnce();
   });
+
+  test("keeps entries separate by namespace", async () => {
+    const cache = createBundleCache(createCacheStore({ cacheDir }));
+    const firstSourceFile = writeFile("src/first/resolver.ts", "export default {}");
+    const secondSourceFile = writeFile("src/second/resolver.ts", "export default {}");
+    const buildFirst = vi.fn(async () => "first bundle");
+    const buildSecond = vi.fn(async () => "second bundle");
+
+    await withCache({
+      cache,
+      kind: "resolver",
+      namespace: "first",
+      name: "getUser",
+      sourceFile: firstSourceFile,
+      contextHash: undefined,
+      build: buildFirst,
+    });
+    await withCache({
+      cache,
+      kind: "resolver",
+      namespace: "second",
+      name: "getUser",
+      sourceFile: secondSourceFile,
+      contextHash: undefined,
+      build: buildSecond,
+    });
+
+    buildFirst.mockClear();
+    const result = await withCache({
+      cache,
+      kind: "resolver",
+      namespace: "first",
+      name: "getUser",
+      sourceFile: firstSourceFile,
+      contextHash: undefined,
+      build: buildFirst,
+    });
+
+    expect(buildFirst).not.toHaveBeenCalled();
+    expect(result).toBe("first bundle");
+  });
 });
 
 describe("computeBundlerContextHash", () => {

packages/sdk/src/cli/cache/bundle-cache.ts

@@ -15,13 +15,15 @@ type BundleKind =
 
 type BundleCacheRestoreParams = {
   kind: BundleKind;
+  namespace?: string;
   name: string;
   /** Optional hash of non-file context (e.g., env variables) to include in cache validation. */
   contextHash?: string;
 };
 
 type BundleCacheSaveParams = {
   kind: BundleKind;
+  namespace?: string;
   name: string;
   sourceFile: string;
   content: string;
@@ -41,8 +43,8 @@ type BundleCache = {
   save(params: BundleCacheSaveParams): void;
 };
 
-function buildCacheKey(kind: string, name: string): string {
-  return `${kind}:${name}`;
+function buildCacheKey(kind: string, name: string, namespace?: string): string {
+  return namespace ? `${kind}:${namespace}:${name}` : `${kind}:${name}`;
 }
 
 function combineHash(fileHash: string, contextHash?: string): string {
@@ -90,6 +92,7 @@ function computeBundlerContextHash(params: ComputeBundlerContextHashParams): str
 type WithCacheParams = {
   cache: BundleCache | undefined;
   kind: BundleKind;
+  namespace?: string;
   name: string;
   sourceFile: string;
   contextHash: string | undefined;
@@ -104,13 +107,13 @@ type WithCacheParams = {
  * @returns The bundled code string
  */
 async function withCache(params: WithCacheParams): Promise<string> {
-  const { cache, kind, name, sourceFile, contextHash, build } = params;
+  const { cache, kind, namespace, name, sourceFile, contextHash, build } = params;
 
   if (!cache) {
     return await build([]);
   }
 
-  const content = cache.tryRestore({ kind, name, contextHash });
+  const content = cache.tryRestore({ kind, namespace, name, contextHash });
   if (content !== undefined) {
     logger.debug(`  ${styles.dim("cached")}: ${name}`);
     return content;
@@ -119,7 +122,15 @@ async function withCache(params: WithCacheParams): Promise<string> {
   const { plugin, getResult } = createDepCollectorPlugin();
   const code = await build([plugin]);
 
-  cache.save({ kind, name, sourceFile, content: code, dependencyPaths: getResult(), contextHash });
+  cache.save({
+    kind,
+    namespace,
+    name,
+    sourceFile,
+    content: code,
+    dependencyPaths: getResult(),
+    contextHash,
+  });
 
   return code;
 }
@@ -131,7 +142,7 @@ async function withCache(params: WithCacheParams): Promise<string> {
  */
 function createBundleCache(store: CacheStore): BundleCache {
   function tryRestore(params: BundleCacheRestoreParams): string | undefined {
-    const cacheKey = buildCacheKey(params.kind, params.name);
+    const cacheKey = buildCacheKey(params.kind, params.name, params.namespace);
     const entry = store.getEntry(cacheKey);
 
     if (!entry) {
@@ -155,8 +166,8 @@ function createBundleCache(store: CacheStore): BundleCache {
   }
 
   function save(params: BundleCacheSaveParams): void {
-    const { kind, name, sourceFile, content, dependencyPaths, contextHash } = params;
-    const cacheKey = buildCacheKey(kind, name);
+    const { kind, namespace, name, sourceFile, content, dependencyPaths, contextHash } = params;
+    const cacheKey = buildCacheKey(kind, name, namespace);
     // Always include sourceFile in dependency paths so that changes to the
     // source file itself are detected even when dep-collector only finds
     // node_modules imports (which are filtered out).

packages/sdk/src/cli/cache/store.test.ts

@@ -149,6 +149,18 @@ describe("createCacheStore", () => {
     });
   });
 
+  describe("storeBundleContent / restoreBundleContent", () => {
+    test("keeps bundle content separate when cache keys share an underscore form", () => {
+      const store = createCacheStore({ cacheDir });
+
+      store.storeBundleContent("resolver:foo_bar:baz", "first bundle");
+      store.storeBundleContent("resolver:foo:bar_baz", "second bundle");
+
+      expect(store.restoreBundleContent("resolver:foo_bar:baz")).toBe("first bundle");
+      expect(store.restoreBundleContent("resolver:foo:bar_baz")).toBe("second bundle");
+    });
+  });
+
   describe("clean", () => {
     test("removes entire cache directory", () => {
       const store = createCacheStore({ cacheDir });

packages/sdk/src/cli/cache/store.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "pathe";
+import { hashContent } from "./hasher";
 import { cacheManifestSchema } from "./types";
 import type { CacheConfig, CacheEntry, CacheManifest } from "./types";
 
@@ -48,7 +49,7 @@ function createCacheStore(config: CacheConfig): CacheStore {
   }
 
   function bundlePath(cacheKey: string): string {
-    return path.join(bundlesDir(), `${cacheKey.replaceAll(":", "_")}.js`);
+    return path.join(bundlesDir(), `${hashContent(cacheKey)}.js`);
   }
 
   function loadManifest(): CacheManifest | undefined {

packages/sdk/src/cli/commands/deploy/__test_fixtures__/integration.test.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { afterAll, beforeAll, describe, expect, test, vi } from "vitest";
+import { resolverBundleKey } from "#/cli/shared/resolver-bundle-key";
 import { setupInvokerMock, setupTailordbMock, setupTailorErrorsMock } from "#/utils/test/mock";
 import { prepareFixtures } from "./prepare";
 import type { BundledScripts } from "#/cli/commands/deploy/function-registry";
@@ -97,17 +98,18 @@ describe("deploy command integration tests", () => {
 
   describe("validation", () => {
     let main: MainFunction;
+    const addResolverBundleKey = resolverBundleKey("test-resolver", "add");
 
     beforeAll(async () => {
-      const code = bundledScripts.resolvers.get("add");
+      const code = bundledScripts.resolvers.get(addResolverBundleKey);
       if (!code) {
         throw new Error("resolvers/add bundle not found");
       }
       main = await importFromCode(code, "resolvers/add");
     });
 
     test("resolvers/add bundle is defined", () => {
-      expect(bundledScripts.resolvers.get("add")).toBeDefined();
+      expect(bundledScripts.resolvers.get(addResolverBundleKey)).toBeDefined();
     });
 
     test("resolvers/add validates input correctly - valid values", async () => {

packages/sdk/src/cli/commands/deploy/function-registry.test.ts

@@ -1,4 +1,5 @@
 import { describe, test, expect, vi, beforeEach } from "vitest";
+import { resolverBundleKey } from "#/cli/shared/resolver-bundle-key";
 import {
   applyFunctionRegistry,
   authHookFunctionName,
@@ -481,8 +482,8 @@ describe("collectFunctionEntries", () => {
   test("collects resolver entries with correct names and hashes", () => {
     const scripts = createBundledScripts({
       resolvers: new Map([
-        ["getUser", "// getUser code"],
-        ["listUsers", "// listUsers code"],
+        [resolverBundleKey("my-ns", "getUser"), "// getUser code"],
+        [resolverBundleKey("my-ns", "listUsers"), "// listUsers code"],
       ]),
     });
 
@@ -508,6 +509,40 @@ describe("collectFunctionEntries", () => {
     expect(entries[1]!.name).toBe(resolverFunctionName("my-ns", "listUsers"));
   });
 
+  test("keeps resolver entries separate when namespaces share resolver names", () => {
+    const scripts = createBundledScripts({
+      resolvers: new Map([
+        [resolverBundleKey("first", "getUser"), "// first getUser code"],
+        [resolverBundleKey("second", "getUser"), "// second getUser code"],
+      ]),
+    });
+
+    const app = createMockApplication({
+      resolverServices: [
+        {
+          namespace: "first",
+          resolvers: {
+            getUser: { name: "getUser" },
+          },
+        },
+        {
+          namespace: "second",
+          resolvers: {
+            getUser: { name: "getUser" },
+          },
+        },
+      ],
+    });
+
+    const entries = collectFunctionEntries(app, [], scripts);
+
+    expect(entries).toHaveLength(2);
+    expect(entries[0]!.name).toBe(resolverFunctionName("first", "getUser"));
+    expect(entries[0]!.scriptContent).toBe("// first getUser code");
+    expect(entries[1]!.name).toBe(resolverFunctionName("second", "getUser"));
+    expect(entries[1]!.scriptContent).toBe("// second getUser code");
+  });
+
   test("collects executor entries only for function/jobFunction kinds", () => {
     const scripts = createBundledScripts({
       executors: new Map([

packages/sdk/src/cli/commands/deploy/function-registry.ts

@@ -1,5 +1,6 @@
 import * as crypto from "node:crypto";
 import { logger } from "#/cli/shared/logger";
+import { resolverBundleKey } from "#/cli/shared/resolver-bundle-key";
 import { createChangeSet, type ChangeSet, type HasName } from "./change-set";
 import { buildMetaRequest, hasMatchingSdkVersion, resourceTrn } from "./label";
 import {
@@ -175,9 +176,13 @@ export function collectFunctionEntries(
   for (const app of application.applications) {
     for (const pipeline of app.resolverServices) {
       for (const resolver of Object.values(pipeline.resolvers)) {
-        const content = bundledScripts.resolvers.get(resolver.name);
+        const content = bundledScripts.resolvers.get(
+          resolverBundleKey(pipeline.namespace, resolver.name),
+        );
         if (!content) {
-          logger.warn(`Bundled code not found for resolver: ${resolver.name}`);
+          logger.warn(
+            `Bundled code not found for resolver: ${pipeline.namespace}/${resolver.name}`,
+          );
           continue;
         }
         entries.push({

packages/sdk/src/cli/services/application.ts

@@ -24,6 +24,7 @@ import { type LoadedConfig } from "#/cli/shared/config-loader";
 import { getDistDir } from "#/cli/shared/dist-dir";
 import { resolveInlineSourcemap } from "#/cli/shared/inline-sourcemap";
 import { logger } from "#/cli/shared/logger";
+import { resolverBundleKey } from "#/cli/shared/resolver-bundle-key";
 import { buildTriggerContext } from "#/cli/shared/trigger-context";
 import {
   type AppConfig,
@@ -539,7 +540,7 @@ export async function loadApplication(
       bundleLogLevel,
     );
     for (const [name, code] of resolverBundles) {
-      bundledScripts.resolvers.set(name, code);
+      bundledScripts.resolvers.set(resolverBundleKey(pipeline.namespace, name), code);
     }
   }