@sixb/core 0.1.18 → 0.1.20

package/dist/chunk-tffvfy6s.js

@@ -1,593 +0,0 @@
-// @bun
-import {
-  assertPropertyTokenBelongsToObjectType2,
-  assertTelemetryProperty2
-} from "./chunk-y05543x6.js";
-import {
-  lowerEditBatch2
-} from "./chunk-wr8qp979.js";
-import {
-  objectRefKey2,
-  linkRefKey2,
-  linkScopeKey
-} from "./chunk-b9affek3.js";
-import {
-  createLinkScopeFingerprint2
-} from "./chunk-p0dqwj3n.js";
-import {
-  ActionValidationError2
-} from "./chunk-6fsr7y93.js";
-import {
-  ActionDefinitionError2,
-  ActionEditCommitError2,
-  missingActionMutationMessage,
-  effectsWithoutEditsMessage,
-  assertNonEmpty2,
-  isObjectActionDefinition2
-} from "./chunk-6h5m9xjx.js";
-import {
-  decorateObjectQueryExecutor
-} from "./chunk-ewqa58h9.js";
-import {
-  RuntimeError2
-} from "./chunk-m4ehq95f.js";
-import {
-  OntologyValidationError2
-} from "./chunk-cqr3acm1.js";
-
-// src/actions/builders/define-action.ts
-function defineAction2(id, options) {
-  assertNonEmpty2(id, "id");
-  return asPublicActionType(createActionBuilder(id, options));
-}
-function createActionBuilder(id, options) {
-  const builder = {
-    params(params) {
-      return createGlobalActionPhaseBuilder(id, params, options);
-    },
-    on(objectType) {
-      assertNonEmpty2(objectType.id, "target id");
-      return createObjectActionParamsBuilder(id, objectType, options);
-    }
-  };
-  return builder;
-}
-function createGlobalActionPhaseBuilder(id, params, options) {
-  const validators = [];
-  const builder = {
-    validate(validator) {
-      validators.push(validator);
-      return builder;
-    },
-    writeback(handler) {
-      return createGlobalDefinition({
-        id,
-        params,
-        description: options?.description,
-        validators,
-        writeback: handler
-      });
-    },
-    edits(handler) {
-      return createGlobalDefinition({
-        id,
-        params,
-        description: options?.description,
-        validators,
-        edits: handler
-      });
-    }
-  };
-  return asPublicActionType(builder);
-}
-function createObjectActionParamsBuilder(id, objectType, options) {
-  return {
-    params(params) {
-      return createObjectActionPhaseBuilder(id, objectType, params, options);
-    }
-  };
-}
-function createObjectActionPhaseBuilder(id, objectType, params, options) {
-  const validators = [];
-  const builder = {
-    validate(validator) {
-      validators.push(validator);
-      return builder;
-    },
-    writeback(handler) {
-      return createObjectDefinition({
-        id,
-        objectType,
-        params,
-        description: options?.description,
-        validators,
-        writeback: handler
-      });
-    },
-    edits(handler) {
-      return createObjectDefinition({
-        id,
-        objectType,
-        params,
-        description: options?.description,
-        validators,
-        edits: handler
-      });
-    }
-  };
-  return asPublicActionType(builder);
-}
-function createGlobalDefinition(input) {
-  const definition = {
-    kind: "action",
-    id: input.id,
-    binding: { kind: "global" },
-    params: input.params,
-    phases: {
-      validate: [...input.validators],
-      ...input.writeback ? { writeback: input.writeback } : {},
-      ...input.edits ? { edits: input.edits } : {},
-      ...input.effects ? { effects: input.effects } : {}
-    },
-    ...input.description !== undefined ? { description: input.description } : {}
-  };
-  return asPublicActionType(Object.assign(definition, {
-    edits(handler) {
-      return createGlobalDefinition({
-        ...input,
-        edits: handler
-      });
-    },
-    effects(handler) {
-      if (!input.edits) {
-        throw new ActionDefinitionError2(effectsWithoutEditsMessage(input.id));
-      }
-      return createGlobalDefinition({
-        ...input,
-        effects: handler
-      });
-    }
-  }));
-}
-function createObjectDefinition(input) {
-  const definition = {
-    kind: "action",
-    id: input.id,
-    binding: { kind: "object", objectType: input.objectType },
-    params: input.params,
-    phases: {
-      validate: [...input.validators],
-      ...input.writeback ? { writeback: input.writeback } : {},
-      ...input.edits ? { edits: input.edits } : {},
-      ...input.effects ? { effects: input.effects } : {}
-    },
-    ...input.description !== undefined ? { description: input.description } : {}
-  };
-  return asPublicActionType(Object.assign(definition, {
-    edits(handler) {
-      return createObjectDefinition({
-        ...input,
-        edits: handler
-      });
-    },
-    effects(handler) {
-      if (!input.edits) {
-        throw new ActionDefinitionError2(effectsWithoutEditsMessage(input.id));
-      }
-      return createObjectDefinition({
-        ...input,
-        effects: handler
-      });
-    }
-  }));
-}
-function asPublicActionType(value) {
-  return value;
-}
-// src/shared/params/builders.ts
-function param2(schema, options) {
-  const result = {
-    schema,
-    required: true,
-    ...options?.description !== undefined ? { description: options.description } : {},
-    ...options?.semanticType !== undefined ? { semanticType: options.semanticType } : {},
-    ...options?.nullable !== undefined ? { nullable: options.nullable } : {}
-  };
-  return result;
-}
-function optional2(paramConfig) {
-  return {
-    ...paramConfig,
-    required: false
-  };
-}
-// src/actions/commit-edits.ts
-var NO_READ_DEPENDENCIES = { objects: [], links: [], linkScopes: [] };
-async function commitActionEdits2(input) {
-  const dependencies = input.dependencies ?? NO_READ_DEPENDENCIES;
-  const commit = await input.mutations.commitEdits({
-    mode: "atomic",
-    source: { kind: "action", actionId: input.actionId, runId: input.runId },
-    operations: lowerEditBatch2(input.batch),
-    expectedObjects: dependencies.objects,
-    expectedLinks: dependencies.links,
-    expectedLinkScopes: dependencies.linkScopes
-  });
-  return toActionEditCommitResult(commit);
-}
-async function findActionEditCommit2(input) {
-  const record = await input.storage.ontology.commits.getByOrigin({
-    projectId: input.projectId,
-    origin: { kind: "action", actionRunId: input.runId }
-  });
-  if (!record)
-    return null;
-  if (record.result.kind !== "edit") {
-    throw new ActionEditCommitError2(`[Sixb] Action run '${input.runId}' resolved a '${record.result.kind}' commit instead of an edit commit.`);
-  }
-  return toActionEditCommitResult({ ...record.result, created: false });
-}
-function toActionEditCommitResult(commit) {
-  return {
-    commitId: commit.commitId,
-    created: commit.created,
-    eventCount: commit.eventCount,
-    outcomes: commit.outcomes,
-    changes: commit.changes,
-    committedAt: new Date(commit.committedAt)
-  };
-}
-// src/actions/read-facade.ts
-class ActionReadRecorder2 {
-  objects = new Map;
-  links = new Map;
-  linkScopes = new Map;
-  observeObject(ref, row) {
-    const key = objectRefKey2(ref);
-    if (this.objects.has(key))
-      return;
-    if (!row) {
-      this.objects.set(key, { ref, exists: false });
-      return;
-    }
-    if (row.lastCommitId === undefined)
-      return;
-    this.objects.set(key, {
-      ref,
-      exists: true,
-      version: row.version,
-      lastCommitId: row.lastCommitId
-    });
-  }
-  observeObjectRows(rows) {
-    for (const row of rows) {
-      this.observeObject({ objectTypeId: row.objectTypeId, primaryId: row.primaryId }, row);
-      for (const value of Object.values(row.links ?? {})) {
-        this.observeObjectRows(expandedRows(value));
-      }
-    }
-  }
-  observeLinkScopes(source, linkIds, rows) {
-    const snapshotsByLinkId = new Map;
-    for (const linkId of linkIds)
-      snapshotsByLinkId.set(linkId, []);
-    const unfenceable = new Set;
-    for (const row of rows) {
-      if (row.sourceTypeId !== source.objectTypeId || row.sourceId !== source.primaryId)
-        continue;
-      const snapshots = snapshotsByLinkId.get(row.linkId);
-      if (!snapshots)
-        continue;
-      const snapshot = toLinkSnapshot(row);
-      if (!snapshot) {
-        unfenceable.add(row.linkId);
-        continue;
-      }
-      snapshots.push(snapshot);
-      this.observeLink(snapshot.ref, snapshot);
-    }
-    for (const [linkId, snapshots] of snapshotsByLinkId) {
-      if (unfenceable.has(linkId))
-        continue;
-      const key = linkScopeKey(source, linkId);
-      if (this.linkScopes.has(key))
-        continue;
-      this.linkScopes.set(key, {
-        source,
-        linkId,
-        fingerprint: createLinkScopeFingerprint2(snapshots)
-      });
-    }
-  }
-  observeLink(ref, snapshot) {
-    const key = linkRefKey2(ref);
-    if (this.links.has(key))
-      return;
-    this.links.set(key, snapshot ? { ref, exists: true, lastCommitId: snapshot.lastCommitId } : { ref, exists: false });
-  }
-  dependencies() {
-    return {
-      objects: [...this.objects.values()],
-      links: [...this.links.values()],
-      linkScopes: [...this.linkScopes.values()]
-    };
-  }
-}
-function createActionReadFacade2(reader, options) {
-  return {
-    telemetry: createActionTelemetryReadFacade(options?.telemetry),
-    objects(objectType) {
-      const objectSet = reader.objects(objectType);
-      return options ? recordObjectReads(objectType, objectSet, options) : objectSet;
-    }
-  };
-}
-function createActionTelemetryReadFacade(source) {
-  const facade = {
-    async historyBatch(input) {
-      if (!source) {
-        throw new RuntimeError2("[Sixb] Action telemetry history requires a configured telemetry read source.");
-      }
-      if (input.series.length === 0) {
-        return [];
-      }
-      const requestedSeries = input.series.map((entry) => {
-        const objectType = source.resolveObjectType(entry.property.objectTypeId);
-        assertPropertyTokenBelongsToObjectType2(objectType, entry.property);
-        const registeredProperty = objectType.properties.find((property) => property.id === entry.property.id);
-        if (!registeredProperty) {
-          throw new OntologyValidationError2(`[Sixb] Unknown property '${entry.property.id}' for object type '${objectType.id}'`);
-        }
-        assertTelemetryProperty2(registeredProperty);
-        return {
-          objectTypeId: objectType.id,
-          objectId: entry.objectId,
-          propertyId: registeredProperty.id
-        };
-      });
-      const results = await source.getHistoryBatch({
-        series: requestedSeries,
-        ...input.from !== undefined ? { from: input.from } : {},
-        ...input.to !== undefined ? { to: input.to } : {},
-        ...input.limitPerSeries !== undefined ? { limitPerSeries: input.limitPerSeries } : {},
-        ...input.order !== undefined ? { order: input.order } : {}
-      });
-      assertTelemetryBatchResultMatchesRequest(requestedSeries, results);
-      return input.series.map((entry, index) => ({
-        objectId: entry.objectId,
-        property: entry.property,
-        points: results[index].points.map((point) => ({
-          value: point.value,
-          at: point.at,
-          ...point.unit !== undefined ? { unit: point.unit } : {}
-        }))
-      }));
-    }
-  };
-  return facade;
-}
-function assertTelemetryBatchResultMatchesRequest(requested, results) {
-  if (results.length !== requested.length) {
-    throw new RuntimeError2(`[Sixb] Telemetry history provider returned ${results.length} batch results for ${requested.length} requested series.`);
-  }
-  for (let index = 0;index < requested.length; index += 1) {
-    const expected = requested[index];
-    const actual = results[index];
-    if (actual.objectTypeId !== expected.objectTypeId || actual.objectId !== expected.objectId || actual.propertyId !== expected.propertyId) {
-      throw new RuntimeError2(`[Sixb] Telemetry history provider returned an unexpected series at batch index ${index}.`);
-    }
-  }
-}
-function recordObjectReads(objectType, objectSet, options) {
-  const { recorder } = options;
-  const ref = (primaryId) => ({
-    objectTypeId: objectType.id,
-    primaryId
-  });
-  return {
-    async get(id) {
-      const row = await objectSet.get(id);
-      recorder.observeObject(ref(id), row && storageRow(row));
-      return row;
-    },
-    query() {
-      return decorateObjectQueryExecutor(objectSet.query(), (executor) => recordingExecutor(executor, recorder));
-    },
-    async list(input) {
-      const result = await objectSet.list(input);
-      recorder.observeObjectRows(result.objects.map(storageRow));
-      return result;
-    },
-    byId(id) {
-      const handle = objectSet.byId(id);
-      return {
-        async get() {
-          const row = await handle.get();
-          recorder.observeObject(ref(id), row && storageRow(row));
-          return row;
-        },
-        async listLinks(link) {
-          const rows = await handle.listLinks(link);
-          recorder.observeLinkScopes(ref(id), link ? [link.id] : options.resolveLinkIds(objectType.id), rows);
-          return rows;
-        },
-        file: handle.file
-      };
-    }
-  };
-}
-function recordingExecutor(executor, recorder) {
-  return {
-    async list(query, listOptions) {
-      const result = await executor.list(query, listOptions);
-      recorder.observeObjectRows(result.objects.map(storageRow));
-      return result;
-    },
-    count: (query) => executor.count(query),
-    exists: (query) => executor.exists(query),
-    facets: (query, facets) => executor.facets(query, facets),
-    validate: executor.validate?.bind(executor),
-    explain: executor.explain?.bind(executor)
-  };
-}
-function storageRow(row) {
-  return row;
-}
-function expandedRows(value) {
-  if (value === null)
-    return [];
-  return isExpandedRowList(value) ? value : [value];
-}
-function isExpandedRowList(value) {
-  return Array.isArray(value);
-}
-function toLinkSnapshot(row) {
-  if (row.lastCommitId === undefined)
-    return null;
-  return {
-    ref: {
-      source: { objectTypeId: row.sourceTypeId, primaryId: row.sourceId },
-      linkId: row.linkId,
-      target: { objectTypeId: row.targetTypeId, primaryId: row.targetId }
-    },
-    ...row.properties !== undefined ? { properties: row.properties } : {},
-    createdAt: row.createdAt.toISOString(),
-    updatedAt: row.updatedAt.toISOString(),
-    lastCommitId: row.lastCommitId
-  };
-}
-// src/actions/registry.ts
-class ActionRegistry2 {
-  byId = new Map;
-  globalActions = [];
-  byTargetId = new Map;
-  ontology;
-  constructor(options) {
-    this.ontology = options.ontology;
-    for (const action of options.actions) {
-      const previous = this.byId.get(action.id);
-      if (previous) {
-        const chainDuplicate = this.getInheritanceDuplicate(action, previous);
-        if (chainDuplicate) {
-          throw new ActionDefinitionError2(`Duplicate action id "${action.id}" in inheritance chain of "${chainDuplicate.objectTypeId}": defined on both "${chainDuplicate.firstTargetId}" and "${chainDuplicate.secondTargetId}".`);
-        }
-        throw new ActionDefinitionError2(`Duplicate action id "${action.id}" declared in multiple files.`);
-      }
-      this.validatePhases(action);
-      this.byId.set(action.id, action);
-      if (!isObjectActionDefinition2(action)) {
-        this.globalActions.push(action);
-        continue;
-      }
-      const objectType = action.binding.objectType;
-      const target = this.ontology.getObjectTypeById(objectType.id);
-      if (!target) {
-        throw new ActionDefinitionError2(`Action "${action.id}" targets unknown object type "${objectType.id}". Add the object type to ontology before registering the action.`);
-      }
-      const bucket = this.byTargetId.get(objectType.id) ?? [];
-      bucket.push(action);
-      this.byTargetId.set(objectType.id, bucket);
-    }
-  }
-  validatePhases(action) {
-    const hasWriteback = action.phases.writeback !== undefined;
-    const hasEdits = action.phases.edits !== undefined;
-    const hasEffects = action.phases.effects !== undefined;
-    if (!hasWriteback && !hasEdits) {
-      throw new ActionDefinitionError2(missingActionMutationMessage(action.id));
-    }
-    if (hasEffects && !hasEdits) {
-      throw new ActionDefinitionError2(effectsWithoutEditsMessage(action.id));
-    }
-  }
-  list() {
-    return [...this.byId.values()];
-  }
-  getById(id) {
-    return this.byId.get(id) ?? null;
-  }
-  listGlobal() {
-    return [...this.globalActions];
-  }
-  listForType(type) {
-    this.ontology.resolveObjectType(type.id);
-    const seen = new Set;
-    const result = [];
-    for (const ancestor of this.ontology.listAncestorChain(type)) {
-      for (const action of this.byTargetId.get(ancestor.id) ?? []) {
-        if (seen.has(action.id))
-          continue;
-        seen.add(action.id);
-        result.push(action);
-      }
-    }
-    return result;
-  }
-  getInheritanceDuplicate(action, previous) {
-    if (!isObjectActionDefinition2(action) || !isObjectActionDefinition2(previous)) {
-      return null;
-    }
-    const actionObjectType = action.binding.objectType;
-    const previousObjectType = previous.binding.objectType;
-    if (actionObjectType.id === previousObjectType.id) {
-      return null;
-    }
-    const actionChain = this.ontology.listAncestorChain(actionObjectType);
-    if (actionChain.some((ancestor) => ancestor.id === previousObjectType.id)) {
-      return {
-        objectTypeId: actionObjectType.id,
-        firstTargetId: previousObjectType.id,
-        secondTargetId: actionObjectType.id
-      };
-    }
-    const previousChain = this.ontology.listAncestorChain(previousObjectType);
-    if (previousChain.some((ancestor) => ancestor.id === actionObjectType.id)) {
-      return {
-        objectTypeId: previousObjectType.id,
-        firstTargetId: actionObjectType.id,
-        secondTargetId: previousObjectType.id
-      };
-    }
-    return null;
-  }
-}
-// src/actions/validators.ts
-async function runActionValidators2(input) {
-  const validators = input.action.phases.validate;
-  if (validators.length === 0) {
-    return;
-  }
-  if (!isObjectActionDefinition2(input.action)) {
-    for (const validator of validators) {
-      const result = await validator(input.baseContext);
-      if (isValidatorErrorResult(result)) {
-        throw new ActionValidationError2(result.error, {
-          actionId: input.action.id,
-          subject: input.subject
-        });
-      }
-    }
-    return;
-  }
-  if (!input.target) {
-    throw new Error(`[Sixb] Action '${input.action.id}' requires an object target.`);
-  }
-  for (const validator of validators) {
-    const result = await validator({
-      ...input.baseContext,
-      target: input.target
-    });
-    if (isValidatorErrorResult(result)) {
-      throw new ActionValidationError2(result.error, {
-        actionId: input.action.id,
-        subject: input.subject
-      });
-    }
-  }
-}
-function isValidatorErrorResult(value) {
-  return typeof value === "object" && value !== null && "error" in value && typeof value.error === "string";
-}
-export { defineAction2, param2, optional2, commitActionEdits2, findActionEditCommit2, ActionReadRecorder2, createActionReadFacade2, ActionRegistry2, runActionValidators2 };
-
-//# debugId=566997B478269C6164756E2164756E21