@query-farm/vgi 0.21.0 → 0.23.0

package/src/protocol/handlers/table-buffering.ts

@@ -43,11 +43,19 @@ export function registerTableBufferingMethods(
   registry: FunctionRegistry,
   signingKey?: Uint8Array,
 ): void {
-  function resolveBuffering(name: string): TableBufferingVgiFunction {
+  // `schemaName` scopes resolution to the schema the caller named. The
+  // buffering process/combine RPCs carry it (protocol 1.2.0), so a name
+  // declared in two schemas resolves to the one the request names rather than
+  // colliding on the flat by-name index. `null` keeps the cross-schema lookup.
+  function resolveBuffering(
+    name: string,
+    schemaName?: string | null,
+  ): TableBufferingVgiFunction {
     const func = registry.get(name, {
       arguments: new Arguments(),
       inputSchema: null,
       isScalar: false,
+      schemaName: schemaName ?? null,
     }) as any;
     if (!func || func.kind !== "table_buffering") {
       throw new Error(`Function '${name}' is not a table_buffering function`);
@@ -75,7 +83,7 @@ export function registerTableBufferingMethods(
         : 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(defaultStorage, executionId);
     const payload = await bound.stateGet(
       FrameworkNS.BUFFERING_INIT,

package/src/protocol/serializers/bind.ts

@@ -30,6 +30,10 @@ const BIND_REQUEST_SCHEMA = schema([
   // Both null when the scan has no AT clause. See BindRequest.at_unit.
   field("at_unit", utf8(), true),
   field("at_value", utf8(), true),
+  // Catalog schema owning the function. A worker may register one name in
+  // several schemas, so the bare name is not a unique key — resolution is by
+  // (schema_name, function_name). Null for callers with no catalog context.
+  field("schema_name", utf8(), true),
 ]);
 
 // COPY ... FROM context — a nullable nested struct<format, file_path,
@@ -76,6 +80,7 @@ export function serializeBindRequest(req: BindRequest): VgiBatch {
     resolved_secrets_provided: req.resolved_secrets_provided ?? false,
     at_unit: req.at_unit ?? null,
     at_value: req.at_value ?? null,
+    schema_name: req.schema_name ?? null,
   };
   // Append the copy_from / copy_to struct columns only for COPY scans/sinks, so
   // non-COPY binds serialize to the exact legacy shape (fields matched by name
@@ -172,6 +177,8 @@ export function deserializeBindRequest(
     // Empty string -> null (matches the C++ BuildBindRequest convention).
     at_unit: params.at_unit ? String(params.at_unit) : null,
     at_value: params.at_value ? String(params.at_value) : null,
+    // Empty string -> null, same convention as at_unit/at_value.
+    schema_name: params.schema_name ? String(params.schema_name) : null,
     // COPY ... FROM context — absent for ordinary scans (params.copy_from
     // undefined -> null). The struct column decodes to a plain object.
     copy_from: parseCopyFromContext(params.copy_from),

package/src/protocol/types.ts

@@ -88,6 +88,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 {

package/src/worker.ts

@@ -65,6 +65,14 @@ export interface WorkerConfig {
   /** Factory that receives the built ReadOnlyCatalogInterface and returns a custom catalog. */
   catalogInterfaceFactory?: (base: ReadOnlyCatalogInterface) => CatalogInterface;
   catalogName?: string;
+  /**
+   * Registry to dispatch through. Pass the same instance used to build a
+   * pre-constructed `catalogInterface` — catalogs record which schema (and
+   * catalog) declares each function on the registry they are given, and
+   * schema-qualified resolution only works if that is the registry the worker
+   * dispatches on. Omit to have the worker create its own.
+   */
+  registry?: FunctionRegistry;
 }
 
 export class Worker {
@@ -73,7 +81,10 @@ export class Worker {
   private _catalogName?: string;
 
   constructor(config: WorkerConfig) {
-    this._registry = new FunctionRegistry();
+    // Reuse the caller's registry when given: a catalogInterface built
+    // elsewhere recorded its per-schema function ownership there, and that
+    // index is what makes a schema-qualified bind resolve correctly.
+    this._registry = config.registry ?? new FunctionRegistry();
     this._catalogName = config.catalogName;
 
     // Register explicit functions
@@ -89,6 +100,9 @@ export class Worker {
         if (schema.functions) {
           for (const func of schema.functions) {
             this._registry.register(func);
+            // Also index by owning schema + catalog so a schema-qualified bind
+            // resolves when one name is declared in more than one schema.
+            this._registry.registerInSchema(func, schema.name, config.catalog.name);
           }
         }
       }