@sixb/core 0.1.3 → 0.1.4

package/dist/{chunk-4z3n1dzt.js → chunk-f83ka50g.js}

@@ -1,4 +1,7 @@
 // @bun
+import {
+  resolveSemanticType
+} from "./chunk-rnshztfq.js";
 import {
   createSixbError
 } from "./chunk-0172wgm9.js";
@@ -615,12 +618,10 @@ function computeProjectionOwnership(projection, ontology) {
   return freezeOwnership({
     objects: [],
     links: [],
-    telemetry: [
-      {
-        objectTypeId: projection.objectTypeId,
-        propertyId: projection.propertyId
-      }
-    ]
+    telemetry: Object.keys(projection.properties).sort(compareStrings).map((propertyId) => ({
+      objectTypeId: projection.objectTypeId,
+      propertyId
+    }))
   });
 }
 function validateProjectionOwnership(projections) {
@@ -735,26 +736,48 @@ function validateLinkProjectionTarget(linkToken) {
     throw new ProjectionValidationError(`Link '${linkToken.id}' has a wildcard target. ` + `Link projection of wildcard links is not supported.`);
   }
 }
-function validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, prefix) {
-  const property = objectType.properties.find((candidate) => candidate.id === projection.propertyId);
-  if (!property) {
-    throw new ProjectionValidationError(`${prefix}: unknown property "${projection.propertyId}" on type "${projection.objectTypeId}"`);
-  }
-  if (property.mode !== "telemetry") {
-    throw new ProjectionValidationError(`${prefix}: property "${projection.propertyId}" on type "${projection.objectTypeId}" must be telemetry-enabled`);
+function validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, valueTypesById, prefix) {
+  const mappedProperties = Object.entries(projection.properties);
+  if (mappedProperties.length === 0) {
+    throw new ProjectionValidationError(`${prefix}: must map at least one telemetry property`);
   }
   const mappedFields = [
     ["objectId", projection.objectIdField],
-    ["at", projection.atField],
-    ["value", projection.valueField],
-    ...projection.unitField !== undefined ? [["unit", projection.unitField]] : []
+    ["at", projection.atField]
   ];
   for (const [fieldRole, columnName] of mappedFields) {
     if (!datasetColumnNames.has(columnName)) {
       throw new ProjectionValidationError(`${prefix}: ${fieldRole} field "${columnName}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
     }
   }
-  return property;
+  const propertiesById = new Map(objectType.properties.map((property) => [property.id, property]));
+  const resolvedProperties = new Map;
+  for (const [propertyId, mapping] of mappedProperties) {
+    const property = propertiesById.get(propertyId);
+    if (!property) {
+      throw new ProjectionValidationError(`${prefix}: unknown property "${propertyId}" on type "${projection.objectTypeId}"`);
+    }
+    if (property.mode !== "telemetry") {
+      throw new ProjectionValidationError(`${prefix}: property "${propertyId}" on type "${projection.objectTypeId}" must be telemetry-enabled`);
+    }
+    for (const [fieldRole, columnName] of [
+      ["value", mapping.valueField],
+      ...mapping.unitField !== undefined ? [["unit", mapping.unitField]] : []
+    ]) {
+      if (!datasetColumnNames.has(columnName)) {
+        throw new ProjectionValidationError(`${prefix}: property "${propertyId}" ${fieldRole} field "${columnName}" references ` + `unknown dataset column on dataset "${projection.datasetId}"`);
+      }
+    }
+    const semanticType = resolveSemanticType(property, valueTypesById);
+    if (semanticType !== undefined && mapping.unitField === undefined) {
+      throw new ProjectionValidationError(`${prefix}: property "${propertyId}" requires a unit field because it uses semantic type "${semanticType}"`);
+    }
+    if (semanticType === undefined && mapping.unitField !== undefined) {
+      throw new ProjectionValidationError(`${prefix}: property "${propertyId}" cannot map a unit field because it has no semantic type`);
+    }
+    resolvedProperties.set(propertyId, property);
+  }
+  return resolvedProperties;
 }
 function validateProjectionsAtStartup(projections, ontology, datasetsById) {
   const { objectProjections, linkProjections, telemetryProjections } = projections;
@@ -897,7 +920,7 @@ function validateProjectionsAtStartup(projections, ontology, datasetsById) {
       throw new ProjectionValidationError(`${prefix}: unknown object type "${projection.objectTypeId}"`);
     }
     const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
-    validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, prefix);
+    validateTelemetryProjectionFieldMapping(projection, objectType, datasetColumnNames, ontology.getValueTypesById(), prefix);
     validatedTelemetryProjections.push({
       definition: projection,
       dataset,
@@ -965,9 +988,9 @@ function defineProjection(id, target) {
     return buildLinkProjection(id, target);
   if ("property" in target)
     return buildTelemetryProjection(id, target);
-  return buildObjectProjection(id, target);
+  return buildObjectTypeProjection(id, target);
 }
-function buildObjectProjection(id, objectType) {
+function buildObjectTypeProjection(id, objectType) {
   assertNonEmpty2(id, "id");
   return {
     fromDataset(dataset) {
@@ -985,6 +1008,18 @@ function buildObjectProjection(id, objectType) {
             links: {},
             conflictResolution: { strategy: "editsWin" }
           });
+        },
+        points(mapping) {
+          const pointMapping = lowerTelemetryPropertiesPointMapping(objectType, mapping);
+          return {
+            _tag: "TelemetryProjectionDefinition",
+            id,
+            objectTypeId: objectType.id,
+            datasetId,
+            objectIdField: pointMapping.objectId,
+            atField: pointMapping.at,
+            properties: pointMapping.properties
+          };
         }
       };
     }
@@ -1034,12 +1069,15 @@ function buildTelemetryProjection(id, propertyToken) {
             _tag: "TelemetryProjectionDefinition",
             id,
             objectTypeId: propertyToken.objectTypeId,
-            propertyId: propertyToken.id,
             datasetId,
             objectIdField: pointMapping.objectId,
             atField: pointMapping.at,
-            valueField: pointMapping.value,
-            ...pointMapping.unit !== undefined ? { unitField: pointMapping.unit } : {}
+            properties: {
+              [propertyToken.id]: {
+                valueField: pointMapping.value,
+                ...pointMapping.unit !== undefined ? { unitField: pointMapping.unit } : {}
+              }
+            }
           };
         }
       };
@@ -1080,6 +1118,69 @@ function lowerTelemetryPointMapping(mapping) {
     ...mapping.unit !== undefined ? { unit: mapping.unit } : {}
   };
 }
+function lowerTelemetryPropertiesPointMapping(objectType, mapping) {
+  const allowedKeys = new Set(["objectId", "at", "properties"]);
+  for (const key of Object.keys(mapping)) {
+    if (!allowedKeys.has(key)) {
+      throw new ProjectionValidationError(`Telemetry projection point mapping contains unknown key '${key}'.`);
+    }
+  }
+  if (mapping.objectId === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires objectId.");
+  }
+  if (mapping.at === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires at.");
+  }
+  if (mapping.properties === undefined) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires properties.");
+  }
+  if (!isRecord(mapping.properties)) {
+    throw new ProjectionValidationError("Telemetry projection point mapping properties must be an object.");
+  }
+  assertNonEmpty2(mapping.objectId, "objectId field");
+  assertNonEmpty2(mapping.at, "at field");
+  const propertyEntries = Object.entries(mapping.properties);
+  if (propertyEntries.length === 0) {
+    throw new ProjectionValidationError("Telemetry projection point mapping requires at least one property.");
+  }
+  const propertiesById = new Map(objectType.properties.map((property) => [property.id, property]));
+  const properties = {};
+  for (const [propertyId, input] of propertyEntries) {
+    const property = propertiesById.get(propertyId);
+    if (!property) {
+      throw new ProjectionValidationError(`Property '${propertyId}' does not exist on object type '${objectType.id}'.`);
+    }
+    if (property.mode !== "telemetry") {
+      throw new ProjectionValidationError(`Projection property '${objectType.id}.${propertyId}' must be telemetry-enabled.`);
+    }
+    properties[propertyId] = lowerTelemetryPropertyMapping(propertyId, input);
+  }
+  return { objectId: mapping.objectId, at: mapping.at, properties };
+}
+function lowerTelemetryPropertyMapping(propertyId, input) {
+  if (typeof input === "string") {
+    assertNonEmpty2(input, `property '${propertyId}' value field`);
+    return { valueField: input };
+  }
+  if (!isRecord(input)) {
+    throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' must map a value column or value/unit columns.`);
+  }
+  const allowedKeys = new Set(["value", "unit"]);
+  for (const key of Object.keys(input)) {
+    if (!allowedKeys.has(key)) {
+      throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' contains unknown key '${key}'.`);
+    }
+  }
+  if (typeof input.value !== "string") {
+    throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' requires a value field.`);
+  }
+  if (typeof input.unit !== "string") {
+    throw new ProjectionValidationError(`Telemetry projection property '${propertyId}' requires a unit field.`);
+  }
+  assertNonEmpty2(input.value, `property '${propertyId}' value field`);
+  assertNonEmpty2(input.unit, `property '${propertyId}' unit field`);
+  return { valueField: input.value, unitField: input.unit };
+}
 function fromForeignKey(input) {
   validateLinkProjectionTarget(input.link);
   if (input.sourceProperty) {
@@ -1151,7 +1252,12 @@ function isLinkProjectionDefinition(value) {
 function isTelemetryProjectionDefinition(value) {
   if (!isRecord(value))
     return false;
-  return value._tag === "TelemetryProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.propertyId === "string" && typeof value.datasetId === "string" && typeof value.objectIdField === "string" && typeof value.atField === "string" && typeof value.valueField === "string" && (value.unitField === undefined || typeof value.unitField === "string");
+  return value._tag === "TelemetryProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && typeof value.objectIdField === "string" && typeof value.atField === "string" && isTelemetryProjectionProperties(value.properties);
+}
+function isTelemetryProjectionProperties(value) {
+  if (!isRecord(value) || Object.keys(value).length === 0)
+    return false;
+  return Object.values(value).every((mapping) => isRecord(mapping) && typeof mapping.valueField === "string" && (mapping.unitField === undefined || typeof mapping.unitField === "string"));
 }
 function isProjectionDefinition(value) {
   return isObjectProjectionDefinition(value) || isLinkProjectionDefinition(value) || isTelemetryProjectionDefinition(value);
@@ -1203,4 +1309,4 @@ function emptyGrantIndex() {
 }
 export { ProjectionValidationError, computeProjectionOwnership, validateProjectionOwnership, validateTelemetryProjectionFieldMapping, validateProjectionsAtStartup, defineProjection, fromForeignKey, isObjectProjectionDefinition, isLinkProjectionDefinition, isTelemetryProjectionDefinition, isProjectionDefinition, projectionTargetOf, GRANT_KINDS, grantKindOf, createPrincipalRuntimeAuthorization, createAgentRuntimeAuthorization, createDisabledRuntimeAuthorization, createTrustedPrimitiveRuntimeAuthorization, getAuthorizationRef, resolveExecutionScopeAuthorization, AuthorizationError, evaluate, isAllowed, assertAuthorized, assertCanEdit, assertCanAppendTelemetry, assertCanManageConnector, assertPrivileged, assertProviderAccess, isApplicationAccessControlled, canAccessApplication, canViewEvent, resolveRoleGrants, resolveAuthorizationContext, canViewActionRun, canViewWorkflowRun, canViewWorkflowIntervention, canViewPipelineRun, canViewProjectionRun, canViewProjection, emptyGrantIndex };
 
-//# debugId=07A883C0450D0C9064756E2164756E21
+//# debugId=48D20BF42F9CD3F464756E2164756E21