refactor: split catalog snapshots into fragment-based architecture

Source adapters now produce CatalogFragmentV1 instead of full CatalogSnapshotV1 objects. Fragments are assembled into snapshots at the sync boundary via createCatalogSnapshotV1FromFragments, keeping import metadata separate from catalog data. This prepares the IR pipeline for multi-fragment catalog composition.

Rhys Sullivan committed 8 months ago

Commit 8019c0b1 parent 7e913c013 files · +264 −115Browse files

Unified · Split

13 files

packages/control-plane/src/ir/catalog.ts +9 −0
packages/control-plane/src/runtime/local-source-artifacts.test.ts +16 −6
packages/control-plane/src/runtime/local-source-artifacts.ts +13 −9
packages/control-plane/src/runtime/source-adapters/google-discovery.test.ts +7 −4
packages/control-plane/src/runtime/source-adapters/google-discovery.ts +10 −4
packages/control-plane/src/runtime/source-adapters/graphql.ts +12 −6
packages/control-plane/src/runtime/source-adapters/internal.ts +14 −21
packages/control-plane/src/runtime/source-adapters/mcp.test.ts +11 −8
packages/control-plane/src/runtime/source-adapters/mcp.ts +10 −4
packages/control-plane/src/runtime/source-adapters/openapi.ts +10 −4
packages/control-plane/src/runtime/source-catalog-snapshot.ts +127 −45
packages/control-plane/src/runtime/source-catalog-support.ts +20 −2
packages/control-plane/src/runtime/source-catalog-sync.ts +5 −2

packages/control-plane/src/ir/catalog.ts+9−0

@@ -1650,6 +1650,15 @@ export const createCatalogSnapshotV1 = (input: { · 1649 unmodified lines
1650	};	1650	};
1651	};	1651	};
1652		1652
		1653	export const createCatalogSnapshotV1FromFragments = (input: {
		1654	import: ImportMetadata;
		1655	fragments: readonly CatalogFragmentV1[];
		1656	}) =>
		1657	createCatalogSnapshotV1({
		1658	import: input.import,
		1659	catalog: mergeCatalogFragments(input.fragments),
		1660	});
		1661
1653	export const mergeCatalogFragments = (fragments: readonly CatalogFragmentV1[]): CatalogV1 => {	1662	export const mergeCatalogFragments = (fragments: readonly CatalogFragmentV1[]): CatalogV1 => {
1654	const catalog = emptyCatalog();	1663	const catalog = emptyCatalog();
1655	const seenByCollection = new Map<string, string>();	1664	const seenByCollection = new Map<string, string>();

packages/control-plane/src/runtime/local-source-artifacts.test.ts+16−6

 } from "./local-source-artifacts";
 import type { ResolvedLocalWorkspaceContext } from "./local-config";
 import {
-  createGraphqlCatalogSnapshot,
+  createCatalogImportMetadata,
-  createOpenApiCatalogSnapshot,
+  createGraphqlCatalogFragment,
+  createOpenApiCatalogFragment,
 } from "./source-catalog-snapshot";
 const makeContext = (): ResolvedLocalWorkspaceContext => {
     configDirectory: join(workspaceRoot, ".executor"),
     projectConfigPath: join(workspaceRoot, ".executor", "executor.jsonc"),
     homeConfigPath: join(workspaceRoot, ".executor-home.jsonc"),
+    homeStateDirectory: join(workspaceRoot, ".executor-home-state"),
     artifactsDirectory: join(workspaceRoot, ".executor", "artifacts"),
     stateDirectory: join(workspaceRoot, ".executor", "state"),
   };
 const makeArtifact = () => {
   const source = makeSource();
-  const snapshot = createOpenApiCatalogSnapshot({
+  const fragment = createOpenApiCatalogFragment({
     source,
     documents: [{
       documentKind: "openapi",
   return buildLocalSourceArtifact({
     source,
     syncResult: {
-      snapshot,
+      fragment,
+      importMetadata: createCatalogImportMetadata({
+        source,
+        adapterKey: "openapi",
+      }),
       sourceHash: source.sourceHash,
     },
   });
       defaultHeaders: null,
     },
   };
-  const snapshot = createGraphqlCatalogSnapshot({
+  const fragment = createGraphqlCatalogFragment({
     source,
     documents: [{
       documentKind: "graphql_introspection",
   return buildLocalSourceArtifact({
     source,
     syncResult: {
-      snapshot,
+      fragment,
+      importMetadata: createCatalogImportMetadata({
+        source,
+        adapterKey: "graphql",
+      }),
       sourceHash: source.sourceHash,
     },
   });

packages/control-plane/src/runtime/local-source-artifacts.ts+13−9

 import { decodeCatalogSnapshotV1 } from "../ir/catalog";
 import {
   CatalogSnapshotV1Schema,
+  type CatalogSnapshotV1,
   type NativeBlob,
   type SourceDocument,
 } from "../ir/model";
-import type { SourceCatalogSyncResult } from "./source-catalog-support";
+import {
+  contentHash,
+  snapshotFromSourceCatalogSyncResult,
+  type SourceCatalogSyncResult,
+} from "./source-catalog-support";
 import type { ResolvedLocalWorkspaceContext } from "./local-config";
 import {
   LocalFileSystemError,
   createSourceCatalogRevisionRecord,
   stableSourceCatalogId,
 } from "./source-definitions";
-import { contentHash } from "./source-catalog-support";
 const LOCAL_SOURCE_ARTIFACT_VERSION = 3 as const;
 export const LocalSourceArtifactSchema = Schema.Struct({
   return nextArtifact;
 };
-const snapshotHash = (snapshot: SourceCatalogSyncResult["snapshot"]): string =>
+const snapshotHash = (snapshot: CatalogSnapshotV1): string =>
   contentHash(JSON.stringify(snapshot));
-const importMetadataHash = (snapshot: SourceCatalogSyncResult["snapshot"]): string =>
+const importMetadataHash = (snapshot: { import: SourceCatalogSyncResult["importMetadata"] }): string =>
   contentHash(JSON.stringify(snapshot.import));
 export const buildLocalSourceArtifact = (input: {
 }): LocalSourceArtifact => {
   const catalogId: SourceCatalogId = stableSourceCatalogId(input.source);
   const generatedAt = Date.now();
-  const importHash = importMetadataHash(input.syncResult.snapshot);
+  const snapshot = snapshotFromSourceCatalogSyncResult(input.syncResult);
-  const hash = snapshotHash(input.syncResult.snapshot);
+  const importHash = importMetadataHash(snapshot);
+  const hash = snapshotHash(snapshot);
   const revision = createSourceCatalogRevisionRecord({
     source: input.source,
     catalogId,
     revisionNumber: 1,
-    importMetadataJson: JSON.stringify(input.syncResult.snapshot.import),
+    importMetadataJson: JSON.stringify(snapshot.import),
     importMetadataHash: importHash,
     snapshotHash: hash,
   });
     catalogId,
     generatedAt,
     revision,
-    snapshot: input.syncResult.snapshot,
+    snapshot,
   };
 };

packages/control-plane/src/runtime/source-adapters/google-discovery.test.ts+7−4

 import * as Effect from "effect/Effect";
 import { googleDiscoverySourceAdapter } from "./google-discovery";
+import { snapshotFromSourceCatalogSyncResult } from "../source-catalog-support";
 import { createSourceFromPayload } from "../source-definitions";
 const fetchLiveDiscoveryDocument = async (): Promise<string> => {
                 }),
             }),
           );
+          const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);
-          expect(Object.values(syncResult.snapshot.catalog.documents)[0]?.kind).toBe("google-discovery");
+          expect(syncResult.fragment.version).toBe("ir.v1.fragment");
-          expect(Object.keys(syncResult.snapshot.catalog.resources)).not.toHaveLength(0);
+          expect(Object.values(snapshot.catalog.documents)[0]?.kind).toBe("google-discovery");
-          expect(Object.keys(syncResult.snapshot.catalog.capabilities).length).toBeGreaterThan(50);
+          expect(Object.keys(snapshot.catalog.resources)).not.toHaveLength(0);
+          expect(Object.keys(snapshot.catalog.capabilities).length).toBeGreaterThan(50);
           expect(
-            Object.values(syncResult.snapshot.catalog.capabilities).some((capability) =>
+            Object.values(snapshot.catalog.capabilities).some((capability) =>
               capability.surface.toolPath.join(".") === "google.sheets.spreadsheets.values.get"
             ),
           ).toBe(true);

packages/control-plane/src/runtime/source-adapters/google-discovery.ts+10−4

 import * as Schema from "effect/Schema";
 import {
-  createGoogleDiscoveryCatalogSnapshot,
+  createCatalogImportMetadata,
+  createGoogleDiscoveryCatalogFragment,
   type GoogleDiscoveryCatalogOperationInput,
 } from "../source-catalog-snapshot";
+import { createSourceCatalogSyncResult } from "../source-catalog-support";
 import type { SourceAdapter } from "./types";
 import {
   ConnectHttpAuthSchema,
       const definitions = compileGoogleDiscoveryToolDefinitions(manifest);
       const now = Date.now();
-      return {
+      return createSourceCatalogSyncResult({
-        snapshot: createGoogleDiscoveryCatalogSnapshot({
+        fragment: createGoogleDiscoveryCatalogFragment({
           source,
           documents: [{
             documentKind: "google_discovery",
             })
           ),
         }),
+        importMetadata: createCatalogImportMetadata({
+          source,
+          adapterKey: "google_discovery",
+        }),
         sourceHash: manifest.sourceHash,
-      };
+      });
     }),
   getOauth2SetupConfig: ({ source }) => googleDiscoveryOauth2SetupConfig(source),
   normalizeOauthClientInput: (input) =>

packages/control-plane/src/runtime/source-adapters/graphql.ts+12−6

 import * as Schema from "effect/Schema";
 import {
-  createGraphqlCatalogSnapshot,
+  createCatalogImportMetadata,
+  createGraphqlCatalogFragment,
   type GraphqlCatalogOperationInput,
 } from "../source-catalog-snapshot";
+import { createSourceCatalogSyncResult } from "../source-catalog-support";
 import type { SourceAdapter } from "./types";
 import {
   ConnectHttpAuthSchema,
         }),
       );
       const now = Date.now();
-      const snapshot = yield* Effect.sync(() =>
+      const fragment = yield* Effect.sync(() =>
-        createGraphqlCatalogSnapshot({
+        createGraphqlCatalogFragment({
           source,
           documents: [{
             documentKind: "graphql_introspection",
         }),
       );
-      return {
+      return createSourceCatalogSyncResult({
-        snapshot,
+        fragment,
+        importMetadata: createCatalogImportMetadata({
+          source,
+          adapterKey: "graphql",
+        }),
         sourceHash: manifest.sourceHash,
-      };
+      });
     }).pipe(
       Effect.withSpan("graphql.syncCatalog", {
         attributes: {

packages/control-plane/src/runtime/source-adapters/internal.ts+14−21

 import * as Schema from "effect/Schema";
 import type { Source } from "#schema";
+import { createCatalogImportMetadata } from "../source-catalog-snapshot";
+import { createSourceCatalogSyncResult } from "../source-catalog-support";
 import type { SourceAdapter } from "./types";
 import {
   decodeBindingConfig,
       };
     }),
   shouldAutoProbe: () => false,
-  syncCatalog: () => Effect.succeed({
+  syncCatalog: ({ source }) =>
-    snapshot: {
+    Effect.succeed(createSourceCatalogSyncResult({
-      version: "ir.v1.snapshot",
+      fragment: {
-      import: {
+        version: "ir.v1.fragment",
-        sourceKind: "custom",
+      },
-        adapterKey: "internal",
+      importMetadata: {
+        ...createCatalogImportMetadata({
+          source,
+          adapterKey: "internal",
+        }),
         importerVersion: "ir.v1.internal",
-        importedAt: new Date().toISOString(),
         sourceConfigHash: "internal",
       },
-      catalog: {
+      sourceHash: null,
-        version: "ir.v1",
+    })),
-        documents: {},
-        resources: {},
-        scopes: {},
-        symbols: {},
-        capabilities: {},
-        executables: {},
-        responseSets: {},
-        diagnostics: {},
-      },
-    },
-    sourceHash: null,
-  }),
 };

packages/control-plane/src/runtime/source-adapters/mcp.test.ts+11−8

   expandCatalogToolByPath,
   type LoadedSourceCatalog,
 } from "../source-catalog-runtime";
+import { snapshotFromSourceCatalogSyncResult } from "../source-catalog-support";
 import { createSourceFromPayload } from "../source-definitions";
 import { mcpSourceAdapter } from "./mcp";
             cookies: {},
             bodyValues: {},
             expiresAt: null,
-            refreshAfter: null,
+          refreshAfter: null,
-          }),
+        }),
       });
+      const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);
-      const capability = Object.values(syncResult.snapshot.catalog.capabilities)[0]!;
+      const capability = Object.values(snapshot.catalog.capabilities)[0]!;
-      const executable = Object.values(syncResult.snapshot.catalog.executables)[0]!;
+      const executable = Object.values(snapshot.catalog.executables)[0]!;
-      const document = Object.values(syncResult.snapshot.catalog.documents)[0]!;
+      const document = Object.values(snapshot.catalog.documents)[0]!;
       const rawManifest = document.native?.[0]?.value;
       expect(capability.surface.title).toBe("Read File");
             cookies: {},
             bodyValues: {},
             expiresAt: null,
-            refreshAfter: null,
+          refreshAfter: null,
-          }),
+        }),
       });
+      const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);
       const tool = yield* expandCatalogToolByPath({
         catalogs: [makeLoadedCatalog({
           source,
-          snapshot: syncResult.snapshot,
+          snapshot,
         })],
         path: "mcp.demo.read_file",
       });

packages/control-plane/src/runtime/source-adapters/mcp.ts+10−4

 import * as Schema from "effect/Schema";
 import {
-  createMcpCatalogSnapshot,
+  createCatalogImportMetadata,
+  createMcpCatalogFragment,
   type McpCatalogOperationInput,
 } from "../source-catalog-snapshot";
 import {
   contentHash,
+  createSourceCatalogSyncResult,
   type SourceCatalogSyncResult,
 } from "../source-catalog-support";
 import { namespaceFromSourceName } from "../source-names";
   const manifestJson = JSON.stringify(input.manifest);
   const manifestHash = contentHash(manifestJson);
-  return {
+  return createSourceCatalogSyncResult({
-    snapshot: createMcpCatalogSnapshot({
+    fragment: createMcpCatalogFragment({
       source: input.source,
       documents: [{
         documentKind: "mcp_manifest",
         })
       ),
     }),
+    importMetadata: createCatalogImportMetadata({
+      source: input.source,
+      adapterKey: "mcp",
+    }),
     sourceHash: manifestHash,
-  };
+  });
 };
 export const mcpSourceAdapter: SourceAdapter = {

packages/control-plane/src/runtime/source-adapters/openapi.ts+10−4

 import * as Schema from "effect/Schema";
 import {
-  createOpenApiCatalogSnapshot,
+  createCatalogImportMetadata,
+  createOpenApiCatalogFragment,
   type OpenApiCatalogOperationInput,
 } from "../source-catalog-snapshot";
+import { createSourceCatalogSyncResult } from "../source-catalog-support";
 import type { SourceAdapter } from "./types";
 import {
   ConnectHttpAuthSchema,
       const definitions = compileOpenApiToolDefinitions(manifest);
       const now = Date.now();
-      return {
+      return createSourceCatalogSyncResult({
-        snapshot: createOpenApiCatalogSnapshot({
+        fragment: createOpenApiCatalogFragment({
           source,
           documents: [{
             documentKind: "openapi",
               refHintTable: manifest.refHintTable,
             })),
         }),
+        importMetadata: createCatalogImportMetadata({
+          source,
+          adapterKey: "openapi",
+        }),
         sourceHash: manifest.sourceHash,
-      };
+      });
     }),
 };

packages/control-plane/src/runtime/source-catalog-snapshot.ts+127−45

 import type { Source } from "#schema";
 import {
-  createCatalogSnapshotV1,
+  createCatalogSnapshotV1FromFragments,
-  createEmptyCatalogV1,
 } from "../ir/catalog";
 import {
   CapabilityIdSchema,
 import type {
   AuthRequirement,
   Capability,
+  CatalogFragmentV1,
   CatalogSnapshotV1,
-  CatalogV1,
   ContentSpec,
   DocumentationBlock,
   EffectKind,
 type JsonSchema = boolean | Record<string, unknown>;
+type CatalogFragmentBuilder = {
+  version: "ir.v1.fragment";
+  documents: NonNullable<CatalogFragmentV1["documents"]>;
+  resources: NonNullable<CatalogFragmentV1["resources"]>;
+  scopes: NonNullable<CatalogFragmentV1["scopes"]>;
+  symbols: NonNullable<CatalogFragmentV1["symbols"]>;
+  capabilities: NonNullable<CatalogFragmentV1["capabilities"]>;
+  executables: NonNullable<CatalogFragmentV1["executables"]>;
+  responseSets: NonNullable<CatalogFragmentV1["responseSets"]>;
+  diagnostics: NonNullable<CatalogFragmentV1["diagnostics"]>;
+};
 export type CatalogSourceDocumentInput = {
   documentKind: string;
   documentKey: string;
     }),
 });
+export const createCatalogImportMetadata = (input: {
+  source: Source;
+  adapterKey: string;
+}) => importMetadataFor(input);
+const createEmptyCatalogFragment = (): CatalogFragmentBuilder => ({
+  version: "ir.v1.fragment",
+  documents: {},
+  resources: {},
+  scopes: {},
+  symbols: {},
+  capabilities: {},
+  executables: {},
+  responseSets: {},
+  diagnostics: {},
+});
+const finalizeCatalogFragment = (fragment: CatalogFragmentBuilder): CatalogFragmentV1 => ({
+  version: "ir.v1.fragment",
+  ...(Object.keys(fragment.documents).length > 0 ? { documents: fragment.documents } : {}),
+  ...(Object.keys(fragment.resources).length > 0 ? { resources: fragment.resources } : {}),
+  ...(Object.keys(fragment.scopes).length > 0 ? { scopes: fragment.scopes } : {}),
+  ...(Object.keys(fragment.symbols).length > 0 ? { symbols: fragment.symbols } : {}),
+  ...(Object.keys(fragment.capabilities).length > 0 ? { capabilities: fragment.capabilities } : {}),
+  ...(Object.keys(fragment.executables).length > 0 ? { executables: fragment.executables } : {}),
+  ...(Object.keys(fragment.responseSets).length > 0 ? { responseSets: fragment.responseSets } : {}),
+  ...(Object.keys(fragment.diagnostics).length > 0 ? { diagnostics: fragment.diagnostics } : {}),
+});
 const addDiagnostic = (
-  catalog: CatalogV1,
+  catalog: CatalogFragmentBuilder,
   input: Omit<ImportDiagnostic, "id">,
 ) => {
   const id = DiagnosticIdSchema.make(`diag_${stableHash(input)}`);
 };
 const createJsonSchemaImporter = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   resourceId: ReturnType<typeof ResourceIdSchema.make>;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
 };
 const exampleSymbolFromValue = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   pointer: string;
 };
 const createServiceScope = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   defaults?: Scope["defaults"];
 };
 const createOperationScope = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   parentScopeId: ReturnType<typeof ScopeIdSchema.make>;
 };
 const responseSetFromSingleResponse = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   responseId: ReturnType<typeof ResponseSymbolIdSchema.make>;
   provenance: ProvenanceRef[];
   traits?: ResponseSet["variants"][number]["traits"];
 };
 const responseSetFromVariants = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   variants: ResponseSet["variants"];
   provenance: ProvenanceRef[];
 }) => {
 };
 const ensureOpenApiSecuritySchemeSymbol = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   schemeName: string;
 };
 const openApiAuthRequirementToIr = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   authRequirement: OpenApiToolProviderData["authRequirement"] | undefined;
 };
 const contentSpecsFromOpenApiContents = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   importer: JsonSchemaImporter;
   });
 const createOpenApiHeaderSymbol = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   importer: JsonSchemaImporter;
 };
 const createHttpCapabilityFromOpenApi = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   serviceScopeId: ReturnType<typeof ScopeIdSchema.make>;
 };
 const createHttpCapabilityFromGoogleDiscovery = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   serviceScopeId: ReturnType<typeof ScopeIdSchema.make>;
 };
 const createGraphqlCapability = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   serviceScopeId: ReturnType<typeof ScopeIdSchema.make>;
 };
 const createMcpCapability = (input: {
-  catalog: CatalogV1;
+  catalog: CatalogFragmentBuilder;
   source: Source;
   documentId: ReturnType<typeof DocumentIdSchema.make>;
   serviceScopeId: ReturnType<typeof ScopeIdSchema.make>;
   } satisfies Capability;
 };
-const buildCatalogSnapshot = (input: {
+const buildCatalogFragment = (input: {
   source: Source;
-  adapterKey: string;
   documents: readonly CatalogSourceDocumentInput[];
   serviceScopeDefaults?: Scope["defaults"];
   registerOperations: (context: {
-    catalog: CatalogV1;
+    catalog: CatalogFragmentBuilder;
     documentId: ReturnType<typeof DocumentIdSchema.make>;
     serviceScopeId: ReturnType<typeof ScopeIdSchema.make>;
     importer: JsonSchemaImporter;
   }) => void;
-}): CatalogSnapshotV1 => {
+}): CatalogFragmentV1 => {
-  const catalog = createEmptyCatalogV1();
+  const catalog = createEmptyCatalogFragment();
   const documents = input.documents.length > 0
     ? input.documents
     : [{
   });
   importer.finalize();
-  const snapshot = createCatalogSnapshotV1({
+  return finalizeCatalogFragment(catalog);
-    import: importMetadataFor(input),
-    catalog,
-  });
-  return snapshot;
 };
-export const createOpenApiCatalogSnapshot = (input: {
+export const createOpenApiCatalogFragment = (input: {
   source: Source;
   documents: readonly CatalogSourceDocumentInput[];
   operations: readonly OpenApiCatalogOperationInput[];
-}): CatalogSnapshotV1 => {
+}): CatalogFragmentV1 => {
   const rootSchema = (() => {
     const primaryDocumentText = input.documents[0]?.contentText;
     if (!primaryDocumentText) {
     }
   })();
-  return buildCatalogSnapshot({
+  return buildCatalogFragment({
     source: input.source,
-    adapterKey: "openapi",
     documents: input.documents,
     serviceScopeDefaults: (() => {
       const documentServers = openApiServerSpecs(
   });
 };
-export const createGoogleDiscoveryCatalogSnapshot = (input: {
+export const createOpenApiCatalogSnapshot = (input: {
   source: Source;
   documents: readonly CatalogSourceDocumentInput[];
-  operations: readonly GoogleDiscoveryCatalogOperationInput[];
+  operations: readonly OpenApiCatalogOperationInput[];
 }): CatalogSnapshotV1 =>
-  buildCatalogSnapshot({
+  createCatalogSnapshotV1FromFragments({
+    import: createCatalogImportMetadata({
+      source: input.source,
+      adapterKey: "openapi",
+    }),
+    fragments: [createOpenApiCatalogFragment(input)],
+  });
+export const createGoogleDiscoveryCatalogFragment = (input: {
+  source: Source;
+  documents: readonly CatalogSourceDocumentInput[];
+  operations: readonly GoogleDiscoveryCatalogOperationInput[];
+}): CatalogFragmentV1 =>
+  buildCatalogFragment({
     source: input.source,
-    adapterKey: "google_discovery",
     documents: input.documents,
     serviceScopeDefaults: (() => {
       const servers = googleDiscoveryServerSpecs(input.operations[0]);
     },
   });
-export const createGraphqlCatalogSnapshot = (input: {
+export const createGoogleDiscoveryCatalogSnapshot = (input: {
   source: Source;
   documents: readonly CatalogSourceDocumentInput[];
-  operations: readonly GraphqlCatalogOperationInput[];
+  operations: readonly GoogleDiscoveryCatalogOperationInput[];
 }): CatalogSnapshotV1 =>
-  buildCatalogSnapshot({
+  createCatalogSnapshotV1FromFragments({
+    import: createCatalogImportMetadata({
+      source: input.source,
+      adapterKey: "google_discovery",
+    }),
+    fragments: [createGoogleDiscoveryCatalogFragment(input)],
+  });
+export const createGraphqlCatalogFragment = (input: {
+  source: Source;
+  documents: readonly CatalogSourceDocumentInput[];
+  operations: readonly GraphqlCatalogOperationInput[];
+}): CatalogFragmentV1 =>
+  buildCatalogFragment({
     source: input.source,
-    adapterKey: "graphql",
     documents: input.documents,
     registerOperations: ({ catalog, documentId, serviceScopeId, importer }) => {
       for (const operation of input.operations) {
     },
   });
-export const createMcpCatalogSnapshot = (input: {
+export const createGraphqlCatalogSnapshot = (input: {
   source: Source;
   documents: readonly CatalogSourceDocumentInput[];
-  operations: readonly McpCatalogOperationInput[];
+  operations: readonly GraphqlCatalogOperationInput[];
 }): CatalogSnapshotV1 =>
-  buildCatalogSnapshot({
+  createCatalogSnapshotV1FromFragments({
+    import: createCatalogImportMetadata({
+      source: input.source,
+      adapterKey: "graphql",
+    }),
+    fragments: [createGraphqlCatalogFragment(input)],
+  });
+export const createMcpCatalogFragment = (input: {
+  source: Source;
+  documents: readonly CatalogSourceDocumentInput[];
+  operations: readonly McpCatalogOperationInput[];
+}): CatalogFragmentV1 =>
+  buildCatalogFragment({
     source: input.source,
-    adapterKey: "mcp",
     documents: input.documents,
     registerOperations: ({ catalog, documentId, serviceScopeId, importer }) => {
       for (const operation of input.operations) {
       }
     },
   });
+export const createMcpCatalogSnapshot = (input: {
+  source: Source;
+  documents: readonly CatalogSourceDocumentInput[];
+  operations: readonly McpCatalogOperationInput[];
+}): CatalogSnapshotV1 =>
+  createCatalogSnapshotV1FromFragments({
+    import: createCatalogImportMetadata({
+      source: input.source,
+      adapterKey: "mcp",
+    }),
+    fragments: [createMcpCatalogFragment(input)],
+  });

packages/control-plane/src/runtime/source-catalog-support.ts+20−2

@@ -1,5 +1,10 @@
1	import { sha256Hex } from "@executor/codemode-core";	1	import { sha256Hex } from "@executor/codemode-core";
2	import type { CatalogSnapshotV1 } from "../ir/model";	2	import { createCatalogSnapshotV1FromFragments } from "../ir/catalog";
		3	import type {
		4	CatalogFragmentV1,
		5	CatalogSnapshotV1,
		6	ImportMetadata,
		7	} from "../ir/model";
3		8
4	export const normalizeSearchText = (	9	export const normalizeSearchText = (
5	...parts: ReadonlyArray<string \| null \| undefined>	10	...parts: ReadonlyArray<string \| null \| undefined>
@@ -13,6 +18,19 @@ export const normalizeSearchText = ( · 7 unmodified lines
13	export const contentHash = (value: string): string => sha256Hex(value);	18	export const contentHash = (value: string): string => sha256Hex(value);
14		19
15	export type SourceCatalogSyncResult = {	20	export type SourceCatalogSyncResult = {
16	snapshot: CatalogSnapshotV1;	21	fragment: CatalogFragmentV1;
		22	importMetadata: ImportMetadata;
17	sourceHash: string \| null;	23	sourceHash: string \| null;
18	};	24	};
		25
		26	export const createSourceCatalogSyncResult = (
		27	input: SourceCatalogSyncResult,
		28	): SourceCatalogSyncResult => input;
		29
		30	export const snapshotFromSourceCatalogSyncResult = (
		31	syncResult: SourceCatalogSyncResult,
		32	): CatalogSnapshotV1 =>
		33	createCatalogSnapshotV1FromFragments({
		34	import: syncResult.importMetadata,
		35	fragments: [syncResult.fragment],
		36	});

packages/control-plane/src/runtime/source-catalog-sync.ts+5−2

   catalogSyncResultFromMcpManifest,
 } from "./source-adapters/mcp";
 import { SecretMaterialResolverService } from "./secret-material-providers";
+import { snapshotFromSourceCatalogSyncResult } from "./source-catalog-support";
 import {
   refreshSourceTypeDeclarationInBackground,
 } from "./source-type-declarations";
           actorAccountId: input.actorAccountId,
         }),
     });
+    const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);
     yield* deps.sourceArtifactStore.write({
       context: workspaceContext,
       sourceId: input.source.id,
       refreshSourceTypeDeclarationInBackground({
         context: workspaceContext,
         source: input.source,
-        snapshot: syncResult.snapshot,
+        snapshot,
       });
     });
   }).pipe(
       endpoint: input.source.endpoint,
       manifest: input.manifest,
     });
+    const snapshot = snapshotFromSourceCatalogSyncResult(syncResult);
     yield* deps.sourceArtifactStore.write({
       context: workspaceContext,
       refreshSourceTypeDeclarationInBackground({
         context: workspaceContext,
         source: input.source,
-        snapshot: syncResult.snapshot,
+        snapshot,
       });
     });
   });