@query-farm/vgi 0.43.0 → 0.44.0

package/dist/worker-cf-entry.js

@@ -1,4 +1,27 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -1978,6 +2001,11 @@ var init_arrow = __esm(() => {
 });
 
 // src/functions/storage-cf-do.ts
+var exports_storage_cf_do = {};
+__export(exports_storage_cf_do, {
+  FunctionStorageCfDo: () => FunctionStorageCfDo
+});
+
 class FunctionStorageCfDo {
   _baseUrl;
   _token;
@@ -2423,7 +2451,7 @@ function resolveStorageFromEnv() {
     return new FunctionStorageSqlite;
   }
   if (backend === "cloudflare-do") {
-    init_storage_cf_do();
+    const { FunctionStorageCfDo } = (init_storage_cf_do(), __toCommonJS(exports_storage_cf_do));
     return FunctionStorageCfDo.fromEnv();
   }
   throw new Error(`Unknown VGI_WORKER_SHARED_STORAGE backend: '${backend}'. Supported: 'memory', 'sqlite', 'cloudflare-do'.`);
@@ -4138,6 +4166,135 @@ var VGI_RANGE_KEY = "vgi_range";
 var VGI_PATTERN_KEY = "vgi_pattern";
 var DEFAULT_MAX_WORKERS = 99999;
 
+// src/codec/conform.ts
+init_arrow();
+var OPTIONAL_ITEM_FIELDS = new Set(["argument_names"]);
+function children(type) {
+  return type.children ?? [];
+}
+function mapValueType(type) {
+  const entries = children(type)[0].type;
+  return children(entries)[1].type;
+}
+function mapPairs(raw) {
+  if (Array.isArray(raw))
+    return raw.map((e) => Array.isArray(e) ? [e[0], e[1]] : [e?.key, e?.value]);
+  if (raw instanceof Map)
+    return Array.from(raw.entries());
+  if (typeof raw[Symbol.iterator] === "function")
+    return Array.from(raw);
+  return Object.entries(raw);
+}
+function zeroValue(type) {
+  if (isUtf8(type) || isDictionary(type))
+    return "";
+  if (isBinary(type))
+    return new Uint8Array(0);
+  if (isBool(type))
+    return false;
+  if (isInt(type))
+    return type.bitWidth === 64 ? 0n : 0;
+  if (isFloat(type))
+    return 0;
+  if (isList(type) || isMap(type))
+    return [];
+  if (isStruct(type)) {
+    const out = {};
+    for (const c of children(type))
+      out[c.name] = c.nullable ? null : conformValue(c.type, undefined, false, c.name);
+    return out;
+  }
+  return null;
+}
+var HAS_CONTAINER = new WeakMap;
+function hasContainer(type) {
+  const cached = HAS_CONTAINER.get(type);
+  if (cached !== undefined)
+    return cached;
+  let has = isList(type) || isMap(type);
+  if (!has && isStruct(type))
+    has = children(type).some((c) => hasContainer(c.type));
+  HAS_CONTAINER.set(type, has);
+  return has;
+}
+function conformValue(type, value, nullable, name) {
+  if (value == null) {
+    if (nullable)
+      return value ?? null;
+    if (isList(type) || isMap(type))
+      return [];
+    return value;
+  }
+  if (!hasContainer(type))
+    return value;
+  if (isList(type)) {
+    const itemType = children(type)[0].type;
+    const itemsNullable = OPTIONAL_ITEM_FIELDS.has(name);
+    const items = Array.isArray(value) ? value : Array.from(value);
+    let changed = !Array.isArray(value);
+    const out = items.map((item) => {
+      const next = item == null && !itemsNullable ? zeroValue(itemType) : conformValue(itemType, item, true, name);
+      if (next !== item)
+        changed = true;
+      return next;
+    });
+    return changed ? out : value;
+  }
+  if (isMap(type)) {
+    const valueType = mapValueType(type);
+    const pairs = mapPairs(value);
+    let changed = false;
+    const out = pairs.map(([k, v]) => {
+      const next = v == null ? zeroValue(valueType) : conformValue(valueType, v, true, name);
+      if (next !== v)
+        changed = true;
+      return [k, next];
+    });
+    return changed ? out : value;
+  }
+  if (isStruct(type)) {
+    let out = null;
+    for (const c of children(type)) {
+      const v = value[c.name];
+      const next = conformValue(c.type, v, c.nullable, c.name);
+      if (next !== v) {
+        (out ??= { ...value })[c.name] = next;
+      }
+    }
+    return out ?? value;
+  }
+  return value;
+}
+function conformRecord(schema, obj) {
+  let out = null;
+  for (const f of schema.fields) {
+    const v = obj[f.name];
+    const next = conformValue(f.type, v, f.nullable, f.name);
+    if (next !== v) {
+      (out ??= { ...obj })[f.name] = next;
+    }
+  }
+  return out ?? obj;
+}
+function conformColumns(schema, columns) {
+  let out = null;
+  for (const f of schema.fields) {
+    const col = columns[f.name];
+    const rows = col ?? [undefined];
+    let changed = col === undefined;
+    const next = rows.map((v) => {
+      const c = conformValue(f.type, v, f.nullable, f.name);
+      if (c !== v)
+        changed = true;
+      return c;
+    });
+    if (changed) {
+      (out ??= { ...columns })[f.name] = next;
+    }
+  }
+  return out ?? columns;
+}
+
 // src/protocol/serializers/shared.ts
 function toUint8Array2(val) {
   if (typeof val === "string")
@@ -6953,7 +7110,8 @@ function normalizeRequestSchemaPaths(params) {
 }
 function wrapResult(values, innerSchema) {
   const a = innerSchema;
-  const batch = batchFromColumns(Object.fromEntries(a.fields.map((f) => [f.name, [values[f.name] ?? null]])), a);
+  const row = conformRecord(a, values);
+  const batch = batchFromColumns(Object.fromEntries(a.fields.map((f) => [f.name, [row[f.name] ?? null]])), a);
   return { result: serializeBatch(batch) };
 }
 function overloadContext(req, catalogInterface) {
@@ -6979,9 +7137,12 @@ init_arrow();
 
 // src/errors.ts
 class VgiError extends Error {
-  constructor(message) {
+  errorCode;
+  constructor(message, code) {
     super(message);
     this.name = "VgiError";
+    if (code !== undefined)
+      this.errorCode = code;
   }
 }
 
@@ -6994,27 +7155,27 @@ class RowCountMismatchError extends VgiError {
 
 class FunctionNotFoundError extends VgiError {
   constructor(name, available) {
-    super(`Unknown function '${name}'`);
+    super(`Unknown function '${name}'`, "NOT_FOUND");
     this.name = "FunctionNotFoundError";
   }
 }
 
 class CatalogReadOnlyError extends VgiError {
   constructor(operation) {
-    super(`catalog is read-only: ${operation} is not supported`);
+    super(`catalog is read-only: ${operation} is not supported`, "FAILED_PRECONDITION");
     this.name = "CatalogReadOnlyError";
   }
 }
 class ArgumentValidationError extends VgiError {
   constructor(message) {
-    super(message);
+    super(message, "INVALID_ARGUMENT");
     this.name = "ArgumentValidationError";
   }
 }
 
 class NoCatalogError extends VgiError {
   constructor() {
-    super("No catalog is configured for this worker");
+    super("No catalog is configured for this worker", "UNIMPLEMENTED");
     this.name = "NoCatalogError";
   }
 }
@@ -9111,7 +9272,7 @@ function hex(buf) {
 // src/codec/asd.ts
 init_arrow();
 function encodeASD(schema, obj) {
-  return serializeBatch(batchFromRows([sortMapsForSchema(schema, obj)], schema));
+  return serializeBatch(batchFromRows([sortMapsForSchema(schema, conformRecord(schema, obj))], schema));
 }
 function compareCodePoints(a, b) {
   const n = Math.min(a.length, b.length);
@@ -9128,7 +9289,7 @@ function compareCodePoints(a, b) {
   }
   return a.length - b.length;
 }
-function mapPairs(raw) {
+function mapPairs2(raw) {
   if (Array.isArray(raw))
     return raw.map((e) => Array.isArray(e) ? [e[0], e[1]] : [e?.key, e?.value]);
   if (raw instanceof Map)
@@ -9163,7 +9324,7 @@ function sortMapsForType(type, value) {
   if (isMap(type)) {
     const entries = type.children[0].type;
     const valueType = entries.children[1].type;
-    return mapPairs(value).map(([k, v]) => [k, sortMapsForType(valueType, v)]).sort((x, y) => compareKeys(x[0], y[0]));
+    return mapPairs2(value).map(([k, v]) => [k, sortMapsForType(valueType, v)]).sort((x, y) => compareKeys(x[0], y[0]));
   }
   if (isList(type)) {
     const child = type.children[0].type;
@@ -9421,12 +9582,12 @@ var encodeAttachCatalogInfo = (v) => encodeASD(AttachCatalogInfoSchema, {
   secret_ref: v.secret_ref ?? ""
 });
 function encodeScanFunctionResult(functionName, argumentsBytes, requiredExtensions = [], schemaPath = null) {
-  return serializeBatch(batchFromColumns({
+  return serializeBatch(batchFromColumns(conformColumns(ScanFunctionResultSchema, {
     function_name: [functionName],
     arguments: [argumentsBytes],
     required_extensions: [requiredExtensions],
     schema_path: [schemaPath]
-  }, ScanFunctionResultSchema));
+  }), ScanFunctionResultSchema));
 }
 function singleBranchResult(legacy) {
   return {
@@ -9441,7 +9602,7 @@ function singleBranchResult(legacy) {
   };
 }
 function encodeScanBranch(cols) {
-  return serializeBatch(batchFromColumns({
+  return serializeBatch(batchFromColumns(conformColumns(ScanBranchSchema, {
     function_name: [cols.function_name],
     arguments: [cols.arguments],
     branch_filter: [cols.branch_filter ?? null],
@@ -9453,7 +9614,7 @@ function encodeScanBranch(cols) {
     format_locations: [cols.format_locations ?? null],
     format_options: [cols.format_options ?? null],
     schema_path: [cols.schema_path ?? null]
-  }, ScanBranchSchema));
+  }), ScanBranchSchema));
 }
 function isPromise(v) {
   return v != null && typeof v.then === "function";
@@ -9762,7 +9923,7 @@ async function checkReservedAttachOptions(catalog) {
 var ATTACH_TICKET_PREFIX = "vgia1.";
 var ATTACH_TICKET_OPTION = RESERVED_ATTACH_OPTION;
 var ATTACH_TICKETS_PROTOCOL_NAME = "vgi.attach_tickets.v1";
-var ATTACH_TICKETS_PROTOCOL_VERSION = "1.0.0";
+var ATTACH_TICKETS_PROTOCOL_VERSION = "2.0.0";
 var TICKET_ENVELOPE_VERSION = 1;
 var MAX_OPTIONS_BYTES = 16 * 1024;
 var MAX_TICKET_CHARS = 32 * 1024;
@@ -10037,8 +10198,19 @@ var SEAL_ATTACH_REQUEST_SCHEMA = schema2([
 ]);
 var ATTACH_TICKET_SCHEMA = schema2([
   field2("ticket", utf82(), false),
-  field2("expires_at", float642(), false)
+  field2("expires_at", timestamp2(TimeUnit2.MICROSECOND, "UTC"), true)
 ]);
+function expiresAtMicros(value) {
+  if (value === null)
+    return null;
+  const ms = value.getTime();
+  if (!Number.isFinite(ms))
+    throw new TypeError("AttachTicket.expires_at must be a valid Date or null");
+  return BigInt(ms) * 1000n;
+}
+function encodeAttachTicket(ticket) {
+  return serializeBatch(batchFromColumns({ ticket: [ticket.ticket], expires_at: [expiresAtMicros(ticket.expires_at)] }, ATTACH_TICKET_SCHEMA));
+}
 function resolveTicketMaxTtl(grantKeys, env) {
   if (grantKeys)
     return Math.trunc(grantKeys.maxTtlSeconds);
@@ -10125,7 +10297,7 @@ async function sealAttach2(config, request, auth) {
   } catch (e) {
     throw new AttachTicketRequestError("seal_attach request is invalid", [["request", e.message]]);
   }
-  return { ticket: token, expires_at: expiresAt === 0 ? Number.POSITIVE_INFINITY : expiresAt };
+  return { ticket: token, expires_at: expiresAt === 0 ? null : new Date(expiresAt * 1000) };
 }
 function buildAttachTicketsProtocol(config) {
   const p = new Protocol2(ATTACH_TICKETS_PROTOCOL_NAME, { protocolVersion: ATTACH_TICKETS_PROTOCOL_VERSION });
@@ -10136,8 +10308,7 @@ function buildAttachTicketsProtocol(config) {
     handler: async (params, ctx) => {
       const request = unwrapRequest(params.request);
       const sealed = await sealAttach2(config, request, ctx?.auth);
-      const batch = batchFromColumns({ ticket: [sealed.ticket], expires_at: [sealed.expires_at] }, ATTACH_TICKET_SCHEMA);
-      return { result: serializeBatch(batch) };
+      return { result: encodeAttachTicket(sealed) };
     }
   });
   return p;
@@ -10664,7 +10835,7 @@ function validatedHostedProtocols(hosting, primary) {
     }
     const name = p.name;
     if (name.startsWith(RESERVED_PREFIX)) {
-      throw new Error(`${owner} entry ${index} is named '${name}', which claims the reserved '${RESERVED_PREFIX}' prefix. ` + "Framework protocols are not supplied through this hook: reflection is hosted automatically, and " + "vgi_rpc.Identity.v1 is enabled by supplying resolveToken and/or mintGrant.");
+      throw new Error(`${owner} entry ${index} is named '${name}', which claims the reserved '${RESERVED_PREFIX}' prefix. ` + "Framework protocols are not supplied through this hook: reflection is hosted automatically, and " + "vgi_rpc.Identity.v2 is enabled by supplying resolveToken and/or mintGrant.");
     }
     if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(name)) {
       throw new Error(`${owner} entry ${index}: protocol name '${name}' is not an identifier, optionally dot-qualified ` + "(e.g. 'acme.Reports.v1').");
@@ -10714,7 +10885,7 @@ function resolveIntrospectPrincipals(explicit, env) {
     principals = raw.split(",").map((p) => p.trim()).filter((p) => p !== "");
   }
   if (principals.length === 0) {
-    throw new Error("This worker supplies resolveToken, which hosts the vgi_rpc.Identity.v1 protocol, but no " + `introspector allowlist was configured. Set ${INTROSPECT_PRINCIPALS_ENV} (comma-separated) or pass ` + `introspectPrincipals.
+    throw new Error("This worker supplies resolveToken, which hosts the vgi_rpc.Identity.v2 protocol, but no " + `introspector allowlist was configured. Set ${INTROSPECT_PRINCIPALS_ENV} (comma-separated) or pass ` + `introspectPrincipals.
 
 ` + "There is no permissive default on purpose: introspection is a separate capability from " + "authentication, and allowing every authenticated caller lets any user resolve any other user's " + "credential to its owner. Remove resolveToken to leave the protocol unhosted entirely.");
   }
@@ -12000,7 +12171,7 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
   }
   attach(name, options, dataVersionSpec, implementationVersion) {
     if (!this.catalogs().includes(name)) {
-      throw new Error(`No worker handles catalog '${name}'`);
+      throw new VgiError(`No worker handles catalog '${name}'`, "NOT_FOUND");
     }
     validateRequiredAttachOptions(name, this.attachOptionSpecs(name), options ?? {});
     const attachOpaqueData = new Uint8Array(16);
@@ -12400,11 +12571,11 @@ class ReadOnlyCatalogInterface extends CatalogInterface {
     validateAtParams(atUnit, atValue);
     const schema = this._descriptor.schemas.find((s) => schemaPathsEqual(schemaDescriptorPath(s), schemaPath));
     if (!schema || !schema.tables) {
-      throw new Error(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`);
+      throw new VgiError(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`, "NOT_FOUND");
     }
     const table = schema.tables.find((t) => t.name === name);
     if (!table) {
-      throw new Error(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`);
+      throw new VgiError(`Table '${name}' not found in schema ${schemaPathDisplay(schemaPath)}`, "NOT_FOUND");
     }
     if (atUnit && !table.supportsTimeTravel) {
       throw new Error(`Table ${schemaPathDisplay(schemaPath)}.${name} does not support time travel queries`);
@@ -12489,12 +12660,12 @@ function resolveIndexGroups(schema, groups) {
 function serializeForeignKeys(fks, schemaPath) {
   if (!fks || fks.length === 0)
     return [];
-  return fks.map((fk) => serializeBatch(batchFromColumns({
+  return fks.map((fk) => serializeBatch(batchFromColumns(conformColumns(ForeignKeyInfoSchema, {
     fk_columns: [fk.columns],
     pk_columns: [fk.referencedColumns],
     referenced_table: [fk.referencedTable],
     referenced_schema_path: [fk.referencedSchemaPath ?? schemaPath ?? ["main"]]
-  }, ForeignKeyInfoSchema)));
+  }), ForeignKeyInfoSchema)));
 }
 function defaultToSql(value) {
   if (value === null || value === undefined)
@@ -12634,7 +12805,7 @@ function serializeArgsBatch(args, argSpecSchema) {
 }
 function validateAtParams(atUnit, atValue) {
   if (Boolean(atUnit) !== Boolean(atValue)) {
-    throw new Error("at_unit and at_value must both be provided or both be absent");
+    throw new VgiError("at_unit and at_value must both be provided or both be absent", "INVALID_ARGUMENT");
   }
 }
 function inferScalarType(val) {
@@ -12732,7 +12903,7 @@ class CompositeCatalogInterface extends CatalogInterface {
         return result;
       }
     }
-    throw new Error(`No worker handles catalog '${name}'`);
+    throw new VgiError(`No worker handles catalog '${name}'`, "NOT_FOUND");
   }
   async detach(attachOpaqueData) {
     await this._route(attachOpaqueData).detach(attachOpaqueData);
@@ -13056,7 +13227,7 @@ class FunctionRegistry {
       } else if (candidates && candidates.length > 0) {
         const schemas = this.schemasFor(name);
         if (schemas.length > 0) {
-          throw new Error(`Function '${name}' is not registered in schema ${schemaPathDisplay(schemaPath)}. ` + `It is available in: [${schemas.map(schemaPathDisplay).join(", ")}]`);
+          throw new VgiError(`Function '${name}' is not registered in schema ${schemaPathDisplay(schemaPath)}. ` + `It is available in: [${schemas.map(schemaPathDisplay).join(", ")}]`, "NOT_FOUND");
         }
       }
     }
@@ -13277,4 +13448,4 @@ export {
   utf82 as utf8
 };
 
-//# debugId=D9B447159663895D64756E2164756E21
+//# debugId=FC599621AC5B851964756E2164756E21