@query-farm/vgi 0.20.0 → 0.22.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

@@ -639,6 +639,7 @@ __export(exports_impl_arrowjs, {
   batchFromRows: () => batchFromRows,
   batchFromColumns: () => batchFromColumns,
   backend: () => backend,
+  adoptArrowJsShape: () => adoptArrowJsShape,
   UnionMode: () => UnionMode,
   TimeUnit: () => TimeUnit,
   IntervalUnit: () => IntervalUnit,
@@ -2275,6 +2276,9 @@ function assemble(columnNames, minData, maxData, hasNull, hasNotNull, distinctCo
 
 // src/arrow/impl-arrowjs/index.ts
 var backend = { name: "arrow-js" };
+function adoptArrowJsShape(batch) {
+  return batch;
+}
 // src/arrow/schema-types.ts
 var { TimeUnit: TimeUnit2, DateUnit: DateUnit3, IntervalUnit: IntervalUnit2, UnionMode: UnionMode2, schema: schema2 } = exports_impl_arrowjs;
 function field2(name, type, nullable, metadata) {
@@ -3025,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),
@@ -3093,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)
   };
@@ -3918,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) {
@@ -4913,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;
@@ -4922,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),
@@ -4938,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);
@@ -4953,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);
@@ -4983,6 +5008,7 @@ function registerFunctionMethods(protocol, config) {
       return state;
     },
     exchange: async (state, input, out) => {
+      input = adoptArrowJsShape(input);
       let handlers;
       let handlerState;
       if (state._handlers) {
@@ -4992,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 = {
@@ -5040,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));
@@ -5053,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);
@@ -5076,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] ?? "");
@@ -6295,7 +6321,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);
@@ -6435,4 +6462,4 @@ export {
   DEFAULT_PORT
 };
 
-//# debugId=51AA40F4C2F8087064756E2164756E21
+//# debugId=BAA2DFC0A0256E9E64756E2164756E21