@query-farm/vgi 0.21.0 → 0.23.0

package/dist/protocol/handlers/function.d.ts

@@ -4,5 +4,13 @@ export interface FunctionHandlerConfig {
     registry: FunctionRegistry;
     recoverExchangeState?: (opaqueData: Uint8Array) => any;
     signingKey?: Uint8Array;
+    /**
+     * Used to map a bind's `attach_opaque_data` to its catalog, so resolution can
+     * be scoped when two catalogs declare the same schema and function name.
+     * Optional — without it, resolution falls back to (schema, name).
+     */
+    catalogInterface?: {
+        catalogNameForAttach(a: Uint8Array): string | null;
+    };
 }
 export declare function registerFunctionMethods(protocol: Protocol, config: FunctionHandlerConfig): void;

package/dist/protocol/handlers/shared.d.ts

@@ -22,6 +22,10 @@ export declare function overloadContext(req: {
     arguments: any;
     input_schema: any;
     function_type: any;
+    schema_name?: string | null;
+    attach_opaque_data?: Uint8Array | null;
+}, catalogInterface?: {
+    catalogNameForAttach(a: Uint8Array): string | null;
 }): OverloadContext;
 /**
  * Recover accumulated exchange state from a FINALIZE init request.

package/dist/protocol/types.d.ts

@@ -73,6 +73,14 @@ export interface BindRequest {
      */
     at_unit?: string | null;
     at_value?: string | null;
+    /**
+     * Catalog schema that declares the function being bound. A worker may
+     * register the same name in more than one schema, so the bare name does not
+     * identify an implementation — resolution is by `(schema_name,
+     * function_name)`. Null for callers with no catalog context (COPY handler
+     * binds). Mirrors vgi-python's `BindRequest.schema_name`.
+     */
+    schema_name?: string | null;
 }
 export interface BindResponse {
     output_schema: VgiSchema;

package/dist/serve-entry.js

@@ -3029,7 +3029,8 @@ var BIND_REQUEST_SCHEMA = schema2([
   field2("transaction_opaque_data", binary2(), true),
   field2("resolved_secrets_provided", bool2(), false),
   field2("at_unit", utf82(), true),
-  field2("at_value", utf82(), true)
+  field2("at_value", utf82(), true),
+  field2("schema_name", utf82(), true)
 ]);
 var COPY_FROM_STRUCT_TYPE = struct2([
   field2("format", utf82(), false),
@@ -3097,6 +3098,7 @@ function deserializeBindRequest(params) {
     resolved_secrets_provided: params.resolved_secrets_provided ?? false,
     at_unit: params.at_unit ? String(params.at_unit) : null,
     at_value: params.at_value ? String(params.at_value) : null,
+    schema_name: params.schema_name ? String(params.schema_name) : null,
     copy_from: parseCopyFromContext(params.copy_from),
     copy_to: parseCopyToContext(params.copy_to)
   };
@@ -3922,11 +3924,21 @@ function wrapResult(values, innerSchema) {
   const batch = batchFromColumns(Object.fromEntries(a.fields.map((f) => [f.name, [values[f.name] ?? null]])), a);
   return { result: serializeBatch(batch) };
 }
-function overloadContext(req) {
+function overloadContext(req, catalogInterface) {
+  let catalogName = null;
+  if (catalogInterface && req.attach_opaque_data) {
+    try {
+      catalogName = catalogInterface.catalogNameForAttach(req.attach_opaque_data);
+    } catch {
+      catalogName = null;
+    }
+  }
   return {
     arguments: req.arguments,
     inputSchema: req.input_schema,
-    isScalar: String(req.function_type).toLowerCase() === "scalar"
+    isScalar: String(req.function_type).toLowerCase() === "scalar",
+    schemaName: req.schema_name ?? null,
+    catalogName
   };
 }
 function recoverFinalizeState(request, recoverExchangeState) {
@@ -4917,7 +4929,7 @@ var columnOpParams = schema2([
 
 // src/protocol/handlers/function.ts
 function registerFunctionMethods(protocol, config) {
-  const { registry, signingKey } = config;
+  const { registry, signingKey, catalogInterface } = config;
   async function stripAttach(attach, ctx) {
     if (attach == null)
       return null;
@@ -4926,6 +4938,15 @@ function registerFunctionMethods(protocol, config) {
       return env;
     return openAttach(env, ctx?.auth, signingKey);
   }
+  async function strippedContext(bindCall, ctx) {
+    let attach = null;
+    try {
+      attach = await stripAttach(bindCall.attach_opaque_data, ctx);
+    } catch {
+      attach = null;
+    }
+    return overloadContext({ ...bindCall, attach_opaque_data: attach }, catalogInterface);
+  }
   const initHeaderSchema = schema2([
     field2("execution_id", binary2(), false),
     field2("opaque_data", binary2(), true),
@@ -4942,7 +4963,7 @@ function registerFunctionMethods(protocol, config) {
       const innerParams = unwrapRequest(params.request);
       const request = deserializeBindRequest(innerParams);
       request.attach_opaque_data = await stripAttach(request.attach_opaque_data, ctx);
-      const func = registry.get(request.function_name, overloadContext(request));
+      const func = registry.get(request.function_name, overloadContext(request, catalogInterface));
       const response = await func.bind(request);
       const serialized = serializeBindResponse(response);
       return wrapResult(serialized, BindResultSchema);
@@ -4957,7 +4978,7 @@ function registerFunctionMethods(protocol, config) {
       const innerParams = unwrapRequest(params.request);
       const request = deserializeInitRequest(innerParams);
       request.bind_call.attach_opaque_data = await stripAttach(request.bind_call.attach_opaque_data, undefined);
-      const func = registry.get(request.bind_call.function_name, overloadContext(request.bind_call));
+      const func = registry.get(request.bind_call.function_name, overloadContext(request.bind_call, catalogInterface));
       const initResponse = await func.globalInit(request);
       const accumulatedState = recoverFinalizeState(request, config.recoverExchangeState);
       const handlers = func.createStreamHandlers(request, initResponse, accumulatedState);
@@ -4997,7 +5018,7 @@ function registerFunctionMethods(protocol, config) {
         const initRequestBatch = deserializeBatch(state.initRequestIpc);
         const initRequestDict = batchToScalarDict(initRequestBatch);
         const request = deserializeInitRequest(initRequestDict);
-        const func = registry.get(state.functionName, overloadContext(request.bind_call));
+        const func = registry.get(state.functionName, await strippedContext(request.bind_call));
         const executionId = state.executionId;
         const opaqueData = state.opaqueData ?? null;
         const initResponse = {
@@ -5045,7 +5066,7 @@ function registerFunctionMethods(protocol, config) {
     handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
       const request = deserializeCardinalityRequest(innerParams);
-      const func = registry.get(request.bind_call.function_name, overloadContext(request.bind_call));
+      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
       let cardResult;
       if (func.cardinality) {
         cardResult = serializeTableCardinality(await func.cardinality(request));
@@ -5058,10 +5079,10 @@ function registerFunctionMethods(protocol, config) {
   protocol.unary("table_function_statistics", {
     params: REQUEST_PARAMS_SCHEMA,
     result: RESULT_BINARY_NULLABLE_SCHEMA,
-    handler: (params) => {
+    handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
       const request = deserializeCardinalityRequest(innerParams);
-      const func = registry.get(request.bind_call.function_name, overloadContext(request.bind_call));
+      const func = registry.get(request.bind_call.function_name, await strippedContext(request.bind_call));
       if (!func.statistics)
         return { result: null };
       const stats = func.statistics(request);
@@ -5081,7 +5102,7 @@ function registerFunctionMethods(protocol, config) {
       const bindCall = deserializeBindRequest(bindParams);
       const globalExecutionId = toUint8Array(innerParams.global_execution_id);
       const bindOpaqueData = innerParams.bind_opaque_data ? toUint8Array(innerParams.bind_opaque_data) : null;
-      const func = registry.get(bindCall.function_name, overloadContext(bindCall));
+      const func = registry.get(bindCall.function_name, await strippedContext(bindCall));
       const map3 = func.dynamicToString ? await func.dynamicToString({ bindCall, bindOpaqueData, globalExecutionId }) : {};
       const keys = Object.keys(map3);
       const values = keys.map((k) => map3[k] ?? "");
@@ -5259,8 +5280,13 @@ function persistGroupStates(executionId, gids) {
 
 // src/protocol/handlers/aggregate.ts
 function registerAggregateMethods(protocol, registry) {
-  function resolveAggregate(name) {
-    const func = registry.get(name, { arguments: new Arguments, inputSchema: null, isScalar: false });
+  function resolveAggregate(name, schemaName) {
+    const func = registry.get(name, {
+      arguments: new Arguments,
+      inputSchema: null,
+      isScalar: false,
+      schemaName: schemaName ?? null
+    });
     if (!func || func.kind !== "aggregate") {
       throw new Error(`Function '${name}' is not an aggregate function`);
     }
@@ -5272,7 +5298,7 @@ function registerAggregateMethods(protocol, registry) {
     handler: async (params) => {
       const innerParams = unwrapRequest(params.request);
       const functionName = innerParams.function_name;
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const argBytes = toUint8Array(innerParams.arguments);
       const args = deserializeArguments(argBytes);
       const inputSchema = innerParams.input_schema ? deserializeSchema(toUint8Array(innerParams.input_schema)) : null;
@@ -5305,7 +5331,7 @@ function registerAggregateMethods(protocol, registry) {
       const innerParams = unwrapRequest(params.request);
       const functionName = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.input_batch));
       if (!batch || batch.numRows === 0)
         return wrapResult({}, schema2([]));
@@ -5358,7 +5384,7 @@ function registerAggregateMethods(protocol, registry) {
       const innerParams = unwrapRequest(params.request);
       const functionName = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const batch = readSingleBatch(toUint8Array(innerParams.merge_batch));
       if (!batch || batch.numRows === 0)
         return wrapResult({}, schema2([]));
@@ -5403,7 +5429,7 @@ function registerAggregateMethods(protocol, registry) {
       const innerParams = unwrapRequest(params.request);
       const functionName = innerParams.function_name;
       const executionId = toUint8Array(innerParams.execution_id);
-      const cfg = resolveAggregate(functionName);
+      const cfg = resolveAggregate(functionName, innerParams.schema_name ?? null);
       const outputSchema = deserializeSchema(toUint8Array(innerParams.output_schema));
       const gidBatch = readSingleBatch(toUint8Array(innerParams.group_ids_batch));
       const groupIds = [];
@@ -5549,11 +5575,12 @@ function splitLenPrefixed(buf, count) {
 
 // src/protocol/handlers/table-buffering.ts
 function registerTableBufferingMethods(protocol, registry, signingKey) {
-  function resolveBuffering(name) {
+  function resolveBuffering(name, schemaName) {
     const func = registry.get(name, {
       arguments: new Arguments,
       inputSchema: null,
-      isScalar: false
+      isScalar: false,
+      schemaName: schemaName ?? null
     });
     if (!func || func.kind !== "table_buffering") {
       throw new Error(`Function '${name}' is not a table_buffering function`);
@@ -5566,7 +5593,7 @@ function registerTableBufferingMethods(protocol, registry, signingKey) {
     const rawAttach = inner.attach_opaque_data ? toUint8Array(inner.attach_opaque_data) : null;
     const attach = rawAttach && rawAttach.length > 0 ? await openAttach(rawAttach, ctx?.auth, signingKey) : rawAttach;
     const transactionId = inner.transaction_id ? toUint8Array(inner.transaction_id) : null;
-    const func = resolveBuffering(functionName);
+    const func = resolveBuffering(functionName, inner.schema_name ?? null);
     const bound = new BoundStorage(storage, executionId);
     const payload = await bound.stateGet(FrameworkNS.BUFFERING_INIT, BoundStorage.packIntKey(-1));
     if (payload == null) {
@@ -6300,7 +6327,8 @@ function buildVgiProtocol(config) {
   registerFunctionMethods(protocol, {
     registry: config.registry,
     recoverExchangeState: config.recoverExchangeState,
-    signingKey: config.signingKey
+    signingKey: config.signingKey,
+    catalogInterface: config.catalogInterface
   });
   registerAggregateMethods(protocol, config.registry);
   registerTableBufferingMethods(protocol, config.registry, config.signingKey);
@@ -6440,4 +6468,4 @@ export {
   DEFAULT_PORT
 };
 
-//# debugId=FE37A0B1C02E4FCF64756E2164756E21
+//# debugId=21DF07825CC8B15864756E2164756E21