@sixb/core 0.0.1

package/src/events/selectors/types.ts

@@ -0,0 +1,258 @@
+import type {
+  ActionBinding,
+  ActionDefinition,
+  ActionParamsConfig,
+  InferActionParams,
+} from "../../actions"
+import type { LinkToken, ObjectRef, ObjectTypeWithTokens, Property } from "../../ontology"
+import type { InferPropertyValue } from "../../ontology/inference"
+import type { RuleDefinition } from "../../rules"
+import type { ActionRunFailure } from "../../storage"
+import type { PropertyChangeOperation } from "../property-changes"
+import type {
+  DatasetVersionCommittedEvent,
+  DomainEvent,
+  PipelineRunFinishedEvent,
+  SyncRunFinishedEvent,
+} from "../types"
+
+declare const eventSelectorContextType: unique symbol
+
+export type ObjectEventSelectorContext<
+  TObjectType extends ObjectTypeWithTokens = ObjectTypeWithTokens,
+> = {
+  readonly kind: "object"
+  readonly objectType: TObjectType
+}
+
+export type LinkEventSelectorContext<
+  TObjectType extends ObjectTypeWithTokens = ObjectTypeWithTokens,
+  TLink extends LinkToken<TObjectType["id"]> = LinkToken<TObjectType["id"]>,
+> = {
+  readonly kind: "link"
+  readonly objectType: TObjectType
+  readonly link: TLink
+}
+
+export type RuleEventSelectorOperation = "triggered" | "resolved"
+
+export type RuleEventSelectorContext<
+  TRule extends RuleDefinition = RuleDefinition,
+  TOperation extends RuleEventSelectorOperation = RuleEventSelectorOperation,
+> = {
+  readonly kind: "rule"
+  readonly rule: TRule
+  readonly operation: TOperation
+}
+
+export type ActionEventSelectorOperation = "requested" | "completed" | "failed"
+
+export type ActionEventToken<
+  TId extends string = string,
+  TParams extends ActionParamsConfig = ActionParamsConfig,
+  TBinding extends ActionBinding = ActionBinding,
+> = {
+  readonly id: TId
+  readonly params: TParams
+  readonly binding: TBinding
+}
+
+export type ActionEventTokenOf<TAction extends ActionDefinition> = ActionEventToken<
+  TAction["id"],
+  TAction["params"],
+  TAction["binding"]
+>
+
+export type ActionEventSelectorContext<
+  TAction extends ActionEventToken = ActionEventToken,
+  TOperation extends ActionEventSelectorOperation = ActionEventSelectorOperation,
+> = {
+  readonly kind: "action"
+  readonly action: TAction
+  readonly operation: TOperation
+}
+
+export type DatasetEventToken<TId extends string = string> = {
+  readonly kind: "dataset"
+  readonly id: TId
+}
+
+export type SyncEventToken<TId extends string = string> = {
+  readonly kind: "sync"
+  readonly id: TId
+}
+
+export type PipelineEventToken<TId extends string = string> = {
+  readonly kind: "pipeline"
+  readonly id: TId
+}
+
+export type DatasetEventSelectorContext<TDataset extends DatasetEventToken = DatasetEventToken> = {
+  readonly kind: "dataset"
+  readonly dataset: TDataset
+}
+
+export type RunEventSelectorOperation = "succeeded" | "failed" | "cancelled"
+
+export type SyncEventSelectorContext<
+  TSync extends SyncEventToken = SyncEventToken,
+  TOperation extends RunEventSelectorOperation = RunEventSelectorOperation,
+> = {
+  readonly kind: "sync"
+  readonly sync: TSync
+  readonly operation: TOperation
+}
+
+export type PipelineEventSelectorContext<
+  TPipeline extends PipelineEventToken = PipelineEventToken,
+  TOperation extends RunEventSelectorOperation = RunEventSelectorOperation,
+> = {
+  readonly kind: "pipeline"
+  readonly pipeline: TPipeline
+  readonly operation: TOperation
+}
+
+export type EventSelectorContext =
+  | ObjectEventSelectorContext
+  | LinkEventSelectorContext
+  | RuleEventSelectorContext
+  | ActionEventSelectorContext
+  | DatasetEventSelectorContext
+  | SyncEventSelectorContext
+  | PipelineEventSelectorContext
+
+export type InferEventSelectorContext<TSelector> = TSelector extends {
+  readonly [eventSelectorContextType]?: infer TContext
+}
+  ? NonNullable<TContext>
+  : EventSelectorContext
+
+export type InferEventSelectorEvent<TSelector> = EventSelectorEvent<
+  InferEventSelectorContext<TSelector>
+>
+
+export type EventSelectorEvent<TContext> =
+  TContext extends ObjectEventSelectorContext<infer TObjectType>
+    ? ObjectEventSelectorEvent<TObjectType>
+    : TContext extends LinkEventSelectorContext<infer TObjectType, infer TLink>
+      ? LinkEventSelectorEvent<TObjectType, TLink>
+      : TContext extends RuleEventSelectorContext<infer TRule, infer TOperation>
+        ? RuleEventSelectorEvent<TRule, TOperation>
+        : TContext extends ActionEventSelectorContext<infer TAction, infer TOperation>
+          ? ActionEventSelectorEvent<TAction, TOperation>
+          : TContext extends DatasetEventSelectorContext<infer TDataset>
+            ? DatasetEventSelectorEvent<TDataset>
+            : TContext extends SyncEventSelectorContext<infer TSync, infer TOperation>
+              ? SyncEventSelectorEvent<TSync, TOperation>
+              : TContext extends PipelineEventSelectorContext<infer TPipeline, infer TOperation>
+                ? PipelineEventSelectorEvent<TPipeline, TOperation>
+                : never
+
+export interface ObjectEventSelectorEvent<TObjectType extends ObjectTypeWithTokens> {
+  readonly object: {
+    readonly objectTypeId: TObjectType["id"]
+    readonly primaryId: string
+    readonly p: ObjectPropertyValues<TObjectType>
+  }
+}
+
+export interface LinkEventSelectorEvent<
+  _TObjectType extends ObjectTypeWithTokens,
+  TLink extends LinkToken,
+> {
+  readonly source: ObjectRef<TLink["objectTypeId"]>
+  readonly target: ObjectRef<ResolveTargetTypeId<TLink["targetObjectTypeId"]>>
+  readonly link: {
+    readonly id: TLink["id"]
+    readonly p: LinkPropertyValues<TLink>
+  }
+}
+
+export type RuleEventSelectorEvent<
+  TRule extends RuleDefinition = RuleDefinition,
+  _TOperation extends RuleEventSelectorOperation = RuleEventSelectorOperation,
+> = {
+  readonly ruleId: TRule["id"]
+  readonly subject: ObjectRef<RuleSubjectTypeId<TRule>>
+}
+
+export type ActionEventSelectorEvent<
+  TAction extends ActionEventToken = ActionEventToken,
+  TOperation extends ActionEventSelectorOperation = ActionEventSelectorOperation,
+> = {
+  readonly actionId: TAction["id"]
+  readonly runId: string
+} & ActionSubjectEvent<TAction> &
+  (TOperation extends "requested"
+    ? { readonly params: InferActionParams<TAction["params"]> }
+    : TOperation extends "failed"
+      ? { readonly error: ActionRunFailure }
+      : Record<never, never>)
+
+export type DatasetEventSelectorEvent<TDataset extends DatasetEventToken = DatasetEventToken> =
+  Omit<DatasetVersionCommittedEvent["payload"], "datasetId"> & {
+    readonly datasetId: TDataset["id"]
+  }
+
+export type SyncEventSelectorEvent<
+  TSync extends SyncEventToken = SyncEventToken,
+  TOperation extends RunEventSelectorOperation = RunEventSelectorOperation,
+> = Omit<SyncRunFinishedEvent["payload"], "syncId" | "status"> & {
+  readonly syncId: TSync["id"]
+  readonly status: TOperation
+}
+
+export type PipelineEventSelectorEvent<
+  TPipeline extends PipelineEventToken = PipelineEventToken,
+  TOperation extends RunEventSelectorOperation = RunEventSelectorOperation,
+> = Omit<PipelineRunFinishedEvent["payload"], "pipelineId" | "status"> & {
+  readonly pipelineId: TPipeline["id"]
+  readonly status: TOperation
+}
+
+export interface EventSelectorSpec<TContext = EventSelectorContext> {
+  readonly [eventSelectorContextType]?: TContext
+  readonly topic?: DomainEvent["topic"]
+  readonly types?: readonly DomainEvent["type"][]
+  readonly objectTypeId?: string
+  readonly primaryId?: string
+  readonly propertyId?: string
+  readonly propertyOperation?: PropertyChangeOperation
+  readonly linkId?: string
+  readonly ruleId?: string
+  readonly actionId?: string
+  readonly datasetId?: string
+  readonly syncId?: string
+  readonly pipelineId?: string
+  readonly runStatus?: RunEventSelectorOperation
+  readonly runId?: string
+}
+
+type ObjectPropertyValues<TObjectType extends ObjectTypeWithTokens> = {
+  readonly [TProperty in TObjectType["properties"][number] as TProperty["id"]]: InferPropertyValue<TProperty>
+}
+
+type LinkPropertyValues<TLink extends LinkToken> =
+  NonNullable<TLink["link"]["properties"]> extends readonly Property[]
+    ? {
+        readonly [TProperty in NonNullable<
+          TLink["link"]["properties"]
+        >[number] as TProperty["id"]]: InferPropertyValue<TProperty>
+      }
+    : Record<never, never>
+
+type ResolveTargetTypeId<TTarget> = TTarget extends readonly string[]
+  ? TTarget[number]
+  : TTarget extends string
+    ? TTarget
+    : string
+
+type RuleSubjectTypeId<TRule extends RuleDefinition> =
+  TRule extends RuleDefinition<string, infer TObjectType> ? TObjectType["id"] : string
+
+type ActionSubjectEvent<TAction extends ActionEventToken> = TAction["binding"] extends {
+  readonly kind: "object"
+  readonly objectType: infer TObjectType extends { readonly id: string }
+}
+  ? { readonly subject: ObjectRef<TObjectType["id"]> }
+  : Record<never, never>

package/src/events/toStoredEvent.ts

@@ -0,0 +1,35 @@
+import { randomUUID } from "node:crypto"
+import { resolveEventStorage } from "./definitions"
+import type { EventActor, EventDraft, StoredAuthorableEvent } from "./types/index"
+
+export function toStoredEvent(params: {
+  projectId: string
+  actor?: EventActor
+  correlationId?: string
+  causationId?: string
+  event: EventDraft
+  cursor: string
+}): StoredAuthorableEvent {
+  const base = {
+    id: randomUUID(),
+    schemaVersion: 1 as const,
+    projectId: params.projectId,
+    occurredAt: params.event.occurredAt ?? new Date().toISOString(),
+    correlationId: params.correlationId,
+    causationId: params.causationId,
+    idempotencyKey: params.event.idempotencyKey,
+    actor: params.actor,
+    origin: params.event.origin,
+    metadata: params.event.metadata,
+    cursor: params.cursor,
+  }
+
+  const storage = resolveEventStorage(params.event)
+  return {
+    ...base,
+    type: params.event.type,
+    topic: storage.topic,
+    partitionKey: storage.partitionKey,
+    payload: params.event.payload,
+  } as StoredAuthorableEvent
+}

package/src/events/types/actions.ts

@@ -0,0 +1,42 @@
+import type { ActionSubject } from "../../actions"
+import type { ActionRunFailure } from "../../storage"
+import type { EventEnvelope } from "../envelope"
+
+export interface ActionRequestedEvent extends EventEnvelope {
+  type: "action.requested"
+  topic: "actions"
+  partitionKey: string
+  payload: {
+    actionId: string
+    subject: ActionSubject
+    params: Record<string, unknown>
+    runId: string
+  }
+}
+
+export interface ActionCompletedEvent extends EventEnvelope {
+  type: "action.completed"
+  topic: "actions"
+  partitionKey: string
+  payload: {
+    actionId: string
+    runId: string
+    subject: ActionSubject
+    finishedAt: string
+  }
+}
+
+export interface ActionFailedEvent extends EventEnvelope {
+  type: "action.failed"
+  topic: "actions"
+  partitionKey: string
+  payload: {
+    actionId: string
+    runId: string
+    subject: ActionSubject
+    error: ActionRunFailure
+    finishedAt: string
+  }
+}
+
+export type ActionEvent = ActionRequestedEvent | ActionCompletedEvent | ActionFailedEvent

package/src/events/types/datasets.ts

@@ -0,0 +1,21 @@
+import type { EventEnvelope } from "../envelope"
+
+export interface DatasetVersionCommittedEvent extends EventEnvelope {
+  type: "dataset.version.committed"
+  topic: "datasets"
+  partitionKey: string
+  payload: {
+    datasetId: string
+    versionId: string
+    /** Canonical UTC ISO timestamp from the committed immutable dataset version. */
+    createdAt: string
+    producer: {
+      kind: "sync" | "pipeline"
+      id?: string
+      runId?: string
+      stepId?: string
+    }
+  }
+}
+
+export type DatasetEvent = DatasetVersionCommittedEvent

package/src/events/types/index.ts

@@ -0,0 +1,206 @@
+import type { JsonValue } from "../../json"
+import type { OntologyMaterializationEvent } from "../../materialization/events"
+import type { EventOrigin } from "../envelope"
+import type { ActionEvent } from "./actions"
+import type { DatasetEvent } from "./datasets"
+import type { LinkEvent } from "./links"
+import type { ObjectEvent } from "./objects"
+import type { PipelineEvent } from "./pipelines"
+import type { RuleEvent } from "./rules"
+import type { ScheduleEvent } from "./schedules"
+import type { SyncEvent } from "./syncs"
+import type { TelemetryEvent } from "./telemetry"
+import type { WorkflowEvent } from "./workflows"
+
+export type {
+  ActionEventOrigin,
+  EventActor,
+  EventEnvelope,
+  EventOrigin,
+  ProjectionEventOrigin,
+  ProjectionTelemetryEventSource,
+  RuntimeMutationEventOrigin,
+  TelemetryEventOrigin,
+  TelemetryEventSource,
+} from "../envelope"
+export type {
+  PropertyChange,
+  PropertyChangeMap,
+  PropertyChangeOperation,
+} from "../property-changes"
+export type {
+  ActionCompletedEvent,
+  ActionEvent,
+  ActionFailedEvent,
+  ActionRequestedEvent,
+} from "./actions"
+export type { DatasetEvent, DatasetVersionCommittedEvent } from "./datasets"
+export type {
+  LinkCreatedEvent,
+  LinkDeletedEvent,
+  LinkEvent,
+  LinkUpdatedEvent,
+} from "./links"
+export type {
+  ObjectCreatedEvent,
+  ObjectDeletedEvent,
+  ObjectEvent,
+  ObjectUpdatedEvent,
+} from "./objects"
+export type {
+  PipelineEvent,
+  PipelineRunFinishedEvent,
+  PipelineRunStartedEvent,
+  PipelineRunStepFinishedEvent,
+  PipelineRunStepStartedEvent,
+} from "./pipelines"
+export type {
+  RuleEvent,
+  RuleEventSubject,
+  RuleResolvedEvent,
+  RuleTriggeredEvent,
+} from "./rules"
+export type { ScheduleEvent, ScheduleTriggeredEvent } from "./schedules"
+export type { SyncEvent, SyncRunFinishedEvent, SyncRunStartedEvent } from "./syncs"
+export type { TelemetryAppendedEvent, TelemetryEvent } from "./telemetry"
+export type {
+  WorkflowEvent,
+  WorkflowInterventionCancelledEvent,
+  WorkflowInterventionExpiredEvent,
+  WorkflowInterventionRequestedEvent,
+  WorkflowInterventionSubmittedEvent,
+  WorkflowRunFinishedEvent,
+  WorkflowRunNodeFinishedEvent,
+  WorkflowRunNodeStartedEvent,
+  WorkflowRunNodeWaitingEvent,
+  WorkflowRunQueuedEvent,
+  WorkflowRunStartedEvent,
+  WorkflowRunWaitingEvent,
+} from "./workflows"
+
+export type DomainEvent =
+  | ObjectEvent
+  | TelemetryEvent
+  | LinkEvent
+  | ActionEvent
+  | ScheduleEvent
+  | RuleEvent
+  | SyncEvent
+  | PipelineEvent
+  | WorkflowEvent
+  | DatasetEvent
+
+export type OntologyDomainEvent = ObjectEvent | LinkEvent | TelemetryEvent
+export type AuthorableDomainEvent = Exclude<DomainEvent, OntologyDomainEvent>
+
+export type StoredAuthorableEvent = AuthorableDomainEvent & { readonly cursor: string }
+export type StoredOntologyMaterializationEvent = OntologyMaterializationEvent & {
+  readonly cursor: string
+}
+export type StoredDomainEvent = StoredAuthorableEvent | StoredOntologyMaterializationEvent
+
+export type DomainEventDraft = {
+  [K in DomainEvent["type"]]: {
+    type: K
+    payload: Extract<DomainEvent, { type: K }>["payload"]
+    occurredAt?: string
+    origin?: EventOrigin
+    metadata?: Record<string, JsonValue>
+    idempotencyKey?: string
+  }
+}[DomainEvent["type"]]
+
+/** Events callers may author directly. Ontology facts are reserved for the Materializer outbox. */
+export type AuthorableEventDraft = Extract<
+  DomainEventDraft,
+  { readonly type: AuthorableDomainEvent["type"] }
+>
+export type EventDraft = AuthorableEventDraft
+
+type StoredOntologyEventOf<TType extends OntologyMaterializationEvent["type"]> =
+  StoredOntologyMaterializationEvent & { readonly type: TType }
+
+export type StoredObjectCreatedEvent = StoredOntologyEventOf<"object.created">
+export type StoredObjectUpdatedEvent = StoredOntologyEventOf<"object.updated">
+export type StoredObjectMutationEvent = StoredObjectCreatedEvent | StoredObjectUpdatedEvent
+export type StoredObjectDeletedEvent = StoredOntologyEventOf<"object.deleted">
+export type StoredTelemetryAppendedEvent = StoredOntologyEventOf<"telemetry.appended">
+export type StoredLinkCreatedEvent = StoredOntologyEventOf<"link.created">
+export type StoredLinkUpdatedEvent = StoredOntologyEventOf<"link.updated">
+export type StoredLinkMutationEvent = StoredLinkCreatedEvent | StoredLinkUpdatedEvent
+export type StoredLinkDeletedEvent = StoredOntologyEventOf<"link.deleted">
+export type StoredActionRequestedEvent = Extract<StoredDomainEvent, { type: "action.requested" }>
+export type StoredActionCompletedEvent = Extract<StoredDomainEvent, { type: "action.completed" }>
+export type StoredActionFailedEvent = Extract<StoredDomainEvent, { type: "action.failed" }>
+export type StoredScheduleTriggeredEvent = Extract<
+  StoredDomainEvent,
+  { type: "schedule.triggered" }
+>
+export type StoredRuleTriggeredEvent = Extract<StoredDomainEvent, { type: "rule.triggered" }>
+export type StoredRuleResolvedEvent = Extract<StoredDomainEvent, { type: "rule.resolved" }>
+export type StoredSyncRunStartedEvent = Extract<StoredDomainEvent, { type: "sync.run.started" }>
+export type StoredSyncRunFinishedEvent = Extract<StoredDomainEvent, { type: "sync.run.finished" }>
+export type StoredPipelineRunStartedEvent = Extract<
+  StoredDomainEvent,
+  { type: "pipeline.run.started" }
+>
+export type StoredPipelineRunStepStartedEvent = Extract<
+  StoredDomainEvent,
+  { type: "pipeline.run.step.started" }
+>
+export type StoredPipelineRunStepFinishedEvent = Extract<
+  StoredDomainEvent,
+  { type: "pipeline.run.step.finished" }
+>
+export type StoredPipelineRunFinishedEvent = Extract<
+  StoredDomainEvent,
+  { type: "pipeline.run.finished" }
+>
+export type StoredWorkflowRunQueuedEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.run.queued" }
+>
+export type StoredWorkflowRunStartedEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.run.started" }
+>
+export type StoredWorkflowRunNodeStartedEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.run.node.started" }
+>
+export type StoredWorkflowRunWaitingEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.run.waiting" }
+>
+export type StoredWorkflowRunNodeWaitingEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.run.node.waiting" }
+>
+export type StoredWorkflowRunNodeFinishedEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.run.node.finished" }
+>
+export type StoredWorkflowRunFinishedEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.run.finished" }
+>
+export type StoredWorkflowInterventionRequestedEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.intervention.requested" }
+>
+export type StoredWorkflowInterventionSubmittedEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.intervention.submitted" }
+>
+export type StoredWorkflowInterventionCancelledEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.intervention.cancelled" }
+>
+export type StoredWorkflowInterventionExpiredEvent = Extract<
+  StoredDomainEvent,
+  { type: "workflow.intervention.expired" }
+>
+export type StoredDatasetVersionCommittedEvent = Extract<
+  StoredDomainEvent,
+  { type: "dataset.version.committed" }
+>

package/src/events/types/links.ts

@@ -0,0 +1,42 @@
+import type { EventEnvelope } from "../envelope"
+import type { PropertyChangeMap } from "../property-changes"
+
+interface LinkEventSubject {
+  sourceTypeId: string
+  sourceId: string
+  linkId: string
+  targetTypeId: string
+  targetId: string
+}
+
+export interface LinkMutationEventPayload<TValue = unknown> extends LinkEventSubject {
+  properties?: Record<string, TValue>
+  propertyChanges: PropertyChangeMap<TValue>
+}
+
+export interface LinkDeletedEventPayload<TValue = unknown> extends LinkEventSubject {
+  propertyChanges: PropertyChangeMap<TValue>
+}
+
+export interface LinkCreatedEvent extends EventEnvelope {
+  type: "link.created"
+  topic: "links"
+  partitionKey: string
+  payload: LinkMutationEventPayload
+}
+
+export interface LinkUpdatedEvent extends EventEnvelope {
+  type: "link.updated"
+  topic: "links"
+  partitionKey: string
+  payload: LinkMutationEventPayload
+}
+
+export interface LinkDeletedEvent extends EventEnvelope {
+  type: "link.deleted"
+  topic: "links"
+  partitionKey: string
+  payload: LinkDeletedEventPayload
+}
+
+export type LinkEvent = LinkCreatedEvent | LinkUpdatedEvent | LinkDeletedEvent

package/src/events/types/objects.ts

@@ -0,0 +1,38 @@
+import type { EventEnvelope } from "../envelope"
+import type { PropertyChangeMap } from "../property-changes"
+
+export interface ObjectMutationEventPayload<TValue = unknown> {
+  objectTypeId: string
+  primaryId: string
+  properties: Record<string, TValue>
+  propertyChanges: PropertyChangeMap<TValue>
+}
+
+export interface ObjectDeletedEventPayload<TValue = unknown> {
+  objectTypeId: string
+  primaryId: string
+  propertyChanges: PropertyChangeMap<TValue>
+}
+
+export interface ObjectCreatedEvent extends EventEnvelope {
+  type: "object.created"
+  topic: "objects"
+  partitionKey: string
+  payload: ObjectMutationEventPayload
+}
+
+export interface ObjectUpdatedEvent extends EventEnvelope {
+  type: "object.updated"
+  topic: "objects"
+  partitionKey: string
+  payload: ObjectMutationEventPayload
+}
+
+export interface ObjectDeletedEvent extends EventEnvelope {
+  type: "object.deleted"
+  topic: "objects"
+  partitionKey: string
+  payload: ObjectDeletedEventPayload
+}
+
+export type ObjectEvent = ObjectCreatedEvent | ObjectUpdatedEvent | ObjectDeletedEvent