@sixb/core 0.1.12 → 0.1.13

package/dist/{chunk-vsg0g7h9.js → chunk-d8yes9yx.js}

@@ -20,6 +20,77 @@ import {
   cloneJsonValue2
 } from "./chunk-wy0qdqfm.js";
 
+// src/ontology/user-ref.ts
+function userRef2(id) {
+  if (typeof id !== "string" || !id.trim()) {
+    throw new OntologyValidationError2("[Sixb] User reference id must not be empty.");
+  }
+  return Object.freeze({ type: "user", id });
+}
+function isUserRef(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const record = value;
+  return Object.keys(record).every((key) => key === "type" || key === "id") && record.type === "user" && typeof record.id === "string" && record.id.trim().length > 0;
+}
+function collectUserRefIds(schema, value, valueTypesById, into, seenValueTypeIds = new Set) {
+  if (value === null || value === undefined)
+    return into;
+  if (typeof schema === "string") {
+    if (schema === "userRef" && isUserRef(value))
+      into.add(value.id);
+    return into;
+  }
+  switch (schema.type) {
+    case "array":
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          collectUserRefIds(schema.items, item, valueTypesById, into, seenValueTypeIds);
+        }
+      }
+      return into;
+    case "map":
+      if (isRecord(value)) {
+        for (const item of Object.values(value)) {
+          collectUserRefIds(schema.valueSchema, item, valueTypesById, into, seenValueTypeIds);
+        }
+      }
+      return into;
+    case "object":
+      if (isRecord(value)) {
+        for (const [fieldId, field] of Object.entries(schema.properties)) {
+          collectUserRefIds(field.schema, value[fieldId], valueTypesById, into, seenValueTypeIds);
+        }
+      }
+      return into;
+    case "valueTypeRef": {
+      if (seenValueTypeIds.has(schema.valueTypeId))
+        return into;
+      const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+      if (!resolved)
+        return into;
+      return collectUserRefIds(resolved, value, valueTypesById, into, new Set([...seenValueTypeIds, schema.valueTypeId]));
+    }
+    case "enum":
+      return into;
+  }
+}
+function userReferenceProblem(path, id, status) {
+  switch (status) {
+    case "active":
+      return;
+    case null:
+      return `[Sixb] ${path} references user '${id}', which does not exist.`;
+    case "unverifiable":
+      return `[Sixb] ${path} references user '${id}', but this runtime has no auth storage to verify users. Configure storage with auth to write user references.`;
+    default:
+      return `[Sixb] ${path} references user '${id}', who is ${status}. Only active users can be newly referenced; existing references are kept.`;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/ontology/validation/schema.ts
 function validateSchemaValue2(schema, value, path, valueTypesById, diagnosticPath = path) {
   if (typeof schema === "string") {
@@ -68,6 +139,13 @@ function validateSchemaValue2(schema, value, path, valueTypesById, diagnosticPat
         }
         return;
       }
+      case "userRef": {
+        if (!isUserRef(value)) {
+          throw withFailureMessage(new OntologyValidationError2(`[Sixb] Property ${path} must be a user reference { type: "user", id }`), `Property ${diagnosticPath} must be a user reference.`);
+        }
+        return;
+      }
+      default:
     }
   }
   if (schema.type === "enum") {
@@ -170,6 +248,16 @@ function normalizeSchemaValue2(schema, value, path, valueTypesById) {
         return normalizeTimestampValue(value, path);
       case "decimal":
         return normalizeDecimal(value, path);
+      case "string":
+      case "uuid":
+      case "integer":
+      case "double":
+      case "boolean":
+      case "fileRef":
+        assertJsonValue2(value, path);
+        return cloneJsonValue2(value);
+      case "userRef":
+        return normalizeUserRef(value, path);
       default:
         assertJsonValue2(value, path);
         return cloneJsonValue2(value);
@@ -240,6 +328,12 @@ function normalizeDecimal(value, path) {
     throw new OntologyValidationError2(`[Sixb] Property ${path} must be an exact decimal string`);
   }
 }
+function normalizeUserRef(value, path) {
+  if (!isUserRef(value)) {
+    throw new OntologyValidationError2(`[Sixb] Property ${path} must be a user reference { type: "user", id }`);
+  }
+  return { type: "user", id: value.id };
+}
 function normalizeDateLike(value, path) {
   const date = value instanceof Date ? value : new Date(String(value));
   if (Number.isNaN(date.getTime())) {
@@ -252,10 +346,22 @@ function coerceSchemaValueToTyped2(schema, value, valueTypesById) {
     return value;
   }
   if (typeof schema === "string") {
-    if (schema === "date" || schema === "timestamp") {
-      return value instanceof Date ? value : new Date(String(value));
+    switch (schema) {
+      case "date":
+      case "timestamp":
+        return value instanceof Date ? value : new Date(String(value));
+      case "string":
+      case "uuid":
+      case "integer":
+      case "double":
+      case "decimal":
+      case "boolean":
+      case "fileRef":
+      case "userRef":
+        return value;
+      default:
+        return value;
     }
-    return value;
   }
   if (schema.type === "valueTypeRef") {
     return coerceSchemaValueToTyped2(resolveValueTypeSchema2(schema, valueTypesById, ""), value, valueTypesById);
@@ -287,6 +393,56 @@ function coerceSchemaValueToTyped2(schema, value, valueTypesById) {
   return output;
 }
 
+// src/ontology/primitives.ts
+var comparable = {
+  exact: true,
+  exactSearch: true,
+  sortable: true,
+  text: false,
+  contains: false,
+  facet: true,
+  telemetry: true,
+  shareableParam: true
+};
+var PRIMITIVE_TRAITS = {
+  string: { ...comparable, queryScalarKind: "string", text: true, contains: true },
+  uuid: { ...comparable, queryScalarKind: "uuid", contains: true },
+  integer: { ...comparable, queryScalarKind: "integer" },
+  double: { ...comparable, queryScalarKind: "double" },
+  decimal: { ...comparable, queryScalarKind: "decimal" },
+  date: { ...comparable, queryScalarKind: "date" },
+  timestamp: { ...comparable, queryScalarKind: "timestamp" },
+  boolean: { ...comparable, queryScalarKind: "boolean", sortable: false },
+  fileRef: {
+    queryScalarKind: undefined,
+    exact: false,
+    exactSearch: false,
+    sortable: false,
+    text: false,
+    contains: false,
+    facet: false,
+    telemetry: false,
+    shareableParam: false
+  },
+  userRef: {
+    queryScalarKind: "userRef",
+    exact: true,
+    exactSearch: false,
+    sortable: false,
+    text: false,
+    contains: false,
+    facet: true,
+    telemetry: false,
+    shareableParam: false
+  }
+};
+function isPrimitiveSchema(schema) {
+  return typeof schema === "string" && Object.hasOwn(PRIMITIVE_TRAITS, schema);
+}
+function primitiveTraits(schema) {
+  return isPrimitiveSchema(schema) ? PRIMITIVE_TRAITS[schema] : undefined;
+}
+
 // src/ontology/validation/properties.ts
 function assertObjectTypeRegistered2(objectTypesById, objectType) {
   if (!objectTypesById.has(objectType.id)) {
@@ -368,8 +524,21 @@ function validatePrimaryProperties2(objectTypesById) {
 function validatePropertyDefinitions2(objectTypesById, valueTypesById) {
   for (const [typeId, objectType] of objectTypesById) {
     for (const property of objectType.properties) {
-      if (property.mode === "telemetry" && schemaContainsFileRef(property.schema, valueTypesById)) {
-        throw new OntologyValidationError2(`[Sixb] Telemetry property '${property.id}' on '${typeId}' cannot use fileRef`);
+      assertNoObjectRefSchema(property, `Property '${typeId}.${property.id}'`, valueTypesById);
+      if (property.mode !== "telemetry")
+        continue;
+      const primitive = findPrimitiveSchema(property.schema, valueTypesById, (schema) => primitiveTraits(schema)?.telemetry === false);
+      if (primitive) {
+        throw new OntologyValidationError2(`[Sixb] Telemetry property '${property.id}' on '${typeId}' cannot use ${primitive}`);
+      }
+    }
+    for (const link of objectType.links) {
+      for (const property of link.properties ?? []) {
+        const path = `Link property '${typeId}.${link.id}.${property.id}'`;
+        assertNoObjectRefSchema(property, path, valueTypesById);
+        if (findPrimitiveSchema(property.schema, valueTypesById, (schema) => schema === "userRef")) {
+          throw new OntologyValidationError2(`[Sixb] ${path} cannot use ref.user(). User references are supported on object properties only.`);
+        }
       }
     }
   }
@@ -386,31 +555,58 @@ function validatePropertyValue2(property, value, path, valueTypesById) {
   }
   validateSchemaValue2(property.schema, value, path, valueTypesById);
 }
-function schemaContainsFileRef(schema, valueTypesById, seenValueTypeIds = new Set) {
-  if (schema === "fileRef") {
-    return true;
-  }
+function findPrimitiveSchema(schema, valueTypesById, matches, seenValueTypeIds = new Set) {
   if (typeof schema === "string") {
-    return false;
+    return matches(schema) ? schema : undefined;
   }
   if (schema.type === "array") {
-    return schemaContainsFileRef(schema.items, valueTypesById, seenValueTypeIds);
+    return findPrimitiveSchema(schema.items, valueTypesById, matches, seenValueTypeIds);
   }
   if (schema.type === "map") {
-    return schemaContainsFileRef(schema.valueSchema, valueTypesById, seenValueTypeIds);
+    return findPrimitiveSchema(schema.valueSchema, valueTypesById, matches, seenValueTypeIds);
   }
   if (schema.type === "object") {
-    return Object.values(schema.properties).some((field) => schemaContainsFileRef(field.schema, valueTypesById, seenValueTypeIds));
+    for (const field of Object.values(schema.properties)) {
+      const primitive = findPrimitiveSchema(field.schema, valueTypesById, matches, seenValueTypeIds);
+      if (primitive)
+        return primitive;
+    }
+    return;
   }
   if (schema.type === "valueTypeRef") {
     if (seenValueTypeIds.has(schema.valueTypeId)) {
-      return false;
+      return;
     }
     seenValueTypeIds.add(schema.valueTypeId);
     const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
-    return resolved ? schemaContainsFileRef(resolved, valueTypesById, seenValueTypeIds) : false;
+    return resolved ? findPrimitiveSchema(resolved, valueTypesById, matches, seenValueTypeIds) : undefined;
+  }
+  return;
+}
+function assertNoObjectRefSchema(property, path, valueTypesById) {
+  if (!containsObjectRefSchema(property.schema, valueTypesById))
+    return;
+  throw new OntologyValidationError2(`[Sixb] ${path} uses ref(ObjectType), which is only for Action and Workflow parameters. Point to another object with link("${property.id}", ObjectType) instead.`);
+}
+function containsObjectRefSchema(schema, valueTypesById, seen = new Set) {
+  if (typeof schema !== "object" || schema === null || seen.has(schema))
+    return false;
+  seen.add(schema);
+  const node = schema;
+  switch (node.type) {
+    case "objectRef":
+      return true;
+    case "array":
+      return containsObjectRefSchema(node.items, valueTypesById, seen);
+    case "map":
+      return containsObjectRefSchema(node.valueSchema, valueTypesById, seen);
+    case "object":
+      return typeof node.properties === "object" && node.properties !== null && Object.values(node.properties).some((field) => containsObjectRefSchema(field?.schema, valueTypesById, seen));
+    case "valueTypeRef":
+      return containsObjectRefSchema(node._resolved ?? valueTypesById.get(String(node.valueTypeId))?.schema, valueTypesById, seen);
+    default:
+      return false;
   }
-  return false;
 }
 
 // src/ontology/validation/links.ts
@@ -472,6 +668,92 @@ function validateLinkProperties2(objectType, link, properties, existingPropertie
   }
 }
 
+// src/ontology/query-capabilities.ts
+function isExactSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.exact === true;
+  return schema.type === "enum";
+}
+function isExactSearchSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.exactSearch === true;
+  return schema.type === "enum";
+}
+function isFilterableSchema(schema) {
+  return isExactSchema(schema) || typeof schema !== "string" && (schema.type === "array" || schema.type === "map");
+}
+function isSortableSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.sortable === true;
+  return schema.type === "enum";
+}
+function isTextSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.text === true;
+  return schema.type === "enum" && schema.valueType === "string";
+}
+function isContainsSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.contains === true;
+  return schema.type === "array" || schema.type === "map";
+}
+function isFacetSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.facet === true;
+  return schema.type === "enum";
+}
+function queryScalarKindForSchema(schema) {
+  if (typeof schema === "string")
+    return primitiveTraits(schema)?.queryScalarKind;
+  if (schema.type === "enum")
+    return schema.valueType === "integer" ? "integer" : "string";
+  return;
+}
+var PRIMARY_OPERATORS = ["eq", "in"];
+var EXACT_OPERATORS = ["eq", "neq", "in", "exists"];
+var RANGE_OPERATORS = ["lt", "lte", "gt", "gte"];
+var OPERATOR_ORDER = [
+  "eq",
+  "neq",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "in",
+  "contains",
+  "exists"
+];
+function resolvePropertyQueryCapabilities2(property, valueTypesById) {
+  const query = property.query?.searchable === true ? property.query : undefined;
+  const schema = resolveQuerySchema(property.schema, valueTypesById);
+  const operators = new Set(property.primary ? PRIMARY_OPERATORS : []);
+  if (query?.filterable === true && schema) {
+    if (isExactSchema(schema))
+      for (const op of EXACT_OPERATORS)
+        operators.add(op);
+    if (isSortableSchema(schema))
+      for (const op of RANGE_OPERATORS)
+        operators.add(op);
+    if (isContainsSchema(schema))
+      operators.add("contains");
+  }
+  return {
+    operators: OPERATOR_ORDER.filter((op) => operators.has(op)),
+    sortable: query?.sortable === true && schema !== undefined && isSortableSchema(schema),
+    facet: query?.facet === true && schema !== undefined && isFacetSchema(schema),
+    text: query?.text === true && property.mode !== "telemetry" && schema !== undefined && isTextSchema(schema)
+  };
+}
+function resolveQuerySchema(schema, valueTypesById, seen = new Set) {
+  if (typeof schema === "string" || schema.type !== "valueTypeRef")
+    return schema;
+  if (seen.has(schema.valueTypeId))
+    return;
+  seen.add(schema.valueTypeId);
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+  return resolved ? resolveQuerySchema(resolved, valueTypesById, seen) : undefined;
+}
+
 // src/ontology/validation/query.ts
 var queryFeatures = ["filterable", "sortable", "text", "exact", "facet"];
 function validateQueryMetadata2(objectTypesById, valueTypesById) {
@@ -512,10 +794,10 @@ function validatePropertyQueryMetadata(ownerPath, property, valueTypesById) {
   if (enabledFeatures.length === 0)
     return;
   const schema = resolveQueryableSchema(property, ownerPath, valueTypesById);
-  if (query.text && !isTextSearchableSchema(schema)) {
+  if (query.text && !isTextSchema(schema)) {
     throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables text search, but its schema is not string-like`);
   }
-  if (query.exact && !isExactSearchableSchema(schema)) {
+  if (query.exact && !isExactSearchSchema(schema)) {
     throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables exact search, but its schema cannot be exact-matched`);
   }
   if (query.filterable && !isFilterableSchema(schema)) {
@@ -545,7 +827,7 @@ function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
     for (const id of profile.source) {
       const property = requireObjectProperty(typeId, objectType, id, `search.vectors.${name}`);
       assertStaticSearchProfileProperty(typeId, property, `search.vectors.${name}`);
-      if (!isTextSearchableSchema(resolveQueryableSchema(property, typeId, valueTypesById))) {
+      if (!isTextSchema(resolveQueryableSchema(property, typeId, valueTypesById))) {
         throw new OntologyValidationError2(`[Sixb] Vector source must be text: ${typeId}.${id}`);
       }
     }
@@ -555,7 +837,7 @@ function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
     const title = requireObjectProperty(typeId, objectType, search.title, "search.title");
     assertStaticSearchProfileProperty(typeId, title, "search.title");
     const schema = resolveQueryableSchema(title, typeId, valueTypesById);
-    if (!isTextSearchableSchema(schema)) {
+    if (!isTextSchema(schema)) {
       throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' search.title references '${title.id}', but title fields must be string-like`);
     }
   }
@@ -610,29 +892,6 @@ function resolveSchema(schema, valueTypesById, path, seenValueTypeIds = new Set)
   seenValueTypeIds.add(schema.valueTypeId);
   return resolveSchema(resolved, valueTypesById, path, seenValueTypeIds);
 }
-function isTextSearchableSchema(schema) {
-  if (schema === "string")
-    return true;
-  return typeof schema !== "string" && schema.type === "enum" && schema.valueType === "string";
-}
-function isExactSearchableSchema(schema) {
-  if (typeof schema === "string") {
-    return schema !== "fileRef";
-  }
-  return schema.type === "enum";
-}
-function isFilterableSchema(schema) {
-  return isExactSearchableSchema(schema) || typeof schema !== "string" && (schema.type === "array" || schema.type === "map");
-}
-function isSortableSchema(schema) {
-  if (typeof schema === "string") {
-    return schema === "string" || schema === "uuid" || schema === "integer" || schema === "double" || schema === "decimal" || schema === "date" || schema === "timestamp";
-  }
-  return schema.type === "enum";
-}
-function isFacetSchema(schema) {
-  return isExactSearchableSchema(schema);
-}
 
 // src/ontology/units/quantitative-types.ts
 var angleUnits = {
@@ -1245,6 +1504,6 @@ function validateTelemetryUnit2(property, propertyPath, unit, valueTypesById) {
     throw new OntologyValidationError2(`[Sixb] Property ${propertyPath} does not define semanticType and cannot accept a unit`);
   }
 }
-export { validateSchemaValue2, resolveValueTypeRef2, resolveValueTypeSchema2, isRecord2, normalizeObjectProperties2, normalizeSchemaValue2, coerceSchemaValueToTyped2, assertObjectTypeRegistered2, assertPropertyTokenBelongsToObjectType2, assertLinkTokenBelongsToObjectType2, assertKnownProperties2, assertRequiredProperties2, validateObjectProperties2, validatePrimaryProperties2, validatePropertyDefinitions2, validatePropertyValue2, assertLinkTargetType2, assertTargetTypeCompatible2, normalizeLinkProperties2, validateLinkProperties2, validateQueryMetadata2, quantitativeTypes2, getUnit2, getUnitsFor2, isValidUnit2, getUnitSymbol2, isQuantitativeTypeId2, isUnitId2, assertTelemetryProperty2, resolveSemanticType2, validateTelemetryUnit2 };
+export { userRef2, collectUserRefIds, userReferenceProblem, validateSchemaValue2, resolveValueTypeRef2, resolveValueTypeSchema2, isRecord2, normalizeObjectProperties2, normalizeSchemaValue2, coerceSchemaValueToTyped2, isPrimitiveSchema, primitiveTraits, assertObjectTypeRegistered2, assertPropertyTokenBelongsToObjectType2, assertLinkTokenBelongsToObjectType2, assertKnownProperties2, assertRequiredProperties2, validateObjectProperties2, validatePrimaryProperties2, validatePropertyDefinitions2, validatePropertyValue2, findPrimitiveSchema, assertLinkTargetType2, assertTargetTypeCompatible2, normalizeLinkProperties2, validateLinkProperties2, isExactSchema, isSortableSchema, isTextSchema, isContainsSchema, queryScalarKindForSchema, resolvePropertyQueryCapabilities2, validateQueryMetadata2, quantitativeTypes2, getUnit2, getUnitsFor2, isValidUnit2, getUnitSymbol2, isQuantitativeTypeId2, isUnitId2, assertTelemetryProperty2, resolveSemanticType2, validateTelemetryUnit2 };
 
-//# debugId=FA9118B7173D1B9264756E2164756E21
+//# debugId=65AF2C96D9900E0264756E2164756E21