@sixb/core 0.1.0 → 0.1.2

package/dist/chunk-btpe64e4.js

@@ -1,554 +0,0 @@
-// @bun
-import {
-  compareStrings
-} from "./chunk-1vffvydj.js";
-
-// src/projections/errors.ts
-class ProjectionValidationError extends Error {
-  name = "ProjectionValidationError";
-}
-
-// src/projections/ownership.ts
-function computeProjectionOwnership(projection, ontology) {
-  if (projection._tag === "ObjectProjectionDefinition") {
-    const primaryId = ontology.getPrimaryPropertyId(projection.objectTypeId);
-    return freezeOwnership({
-      objects: [
-        {
-          objectTypeId: projection.objectTypeId,
-          existence: true,
-          propertyIds: Object.keys(projection.properties).filter((propertyId) => propertyId !== primaryId).sort(compareStrings)
-        }
-      ],
-      links: Object.keys(projection.links).sort(compareStrings).map((linkId) => ({ sourceObjectTypeId: projection.objectTypeId, linkId })),
-      telemetry: []
-    });
-  }
-  if (projection._tag === "LinkProjectionDefinition") {
-    return freezeOwnership({
-      objects: [],
-      links: [
-        {
-          sourceObjectTypeId: projection.sourceObjectTypeId,
-          linkId: projection.linkId
-        }
-      ],
-      telemetry: []
-    });
-  }
-  return freezeOwnership({
-    objects: [],
-    links: [],
-    telemetry: [
-      {
-        objectTypeId: projection.objectTypeId,
-        propertyId: projection.propertyId
-      }
-    ]
-  });
-}
-function validateProjectionOwnership(projections) {
-  const existenceOwners = new Map;
-  const propertyOwners = new Map;
-  const linkOwners = new Map;
-  const telemetryOwners = new Map;
-  for (const { definition, ownership } of projections) {
-    for (const object of ownership.objects) {
-      if (object.existence) {
-        registerOwner(existenceOwners, object.objectTypeId, definition.id, `object type '${object.objectTypeId}' existence`);
-      }
-      for (const propertyId of object.propertyIds) {
-        registerOwner(propertyOwners, JSON.stringify([object.objectTypeId, propertyId]), definition.id, `property '${object.objectTypeId}.${propertyId}'`);
-      }
-    }
-    for (const link of ownership.links) {
-      registerOwner(linkOwners, JSON.stringify([link.sourceObjectTypeId, link.linkId]), definition.id, `link scope '${link.sourceObjectTypeId}.${link.linkId}'`);
-    }
-    for (const telemetry of ownership.telemetry) {
-      registerOwner(telemetryOwners, JSON.stringify([telemetry.objectTypeId, telemetry.propertyId]), definition.id, `telemetry source '${telemetry.objectTypeId}.${telemetry.propertyId}'`);
-    }
-  }
-}
-function registerOwner(owners, key, projectionId, description) {
-  const existing = owners.get(key);
-  if (existing !== undefined) {
-    throw new ProjectionValidationError(`[Sixb] Projection '${projectionId}' overlaps ${description} owned by projection '${existing}'.`);
-  }
-  owners.set(key, projectionId);
-}
-function freezeOwnership(ownership) {
-  return Object.freeze({
-    objects: Object.freeze(ownership.objects.map((object) => Object.freeze({ ...object, propertyIds: Object.freeze([...object.propertyIds]) }))),
-    links: Object.freeze(ownership.links.map((link) => Object.freeze({ ...link }))),
-    telemetry: Object.freeze(ownership.telemetry.map((telemetry) => Object.freeze({ ...telemetry })))
-  });
-}
-
-// src/projections/validation.ts
-function validatePropertyMapping(objectType, mapping) {
-  const propertyIds = new Set(objectType.properties.map((p) => p.id));
-  const mappingKeys = Object.keys(mapping);
-  for (const key of mappingKeys) {
-    if (!propertyIds.has(key)) {
-      const available = [...propertyIds].sort().join(", ");
-      throw new ProjectionValidationError(`Property '${key}' does not exist on object type '${objectType.id}'. ` + `Available properties: ${available}`);
-    }
-  }
-  const primaryProperties = objectType.properties.filter((p) => p.primary === true);
-  if (primaryProperties.length !== 1) {
-    throw new ProjectionValidationError(`Object type '${objectType.id}' must have exactly one primary property, ` + `found ${primaryProperties.length}.`);
-  }
-  const primaryId = primaryProperties[0].id;
-  if (!(primaryId in mapping)) {
-    throw new ProjectionValidationError(`Primary property '${primaryId}' of object type '${objectType.id}' ` + `must be included in the property mapping.`);
-  }
-}
-function validateAndLowerLinkMapping(objectType, linkMapping, propertyMapping) {
-  const linkIds = new Set(objectType.links.map((l) => l.id));
-  const linksById = new Map(objectType.links.map((l) => [l.id, l]));
-  const propertyIds = new Set(objectType.properties.map((p) => p.id));
-  for (const [key, descriptor] of Object.entries(linkMapping)) {
-    if (!linkIds.has(key)) {
-      const available = [...linkIds].sort().join(", ");
-      throw new ProjectionValidationError(`Link '${key}' does not exist on object type '${objectType.id}'. ` + `Available links: ${available}`);
-    }
-    if (key !== descriptor.linkId) {
-      throw new ProjectionValidationError(`Link mapping key '${key}' does not match descriptor linkId '${descriptor.linkId}'.`);
-    }
-    const link = linksById.get(key);
-    if (Array.isArray(link.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`Link '${key}' on object type '${objectType.id}' has a polymorphic target. ` + `FK projection of polymorphic links is not yet supported.`);
-    }
-    if (link.targetObjectTypeId === "*") {
-      throw new ProjectionValidationError(`Link '${key}' on object type '${objectType.id}' has a wildcard target. ` + `FK projection of wildcard links is not supported.`);
-    }
-    const sourcePropertyId = descriptor.sourcePropertyId;
-    const sourceField = descriptor.sourceField;
-    if (sourcePropertyId && sourceField) {
-      throw new ProjectionValidationError(`FK link '${key}' must use either sourceProperty or sourceField, not both.`);
-    }
-    if (!sourcePropertyId && !sourceField) {
-      throw new ProjectionValidationError(`FK link '${key}' must declare sourceProperty or sourceField.`);
-    }
-    if (!sourcePropertyId) {
-      continue;
-    }
-    if (!propertyIds.has(sourcePropertyId)) {
-      const available = [...propertyIds].sort().join(", ");
-      throw new ProjectionValidationError(`Source property '${sourcePropertyId}' does not exist on ` + `object type '${objectType.id}'. Available properties: ${available}`);
-    }
-    if (!(sourcePropertyId in propertyMapping)) {
-      throw new ProjectionValidationError(`Source property '${sourcePropertyId}' for link '${key}' ` + `must be included in the property mapping.`);
-    }
-  }
-  return Object.fromEntries(Object.entries(linkMapping).map(([linkId, descriptor]) => [
-    linkId,
-    {
-      linkId: descriptor.linkId,
-      ...descriptor.sourcePropertyId !== undefined ? { sourcePropertyId: descriptor.sourcePropertyId } : {},
-      ...descriptor.sourceField !== undefined ? { sourceField: descriptor.sourceField } : {},
-      targetObjectTypeId: descriptor.targetObjectTypeId
-    }
-  ]));
-}
-function validateLinkProjectionTarget(linkToken) {
-  if (Array.isArray(linkToken.targetObjectTypeId)) {
-    throw new ProjectionValidationError(`Link '${linkToken.id}' has a polymorphic target. ` + `Link projection of polymorphic links is not yet supported.`);
-  }
-  if (linkToken.targetObjectTypeId === "*") {
-    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`);
-  }
-  const mappedFields = [
-    ["objectId", projection.objectIdField],
-    ["at", projection.atField],
-    ["value", projection.valueField],
-    ...projection.unitField !== undefined ? [["unit", projection.unitField]] : []
-  ];
-  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;
-}
-function validateProjectionsAtStartup(projections, ontology, datasetsById) {
-  const { objectProjections, linkProjections, telemetryProjections } = projections;
-  const objectTypesById = ontology.getObjectTypesById();
-  const primaryByTypeId = ontology.getPrimaryByTypeId();
-  const validatedObjectProjections = [];
-  const validatedLinkProjections = [];
-  const validatedTelemetryProjections = [];
-  validateMaterializationOntologyConstraints(ontology);
-  for (const projection of objectProjections) {
-    const prefix = `Projection "${projection.id}"`;
-    const dataset = datasetsById.get(projection.datasetId);
-    if (!dataset) {
-      throw new ProjectionValidationError(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
-    }
-    const objectType = objectTypesById.get(projection.objectTypeId);
-    if (!objectType) {
-      throw new ProjectionValidationError(`${prefix}: unknown object type "${projection.objectTypeId}"`);
-    }
-    const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
-    const propertyIds = new Set(objectType.properties.map((p) => p.id));
-    for (const [propId, columnName] of Object.entries(projection.properties)) {
-      if (!propertyIds.has(propId)) {
-        throw new ProjectionValidationError(`${prefix}: unknown property "${propId}" on type "${projection.objectTypeId}"`);
-      }
-      if (!datasetColumnNames.has(columnName)) {
-        throw new ProjectionValidationError(`${prefix}: property "${propId}" references unknown dataset column "${columnName}" ` + `on dataset "${projection.datasetId}"`);
-      }
-      const property = objectType.properties.find((candidate) => candidate.id === propId);
-      if (property?.mode === "telemetry") {
-        throw new ProjectionValidationError(`[Sixb] ${prefix}: source mappings cannot own telemetry property "${projection.objectTypeId}.${propId}"`);
-      }
-    }
-    const primaryId = primaryByTypeId.get(projection.objectTypeId);
-    if (!(primaryId in projection.properties)) {
-      throw new ProjectionValidationError(`${prefix}: primary property "${primaryId}" must be in property mapping`);
-    }
-    const linkIds = new Set(objectType.links.map((l) => l.id));
-    for (const [linkId, fk] of Object.entries(projection.links)) {
-      if (!linkIds.has(linkId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" references unknown link on type "${projection.objectTypeId}"`);
-      }
-      if (fk.linkId !== linkId) {
-        throw new ProjectionValidationError(`${prefix}: FK link mapping key "${linkId}" does not match descriptor linkId "${fk.linkId}"`);
-      }
-      const sourcePropertyId = fk.sourcePropertyId;
-      const sourceField = fk.sourceField;
-      if (sourcePropertyId && sourceField) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" must use either sourcePropertyId or sourceField, not both`);
-      }
-      if (!sourcePropertyId && !sourceField) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" must declare sourcePropertyId or sourceField`);
-      }
-      if (sourcePropertyId && !propertyIds.has(sourcePropertyId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" source property "${sourcePropertyId}" does not exist on type "${projection.objectTypeId}"`);
-      }
-      if (sourcePropertyId && !(sourcePropertyId in projection.properties)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" source property "${sourcePropertyId}" must be in property mapping`);
-      }
-      if (sourceField && !datasetColumnNames.has(sourceField)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" source field "${sourceField}" references unknown dataset column on dataset "${projection.datasetId}"`);
-      }
-      if (!objectTypesById.has(fk.targetObjectTypeId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" is unknown`);
-      }
-      if (!primaryByTypeId.has(fk.targetObjectTypeId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" has no primary property`);
-      }
-      const link = objectType.links.find((candidate) => candidate.id === linkId);
-      if (!ontology.isValidLinkTarget(link.targetObjectTypeId, fk.targetObjectTypeId)) {
-        throw new ProjectionValidationError(`${prefix}: FK link "${linkId}" target type "${fk.targetObjectTypeId}" is not compatible with its declared target`);
-      }
-    }
-    validatedObjectProjections.push({
-      definition: projection,
-      dataset,
-      ownership: computeProjectionOwnership(projection, ontology)
-    });
-  }
-  for (const projection of linkProjections) {
-    const prefix = `Projection "${projection.id}"`;
-    const dataset = datasetsById.get(projection.datasetId);
-    if (!dataset) {
-      throw new ProjectionValidationError(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
-    }
-    if (!objectTypesById.has(projection.sourceObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: unknown source type "${projection.sourceObjectTypeId}"`);
-    }
-    if (!objectTypesById.has(projection.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: unknown target type "${projection.targetObjectTypeId}"`);
-    }
-    const sourceType = objectTypesById.get(projection.sourceObjectTypeId);
-    const link = sourceType.links.find((candidate) => candidate.id === projection.linkId);
-    if (!link) {
-      throw new ProjectionValidationError(`${prefix}: link "${projection.linkId}" does not exist on source type "${projection.sourceObjectTypeId}"`);
-    }
-    if (!ontology.isValidLinkTarget(link.targetObjectTypeId, projection.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: target type "${projection.targetObjectTypeId}" is not compatible with link "${projection.linkId}"`);
-    }
-    const datasetColumnNames = new Set(dataset.schema.columns.map((column) => column.name));
-    if (!datasetColumnNames.has(projection.sourceField)) {
-      throw new ProjectionValidationError(`${prefix}: source field "${projection.sourceField}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
-    }
-    if (!datasetColumnNames.has(projection.targetField)) {
-      throw new ProjectionValidationError(`${prefix}: target field "${projection.targetField}" references unknown dataset column ` + `on dataset "${projection.datasetId}"`);
-    }
-    if (!primaryByTypeId.has(projection.sourceObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: source type "${projection.sourceObjectTypeId}" has no primary property`);
-    }
-    if (!primaryByTypeId.has(projection.targetObjectTypeId)) {
-      throw new ProjectionValidationError(`${prefix}: target type "${projection.targetObjectTypeId}" has no primary property`);
-    }
-    validatedLinkProjections.push({
-      definition: projection,
-      dataset,
-      ownership: computeProjectionOwnership(projection, ontology)
-    });
-  }
-  for (const projection of telemetryProjections) {
-    const prefix = `Projection "${projection.id}"`;
-    const dataset = datasetsById.get(projection.datasetId);
-    if (!dataset) {
-      throw new ProjectionValidationError(`${prefix}: unknown dataset "${projection.datasetId}". ` + `Add it to 'datasets' in createSixb() or export it from 'datasets/'.`);
-    }
-    const objectType = objectTypesById.get(projection.objectTypeId);
-    if (!objectType) {
-      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);
-    validatedTelemetryProjections.push({
-      definition: projection,
-      dataset,
-      ownership: computeProjectionOwnership(projection, ontology)
-    });
-  }
-  const validatedProjections = [
-    ...validatedObjectProjections,
-    ...validatedLinkProjections,
-    ...validatedTelemetryProjections
-  ];
-  validateProjectionOwnership(validatedProjections);
-  return {
-    objectProjections: validatedObjectProjections,
-    linkProjections: validatedLinkProjections,
-    telemetryProjections: validatedTelemetryProjections
-  };
-}
-function validateMaterializationOntologyConstraints(ontology) {
-  for (const objectType of ontology.getObjectTypesById().values()) {
-    for (const property of objectType.properties) {
-      if (property.mode === "telemetry" && property.required === true) {
-        throw new ProjectionValidationError(`[Sixb] Telemetry property '${objectType.id}.${property.id}' cannot be required.`);
-      }
-    }
-    for (const link of objectType.links) {
-      for (const property of link.properties ?? []) {
-        if (property.mode === "telemetry") {
-          throw new ProjectionValidationError(`[Sixb] Link property '${objectType.id}.${link.id}.${property.id}' cannot use telemetry mode.`);
-        }
-      }
-    }
-  }
-}
-
-// src/projections/builders.ts
-function assertNonEmpty(value, field) {
-  if (!value.trim()) {
-    throw new ProjectionValidationError(`Projection ${field} must not be empty.`);
-  }
-}
-function assertProjectionDataset(dataset) {
-  if (!dataset || dataset.kind !== "dataset" || typeof dataset.id !== "string") {
-    throw new ProjectionValidationError("Projection dataset must be a dataset definition.");
-  }
-  assertNonEmpty(dataset.id, "dataset id");
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function lowerForeignKeyMapping(mapping) {
-  const lowered = {};
-  for (const [linkId, descriptor] of Object.entries(mapping)) {
-    if (!descriptor)
-      continue;
-    lowered[linkId] = isForeignKeyDescriptor(descriptor) ? descriptor : fromForeignKey(descriptor);
-  }
-  return lowered;
-}
-function isForeignKeyDescriptor(value) {
-  return isRecord(value) && typeof value.linkId === "string";
-}
-function defineProjection(id, target) {
-  if ("link" in target)
-    return buildLinkProjection(id, target);
-  if ("property" in target)
-    return buildTelemetryProjection(id, target);
-  return buildObjectProjection(id, target);
-}
-function buildObjectProjection(id, objectType) {
-  assertNonEmpty(id, "id");
-  return {
-    fromDataset(dataset) {
-      assertProjectionDataset(dataset);
-      const datasetId = dataset.id;
-      return {
-        properties(mapping) {
-          const propertyMapping = mapping;
-          validatePropertyMapping(objectType, propertyMapping);
-          const definition = {
-            _tag: "ObjectProjectionDefinition",
-            id,
-            objectTypeId: objectType.id,
-            datasetId,
-            properties: { ...propertyMapping },
-            links: {}
-          };
-          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 buildTelemetryProjection(id, propertyToken) {
-  assertNonEmpty(id, "id");
-  validateTelemetryProjectionProperty(propertyToken);
-  return {
-    fromDataset(dataset) {
-      assertProjectionDataset(dataset);
-      const datasetId = dataset.id;
-      return {
-        points(mapping) {
-          const pointMapping = lowerTelemetryPointMapping(mapping);
-          return {
-            _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 } : {}
-          };
-        }
-      };
-    }
-  };
-}
-function validateTelemetryProjectionProperty(propertyToken) {
-  if (propertyToken.property.mode !== "telemetry") {
-    throw new ProjectionValidationError(`Projection property '${propertyToken.objectTypeId}.${propertyToken.id}' must be telemetry-enabled.`);
-  }
-}
-function lowerTelemetryPointMapping(mapping) {
-  const allowedKeys = new Set(["objectId", "at", "value", "unit"]);
-  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.value === undefined) {
-    throw new ProjectionValidationError("Telemetry projection point mapping requires value.");
-  }
-  assertNonEmpty(mapping.objectId, "objectId field");
-  assertNonEmpty(mapping.at, "at field");
-  assertNonEmpty(mapping.value, "value field");
-  if (mapping.unit !== undefined) {
-    assertNonEmpty(mapping.unit, "unit field");
-  }
-  return {
-    objectId: mapping.objectId,
-    at: mapping.at,
-    value: mapping.value,
-    ...mapping.unit !== undefined ? { unit: mapping.unit } : {}
-  };
-}
-function fromForeignKey(input) {
-  validateLinkProjectionTarget(input.link);
-  if (input.sourceProperty) {
-    return {
-      linkId: input.link.id,
-      sourcePropertyId: input.sourceProperty.id,
-      targetObjectTypeId: input.target.id
-    };
-  }
-  if (input.sourceField === undefined) {
-    throw new ProjectionValidationError("Foreign key sourceField is required.");
-  }
-  assertNonEmpty(input.sourceField, "source field");
-  return {
-    linkId: input.link.id,
-    sourceField: input.sourceField,
-    targetObjectTypeId: input.target.id
-  };
-}
-function buildLinkProjection(id, linkToken) {
-  assertNonEmpty(id, "id");
-  validateLinkProjectionTarget(linkToken);
-  return {
-    fromDataset(dataset) {
-      assertProjectionDataset(dataset);
-      const datasetId = dataset.id;
-      return {
-        sourceField(columnName) {
-          assertNonEmpty(columnName, "source field");
-          return {
-            targetField(targetColumnName) {
-              assertNonEmpty(targetColumnName, "target field");
-              return {
-                _tag: "LinkProjectionDefinition",
-                id,
-                linkId: linkToken.id,
-                sourceObjectTypeId: linkToken.objectTypeId,
-                targetObjectTypeId: linkToken.targetObjectTypeId,
-                datasetId,
-                sourceField: columnName,
-                targetField: targetColumnName
-              };
-            }
-          };
-        }
-      };
-    }
-  };
-}
-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);
-}
-function isLinkProjectionDefinition(value) {
-  if (!isRecord(value))
-    return false;
-  return value._tag === "LinkProjectionDefinition" && typeof value.id === "string" && typeof value.linkId === "string" && typeof value.sourceObjectTypeId === "string" && typeof value.targetObjectTypeId === "string" && typeof value.datasetId === "string" && typeof value.sourceField === "string" && typeof value.targetField === "string";
-}
-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");
-}
-function isProjectionDefinition(value) {
-  return isObjectProjectionDefinition(value) || isLinkProjectionDefinition(value) || isTelemetryProjectionDefinition(value);
-}
-function projectionTargetOf(projection) {
-  return projection._tag === "LinkProjectionDefinition" ? {
-    sourceObjectTypeId: projection.sourceObjectTypeId,
-    targetObjectTypeId: projection.targetObjectTypeId
-  } : { objectTypeId: projection.objectTypeId };
-}
-
-export { ProjectionValidationError, computeProjectionOwnership, validateProjectionOwnership, validateTelemetryProjectionFieldMapping, validateProjectionsAtStartup, defineProjection, fromForeignKey, isObjectProjectionDefinition, isLinkProjectionDefinition, isTelemetryProjectionDefinition, isProjectionDefinition, projectionTargetOf };
-
-//# debugId=92806BDDE8D60B1764756E2164756E21