@sixb/core 0.1.2 → 0.1.4

package/dist/{chunk-nnyp53zt.js → chunk-7gw7mepb.js}

@@ -4,11 +4,18 @@ import {
   ObjectQueryPlanningError,
   ObjectQueryValidationError,
   normalizeObjectQuery
-} from "./chunk-88ppkr54.js";
+} from "./chunk-rte5sm3z.js";
 import {
   compareQueryScalarValues,
+  linkBatchKey,
+  objectBatchKey,
+  objectLinkCursor,
   queryScalarValuesEqual
-} from "./chunk-6wetht33.js";
+} from "./chunk-1wk20wn3.js";
+import {
+  assertAuthorized,
+  isAllowed
+} from "./chunk-f83ka50g.js";
 import {
   validatePropertyValue,
   validateSchemaValue
@@ -20,12 +27,13 @@ import {
   formatUnknownObjectTypeMessage
 } from "./chunk-dktq02ne.js";
 import {
-  assertAuthorized
-} from "./chunk-34bqh420.js";
+  stableJsonStringify
+} from "./chunk-t8t39h7v.js";
 // src/objects/query/planner.ts
 var DEFAULT_MAX_FALLBACK_ROWS = 1000;
 var fallbackNodeKinds = new Set([
   "start",
+  "refs",
   "filter",
   "sort",
   "limit",
@@ -122,6 +130,8 @@ function collectNodeProviderIssues(query, path, capabilities, issues) {
         addIssue(issues, path, "include_subtypes_not_supported", "Provider does not support start.includeSubtypes expansion");
       }
       return;
+    case "refs":
+      return;
     case "filter":
       collectPredicateProviderIssues(query.predicate, `${path}.predicate`, capabilities, issues);
       collectNodeProviderIssues(query.input, `${path}.input`, capabilities, issues);
@@ -269,6 +279,7 @@ function collectFallbackNodeIssues(query, path, issues) {
   }
   switch (query.kind) {
     case "start":
+    case "refs":
       return;
     case "filter":
     case "limit":
@@ -301,6 +312,7 @@ function hasExplicitResultBound(query) {
   switch (query.kind) {
     case "limit":
     case "page":
+    case "refs":
       return true;
     case "start":
       return false;
@@ -317,6 +329,7 @@ function addIssue(issues, path, code, message) {
 // src/objects/query/validate.ts
 var DEFAULT_MAX_LIMIT = 1000;
 var DEFAULT_MAX_PAGE_SIZE = 1000;
+var DEFAULT_MAX_REFS = 1000;
 function validateObjectQuery(query, options) {
   const normalized = options.normalize === false ? query : normalizeObjectQuery(query);
   const ctx = createValidationContext(options);
@@ -345,6 +358,7 @@ function createValidationContext(options) {
     valueTypesById: options.ontology.getValueTypesById(),
     maxLimit: options.maxLimit ?? DEFAULT_MAX_LIMIT,
     maxPageSize: options.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE,
+    maxRefs: options.maxRefs ?? DEFAULT_MAX_REFS,
     issues: [],
     touchedObjectTypeIds: new Set
   };
@@ -360,6 +374,8 @@ function dispatchQueryNode(query, path, ctx) {
   switch (query.kind) {
     case "start":
       return validateStart(query.objectTypeId, query.includeSubtypes, path, ctx);
+    case "refs":
+      return validateRefs(query.refs, path, ctx);
     case "filter": {
       const input = validateQueryNode(query.input, `${path}.input`, ctx);
       const predicate = validatePredicate(query.predicate, input.result, `${path}.predicate`, ctx);
@@ -419,6 +435,32 @@ function dispatchQueryNode(query, path, ctx) {
     }
   }
 }
+function validateRefs(refs, path, ctx) {
+  if (refs.length === 0) {
+    addIssue2(ctx, `${path}.refs`, "empty_refs", "refs must include at least one object reference");
+  }
+  if (refs.length > ctx.maxRefs) {
+    addIssue2(ctx, `${path}.refs`, "too_many_refs", `refs must include at most ${ctx.maxRefs} object references`);
+  }
+  const objectTypeIds = new Set;
+  refs.forEach((ref, index) => {
+    const refPath = `${path}.refs[${index}]`;
+    if (!ref.objectTypeId) {
+      addIssue2(ctx, `${refPath}.objectTypeId`, "missing_object_type", "objectTypeId is required");
+    } else if (!ctx.ontology.getObjectTypeById(ref.objectTypeId)) {
+      addIssue2(ctx, `${refPath}.objectTypeId`, "unknown_object_type", formatUnknownObjectTypeMessage(ref.objectTypeId));
+    } else {
+      objectTypeIds.add(ref.objectTypeId);
+    }
+    if (!ref.primaryId) {
+      addIssue2(ctx, `${refPath}.primaryId`, "missing_primary_id", "primaryId is required");
+    }
+  });
+  return {
+    result: { objectTypeIds: [...objectTypeIds] },
+    query: { kind: "refs", refs: refs.map((ref) => ({ ...ref })) }
+  };
+}
 function validateStart(objectTypeId, includeSubtypes, path, ctx) {
   if (!objectTypeId) {
     addIssue2(ctx, path, "missing_object_type", "start.objectTypeId is required");
@@ -984,6 +1026,7 @@ async function executeObjectQuery(input, options) {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
     normalize: false
   });
   assertQueryViewable(validated, options);
@@ -1036,6 +1079,7 @@ async function countObjects(input, options) {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
     normalize: false
   });
   assertQueryViewable(validated, options);
@@ -1089,6 +1133,7 @@ async function existsObjects(input, options) {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
     normalize: false
   });
   assertQueryViewable(validated, options);
@@ -1142,6 +1187,7 @@ async function facetObjects(input, options) {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
     normalize: false
   });
   assertQueryViewable(validated, options);
@@ -1222,6 +1268,7 @@ function resolveExpansions(query, ctx) {
       };
     }
     case "start":
+    case "refs":
       return query;
     case "set":
       return {
@@ -1305,6 +1352,8 @@ function expandIncludeSubtypes(query, ontology) {
         inputs: objectTypeIds.map((objectTypeId) => ({ kind: "start", objectTypeId }))
       };
     }
+    case "refs":
+      return query;
     case "filter":
     case "text":
     case "vector":
@@ -1336,6 +1385,8 @@ async function evaluateFallbackQuery(projectId, query, options, maxRows) {
   switch (query.kind) {
     case "start":
       return evaluateFallbackStart(projectId, query, options, maxRows);
+    case "refs":
+      return evaluateFallbackRefs(projectId, query, options);
     case "filter": {
       const input = await evaluateFallbackQuery(projectId, query.input, options, maxRows);
       return completeFallbackEvaluation(input.entries.filter((entry) => matchesPredicate(entry.row, query.predicate)));
@@ -1397,6 +1448,16 @@ async function evaluateFallbackQuery(projectId, query, options, maxRows) {
       throw new ObjectQueryExecutionError("fallback_node_not_supported", `Fallback execution does not support query node '${query.kind}'`);
   }
 }
+async function evaluateFallbackRefs(projectId, query, options) {
+  const rows = await options.storage.getByPrimaryIdBatch({
+    projectId,
+    items: query.refs
+  });
+  return completeFallbackEvaluation(query.refs.flatMap((ref, order) => {
+    const row = rows.get(objectBatchKey(ref.objectTypeId, ref.primaryId));
+    return row ? [{ row, order }] : [];
+  }));
+}
 async function hydrateExpansions(projectId, parents, expansions, options) {
   if (expansions.length === 0) {
     return parents.map((parent) => ({ ...parent }));
@@ -1436,7 +1497,7 @@ async function collectOutgoingEdges(projectId, parents, expansion, options) {
     }))
   });
   return parents.map((parent) => {
-    const links = linksByKey.get(`${parent.objectTypeId}:${parent.primaryId}:${expansion.linkId}`);
+    const links = linksByKey.get(linkBatchKey(parent.objectTypeId, parent.primaryId, expansion.linkId));
     if (!links)
       return [];
     return links.map((link) => ({
@@ -1572,7 +1633,7 @@ function toLinkValue(rows, cardinality) {
   return rows;
 }
 function targetKey(objectTypeId, id) {
-  return `${objectTypeId}:${id}`;
+  return objectBatchKey(objectTypeId, id);
 }
 async function evaluateFallbackStart(projectId, query, options, maxRows) {
   const objectTypeIds = query.includeSubtypes ? [query.objectTypeId, ...options.ontology.listSubTypes(query.objectTypeId)] : [query.objectTypeId];
@@ -1769,7 +1830,7 @@ function facetValueSortKey(value) {
   return JSON.stringify(value) ?? String(value);
 }
 function rowIdentityKey(row) {
-  return `${row.objectTypeId}:${row.primaryId}`;
+  return objectBatchKey(row.objectTypeId, row.primaryId);
 }
 function encodePageOffset(offset) {
   return `${PAGE_TOKEN_PREFIX}${offset}`;
@@ -1796,12 +1857,14 @@ function explainObjectQuery(query, options = {}) {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
     normalize: false
   }) : [];
   const result = options.ontology && issues.length === 0 ? validateObjectQuery(normalizedQuery, {
     ontology: options.ontology,
     maxLimit: options.maxLimit,
     maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
     normalize: false
   }).result : undefined;
   return {
@@ -1826,6 +1889,14 @@ function buildExplainNode(query, path) {
         },
         children: []
       };
+    case "refs":
+      return {
+        path,
+        kind: query.kind,
+        summary: `refs ${query.refs.length}`,
+        details: { refs: query.refs },
+        children: []
+      };
     case "filter":
       return {
         path,
@@ -1943,6 +2014,185 @@ function summarizeSortField(field) {
     return `relevance ${field.direction ?? "desc"}`;
   return `${field.propertyId} ${field.direction ?? "asc"}`;
 }
-export { planObjectQuery, validateObjectQuery, collectObjectQueryValidationIssues, resolveObjectQueryResultShape, executeObjectQuery, countObjects, existsObjects, facetObjects, explainObjectQuery };
+// src/objects/query/links.ts
+import { createHash } from "crypto";
+var MAX_LINK_QUERY_OBJECTS = 1000;
+var MAX_LINK_PAGE_SIZE = 1000;
+var DEFAULT_LINK_PAGE_SIZE = 100;
+var LINK_PAGE_TOKEN_PREFIX = "link:v1:";
+async function executeObjectQueryLinks(input, options) {
+  const direction = input.direction ?? "both";
+  if (direction !== "outgoing" && direction !== "incoming" && direction !== "both") {
+    throw new ObjectQueryExecutionError("invalid_link_direction", "direction must be 'outgoing', 'incoming', or 'both'", "$.direction");
+  }
+  if (input.linkId !== undefined && input.linkId.length === 0) {
+    throw new ObjectQueryExecutionError("invalid_link_id", "linkId must not be empty", "$.linkId");
+  }
+  const pageSize = input.pageSize ?? DEFAULT_LINK_PAGE_SIZE;
+  if (!Number.isInteger(pageSize) || pageSize <= 0 || pageSize > MAX_LINK_PAGE_SIZE) {
+    throw new ObjectQueryExecutionError("invalid_link_page_size", `pageSize must be an integer between 1 and ${MAX_LINK_PAGE_SIZE}`, "$.pageSize");
+  }
+  const validated = validateObjectQuery(normalizeObjectQuery(input.query), {
+    ontology: options.ontology,
+    maxLimit: options.maxLimit,
+    maxPageSize: options.maxPageSize,
+    maxRefs: options.maxRefs,
+    normalize: false
+  });
+  assertLinkSelectorShape(validated.query);
+  const selectorQuery = validated.query;
+  const pageScope = linkPageScope(input.projectId, selectorQuery, direction, input.linkId);
+  const cursor = decodeLinkPageToken(input.pageToken, pageScope);
+  const boundedSelector = selectorQuery.kind === "page" ? selectorQuery : { kind: "limit", limit: MAX_LINK_QUERY_OBJECTS + 1, input: selectorQuery };
+  const selection = await executeObjectQuery({
+    projectId: input.projectId,
+    query: boundedSelector,
+    includeTotal: false
+  }, {
+    ...options,
+    maxLimit: Math.max(options.maxLimit ?? 1000, MAX_LINK_QUERY_OBJECTS + 1)
+  });
+  if (selection.objects.length > MAX_LINK_QUERY_OBJECTS) {
+    throw new ObjectQueryExecutionError("link_query_object_limit_exceeded", `Link query selected more than ${MAX_LINK_QUERY_OBJECTS} objects; add a limit or page node`, "$.query");
+  }
+  const selected = selection.objects;
+  if (selected.length === 0) {
+    return { objects: [], links: [], hasMore: false };
+  }
+  const endpointObjectTypeIds = visibleEndpointTypeIds(options);
+  const page = await options.storage.queryLinks({
+    projectId: input.projectId,
+    objectRefs: selected.map((row) => ({
+      objectTypeId: row.objectTypeId,
+      primaryId: row.primaryId
+    })),
+    direction,
+    ...input.linkId === undefined ? {} : { linkId: input.linkId },
+    ...endpointObjectTypeIds === undefined ? {} : { endpointObjectTypeIds },
+    ...cursor === undefined ? {} : { after: cursor },
+    limit: pageSize
+  });
+  const lastLink = page.links.at(-1);
+  let nextPageToken;
+  if (page.hasMore) {
+    if (!lastLink) {
+      throw new Error("[Sixb] Object storage returned hasMore for an empty link page.");
+    }
+    nextPageToken = encodeLinkPageToken(objectLinkCursor(lastLink), pageScope);
+  }
+  const objects = input.includeObjects ? await hydrateLinkQueryObjects(input.projectId, selected, page.links, options.storage) : [];
+  return {
+    objects,
+    links: page.links,
+    hasMore: page.hasMore,
+    ...nextPageToken ? { nextPageToken } : {}
+  };
+}
+function assertLinkSelectorShape(query, path = "$.query", root = true) {
+  switch (query.kind) {
+    case "project":
+    case "expand":
+      throw new ObjectQueryExecutionError("link_selector_output_shape_not_supported", `Link selectors do not support '${query.kind}' nodes; remove output shaping from the selector`, path);
+    case "page":
+      if (!root) {
+        throw new ObjectQueryExecutionError("link_selector_page_must_be_root", "A page node in a link selector must be the outermost node", path);
+      }
+      assertLinkSelectorShape(query.input, `${path}.input`, false);
+      return;
+    case "start":
+    case "refs":
+      return;
+    case "set": {
+      for (const [index, input] of query.inputs.entries()) {
+        assertLinkSelectorShape(input, `${path}.inputs[${index}]`, false);
+      }
+      return;
+    }
+    case "filter":
+    case "text":
+    case "vector":
+    case "traverse":
+    case "sort":
+    case "limit":
+      assertLinkSelectorShape(query.input, `${path}.input`, false);
+      return;
+  }
+}
+function visibleEndpointTypeIds(options) {
+  if (!options.authorization)
+    return;
+  return options.ontology.listObjectTypes().filter((objectType) => isAllowed(options.authorization, { kind: "object.view", objectTypeId: objectType.id })).map((objectType) => objectType.id);
+}
+function objectIdentity(objectTypeId, primaryId) {
+  return objectBatchKey(objectTypeId, primaryId);
+}
+function linkPageScope(projectId, query, direction, linkId) {
+  return createHash("sha256").update(stableJsonStringify({
+    projectId,
+    query,
+    direction,
+    linkId: linkId ?? null
+  })).digest("base64url");
+}
+function encodeLinkPageToken(cursor, scope) {
+  const payload = { version: 1, scope, cursor };
+  return `${LINK_PAGE_TOKEN_PREFIX}${Buffer.from(JSON.stringify(payload)).toString("base64url")}`;
+}
+function decodeLinkPageToken(token, expectedScope) {
+  if (token === undefined)
+    return;
+  try {
+    if (!token.startsWith(LINK_PAGE_TOKEN_PREFIX))
+      throw new Error("invalid prefix");
+    const value = JSON.parse(Buffer.from(token.slice(LINK_PAGE_TOKEN_PREFIX.length), "base64url").toString("utf8"));
+    if (!isPlainObject2(value) || value.version !== 1 || typeof value.scope !== "string" || !isObjectLinkCursor(value.cursor)) {
+      throw new Error("invalid cursor");
+    }
+    if (value.scope !== expectedScope) {
+      throw new Error("cursor scope mismatch");
+    }
+    return value.cursor;
+  } catch {
+    throw new ObjectQueryExecutionError("invalid_link_page_token", "pageToken is not a valid object-links cursor", "$.pageToken");
+  }
+}
+function isObjectLinkCursor(value) {
+  return Array.isArray(value) && value.length === 5 && value.every((part) => typeof part === "string");
+}
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function hydrateLinkQueryObjects(projectId, selected, links, storage) {
+  const byIdentity = new Map(selected.map((row) => [objectIdentity(row.objectTypeId, row.primaryId), row]));
+  const orderedIdentities = selected.map((row) => objectIdentity(row.objectTypeId, row.primaryId));
+  const seenIdentities = new Set(orderedIdentities);
+  const missingRefs = [];
+  for (const link of links) {
+    for (const ref of [
+      { objectTypeId: link.sourceTypeId, primaryId: link.sourceId },
+      { objectTypeId: link.targetTypeId, primaryId: link.targetId }
+    ]) {
+      const identity = objectIdentity(ref.objectTypeId, ref.primaryId);
+      if (seenIdentities.has(identity))
+        continue;
+      seenIdentities.add(identity);
+      orderedIdentities.push(identity);
+      missingRefs.push(ref);
+    }
+  }
+  if (missingRefs.length > 0) {
+    const hydrated = await storage.getByPrimaryIdBatch({ projectId, items: missingRefs });
+    for (const ref of missingRefs) {
+      const row = hydrated.get(objectBatchKey(ref.objectTypeId, ref.primaryId));
+      if (row)
+        byIdentity.set(objectIdentity(ref.objectTypeId, ref.primaryId), row);
+    }
+  }
+  return orderedIdentities.flatMap((identity) => {
+    const row = byIdentity.get(identity);
+    return row ? [row] : [];
+  });
+}
+export { planObjectQuery, validateObjectQuery, collectObjectQueryValidationIssues, resolveObjectQueryResultShape, executeObjectQuery, countObjects, existsObjects, facetObjects, explainObjectQuery, executeObjectQueryLinks };
 
-//# debugId=99CC14ED40CC1D8E64756E2164756E21
+//# debugId=6AF3162EF872D1D064756E2164756E21