@sixb/core 0.1.2 → 0.1.4

package/dist/{chunk-34bqh420.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;
@@ -775,6 +798,19 @@ 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));
+    const conflictResolution = projection.conflictResolution ?? { strategy: "editsWin" };
+    if (conflictResolution.strategy === "mostRecent") {
+      const sourceTimestamp = dataset.schema.columns.find((column) => column.name === conflictResolution.sourceTimestamp);
+      if (!sourceTimestamp) {
+        throw new ProjectionValidationError(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" references unknown ` + `dataset column on dataset "${projection.datasetId}"`);
+      }
+      if (sourceTimestamp.type !== "timestamp") {
+        throw new ProjectionValidationError(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" must reference a ` + `timestamp dataset column`);
+      }
+      if (sourceTimestamp.nullable === true) {
+        throw new ProjectionValidationError(`${prefix}: source timestamp "${conflictResolution.sourceTimestamp}" must reference a ` + `non-null timestamp dataset column`);
+      }
+    }
     const propertyIds = new Set(objectType.properties.map((p) => p.id));
     for (const [propId, columnName] of Object.entries(projection.properties)) {
       if (!propertyIds.has(propId)) {
@@ -884,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,
@@ -952,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) {
@@ -964,33 +1000,61 @@ function buildObjectProjection(id, objectType) {
         properties(mapping) {
           const propertyMapping = mapping;
           validatePropertyMapping(objectType, propertyMapping);
-          const definition = {
-            _tag: "ObjectProjectionDefinition",
+          return objectProjectionBuilder({
+            id,
+            objectType,
+            datasetId,
+            propertyMapping,
+            links: {},
+            conflictResolution: { strategy: "editsWin" }
+          });
+        },
+        points(mapping) {
+          const pointMapping = lowerTelemetryPropertiesPointMapping(objectType, mapping);
+          return {
+            _tag: "TelemetryProjectionDefinition",
             id,
             objectTypeId: objectType.id,
             datasetId,
-            properties: { ...propertyMapping },
-            links: {}
+            objectIdField: pointMapping.objectId,
+            atField: pointMapping.at,
+            properties: pointMapping.properties
           };
-          return Object.assign(definition, {
-            withLinks(linkMapping) {
-              const loweredLinkMapping = lowerForeignKeyMapping(linkMapping);
-              const validatedLinks = validateAndLowerLinkMapping(objectType, loweredLinkMapping, propertyMapping);
-              return {
-                _tag: "ObjectProjectionDefinition",
-                id,
-                objectTypeId: objectType.id,
-                datasetId,
-                properties: { ...propertyMapping },
-                links: validatedLinks
-              };
-            }
-          });
         }
       };
     }
   };
 }
+function objectProjectionBuilder(input) {
+  const definition = {
+    _tag: "ObjectProjectionDefinition",
+    id: input.id,
+    objectTypeId: input.objectType.id,
+    datasetId: input.datasetId,
+    properties: { ...input.propertyMapping },
+    links: { ...input.links },
+    conflictResolution: { ...input.conflictResolution }
+  };
+  return Object.assign(definition, {
+    withLinks(linkMapping) {
+      const loweredLinkMapping = lowerForeignKeyMapping(linkMapping);
+      const validatedLinks = validateAndLowerLinkMapping(input.objectType, loweredLinkMapping, input.propertyMapping);
+      return objectProjectionBuilder({ ...input, links: validatedLinks });
+    },
+    resolveConflicts(resolution) {
+      validateConflictResolution(resolution);
+      return objectProjectionBuilder({
+        ...input,
+        conflictResolution: resolution
+      });
+    }
+  });
+}
+function validateConflictResolution(resolution) {
+  if (resolution.strategy === "editsWin")
+    return;
+  assertNonEmpty2(resolution.sourceTimestamp, "source timestamp field");
+}
 function buildTelemetryProjection(id, propertyToken) {
   assertNonEmpty2(id, "id");
   validateTelemetryProjectionProperty(propertyToken);
@@ -1005,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 } : {}
+              }
+            }
           };
         }
       };
@@ -1051,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) {
@@ -1103,7 +1233,16 @@ function buildLinkProjection(id, linkToken) {
 function isObjectProjectionDefinition(value) {
   if (!isRecord(value))
     return false;
-  return value._tag === "ObjectProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && isRecord(value.properties) && isRecord(value.links);
+  return value._tag === "ObjectProjectionDefinition" && typeof value.id === "string" && typeof value.objectTypeId === "string" && typeof value.datasetId === "string" && isRecord(value.properties) && isRecord(value.links) && isSourceEditConflictResolution(value.conflictResolution);
+}
+function isSourceEditConflictResolution(value) {
+  if (value === undefined)
+    return true;
+  if (!isRecord(value) || typeof value.strategy !== "string")
+    return false;
+  if (value.strategy === "editsWin")
+    return value.sourceTimestamp === undefined;
+  return value.strategy === "mostRecent" && typeof value.sourceTimestamp === "string";
 }
 function isLinkProjectionDefinition(value) {
   if (!isRecord(value))
@@ -1113,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);
@@ -1165,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=EA88C5F91530A04564756E2164756E21
+//# debugId=48D20BF42F9CD3F464756E2164756E21