@sixb/core 0.1.18 → 0.1.19

package/src/schedules/runtime.ts

@@ -100,26 +100,6 @@ export function buildEventScheduleContext(event: DomainEvent): RuntimeEventSched
           primaryId: event.payload.subject.primaryId,
         },
       }
-    case "action.requested":
-      return {
-        actionId: event.payload.actionId,
-        runId: event.payload.runId,
-        ...actionSubjectContext(event.payload.subject),
-        params: { ...event.payload.params },
-      }
-    case "action.completed":
-      return {
-        actionId: event.payload.actionId,
-        runId: event.payload.runId,
-        ...actionSubjectContext(event.payload.subject),
-      }
-    case "action.failed":
-      return {
-        actionId: event.payload.actionId,
-        runId: event.payload.runId,
-        ...actionSubjectContext(event.payload.subject),
-        error: event.payload.error,
-      }
     case "dataset.version.committed":
       return { ...event.payload }
     case "sync.run.finished":
@@ -131,27 +111,6 @@ export function buildEventScheduleContext(event: DomainEvent): RuntimeEventSched
   }
 }
 
-function actionSubjectContext(subject: {
-  readonly kind: "none" | "object"
-  readonly objectTypeId?: string
-  readonly primaryId?: string
-}): { readonly subject?: { readonly objectTypeId: string; readonly primaryId: string } } {
-  if (
-    subject.kind !== "object" ||
-    subject.objectTypeId === undefined ||
-    subject.primaryId === undefined
-  ) {
-    return {}
-  }
-
-  return {
-    subject: {
-      objectTypeId: subject.objectTypeId,
-      primaryId: subject.primaryId,
-    },
-  }
-}
-
 function fieldsForEvent(event: DomainEvent): Readonly<Record<string, unknown>> {
   if (event.topic !== "links") {
     return {}

package/src/schedules/validation.ts

@@ -8,7 +8,6 @@ import type { EventScheduleCondition, EventScheduleDefinition, ScheduleDefinitio
 const objectEventTypes = new Set(["object.created", "object.updated", "object.deleted"])
 const linkEventTypes = new Set(["link.created", "link.updated", "link.deleted"])
 const ruleEventTypes = new Set(["rule.triggered", "rule.resolved"])
-const actionEventTypes = new Set(["action.requested", "action.completed", "action.failed"])
 const datasetEventTypes = new Set(["dataset.version.committed"])
 const syncEventTypes = new Set(["sync.run.finished"])
 const pipelineEventTypes = new Set(["pipeline.run.finished"])
@@ -17,7 +16,6 @@ const linkIdentityFields = new Set(["target.objectTypeId", "target.primaryId"])
 
 export interface ValidateSchedulesAtStartupOptions {
   readonly registeredRuleIds?: ReadonlySet<string>
-  readonly registeredActionIds?: ReadonlySet<string>
   readonly registeredDatasetIds?: ReadonlySet<string>
   readonly registeredSyncIds?: ReadonlySet<string>
   readonly registeredPipelineIds?: ReadonlySet<string>
@@ -138,9 +136,6 @@ function assertEventSourceShape(
     case "rules":
       assertNonEmptyString(value.ruleId, `${path} ruleId`, createError)
       return
-    case "actions":
-      assertNonEmptyString(value.actionId, `${path} actionId`, createError)
-      return
     case "datasets":
       assertNonEmptyString(value.datasetId, `${path} datasetId`, createError)
       return
@@ -154,7 +149,7 @@ function assertEventSourceShape(
       return
     default:
       throw createError(
-        `${path} must select object, link, rule, action, dataset, sync, or pipeline events.`
+        `${path} must select object, link, rule, dataset, sync, or pipeline events.`
       )
   }
 }
@@ -212,15 +207,6 @@ function validateEventSchedule(
         "rule"
       )
       return
-    case "actions":
-      validateRegisteredSource(
-        schedule,
-        source.actionId,
-        options.registeredActionIds,
-        actionEventTypes,
-        "action"
-      )
-      return
     case "datasets":
       validateRegisteredSource(
         schedule,
@@ -294,7 +280,7 @@ function validateRegisteredSource(
   sourceId: string | undefined,
   registeredIds: ReadonlySet<string> | undefined,
   supportedTypes: ReadonlySet<string>,
-  sourceKind: "rule" | "action" | "dataset" | "sync" | "pipeline"
+  sourceKind: "rule" | "dataset" | "sync" | "pipeline"
 ): void {
   validateEventTypes(schedule, supportedTypes, sourceKind)
   if (!registeredIds?.has(sourceId ?? "")) {

package/src/security/every.ts

@@ -8,7 +8,7 @@
  *
  * They live under one `every` namespace on purpose. Spending seven of the best identifiers in
  * `@sixb/core` — `actions`, `workflows`, `syncs`, … — on an auxiliary subsystem collided with the
- * primitives themselves and with `events.actions()` / `logs.actions()` on the client.
+ * primitives themselves and with client builders such as `logs.actions()`.
  */
 
 import type { ActionDefinition } from "../actions/types"

package/src/storage/action-runs/idempotency.ts

@@ -1,13 +1,6 @@
 import type { ActionSubject } from "../../actions"
 import { stableJsonStringify } from "../../json"
-import type {
-  ActionRunEffectsRecord,
-  ActionRunPhase,
-  ActionRunRecord,
-  ActionRunWritebackRecord,
-  FinishActionRunInput,
-  QueueActionRunInput,
-} from "./types"
+import type { ActionRunEffectsRecord, ActionRunRecord, ActionRunWritebackRecord } from "./types"
 
 export function actionSubjectsEqual(left: ActionSubject, right: ActionSubject): boolean {
   if (left.kind !== right.kind) return false
@@ -20,6 +13,18 @@ export function actionRunParamsEqual(left: unknown, right: unknown): boolean {
   return stableJsonStringify(left) === stableJsonStringify(right)
 }
 
+/** Whether two runs carry the same request: the same Action, subject, and params. */
+export function actionRunRequestsEqual(
+  left: Pick<ActionRunRecord, "actionId" | "subject" | "params">,
+  right: Pick<ActionRunRecord, "actionId" | "subject" | "params">
+): boolean {
+  return (
+    left.actionId === right.actionId &&
+    actionSubjectsEqual(left.subject, right.subject) &&
+    actionRunParamsEqual(left.params, right.params)
+  )
+}
+
 export type ActionRunPhaseRecord = ActionRunWritebackRecord | ActionRunEffectsRecord
 
 export function actionRunPhaseRecordsEqual(
@@ -29,39 +34,6 @@ export function actionRunPhaseRecordsEqual(
   return actionRunParamsEqual(stripPhaseRecordCompletedAt(left), stripPhaseRecordCompletedAt(right))
 }
 
-export function finishActionRunPhase(
-  input: FinishActionRunInput,
-  current: ActionRunPhase | null | undefined
-): ActionRunPhase {
-  if (input.status === "succeeded") {
-    return input.phase ?? current ?? "validation"
-  }
-
-  return input.error.details.phase
-}
-
-export function canRequeueActionRunAfterEnqueueFailure(
-  existing: ActionRunRecord,
-  input: QueueActionRunInput
-): boolean {
-  return (
-    existing.status === "failed" &&
-    existing.phase === "enqueue" &&
-    existing.executionId === input.executionId &&
-    existing.error?.retryable === true &&
-    existing.actionId === input.actionId &&
-    existing.idempotencyKey === input.idempotencyKey &&
-    actionSubjectsEqual(existing.subject, input.subject) &&
-    actionRunParamsEqual(existing.params, input.params)
-  )
-}
-
-export function isTerminalActionRun(record: Pick<ActionRunRecord, "status">): boolean {
-  return (
-    record.status === "succeeded" || record.status === "failed" || record.status === "cancelled"
-  )
-}
-
 function stripPhaseRecordCompletedAt(
   record: ActionRunPhaseRecord
 ): Omit<ActionRunPhaseRecord, "completedAt"> {

package/src/storage/action-runs/in-memory.ts

@@ -1,30 +1,15 @@
 import type { ExecutionStorage } from "../executions"
 import { ActionRunError } from "./errors"
-import { parseActionRunFailure } from "./failure"
-import {
-  actionRunPhaseRecordsEqual,
-  actionSubjectsEqual,
-  canRequeueActionRunAfterEnqueueFailure,
-  isTerminalActionRun,
-} from "./idempotency"
+import { actionSubjectsEqual } from "./idempotency"
 import { assertActionRunExecution } from "./provider"
+import { normalizeRecordActionRunInput, resolveActionRunEffects } from "./record"
 import type {
-  ActionRunEffectsRecord,
-  ActionRunFailure,
-  ActionRunParams,
-  ActionRunPhase,
   ActionRunRecord,
   ActionRunStorage,
-  ActionRunWritebackRecord,
-  EnterActionRunPhaseInput,
-  FinishActionRunInput,
   ListActionRunsInput,
   ListActionRunsResult,
-  LockActionMaterializationRunInput,
-  QueueActionRunInput,
   RecordActionEffectsInput,
-  RecordActionWritebackInput,
-  StartActionRunInput,
+  RecordActionRunInput,
 } from "./types"
 
 type RunRootOperation = <T>(run: () => Promise<T> | T) => Promise<T>
@@ -35,74 +20,12 @@ function actionRunKey(projectId: string, id: string): string {
   return JSON.stringify([projectId, id])
 }
 
-function assertNonBlank(value: string, fieldName: string): void {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new ActionRunError(`[Sixb] Action materialization ${fieldName} must be nonblank.`)
-  }
-}
-
 function cloneActionRunRecord(record: ActionRunRecord): ActionRunRecord {
   return structuredClone(record)
 }
 
-function normalizeParams(params: ActionRunParams): ActionRunParams {
-  return structuredClone(params)
-}
-
-function normalizeSubject(subject: QueueActionRunInput["subject"]): QueueActionRunInput["subject"] {
-  return structuredClone(subject)
-}
-
-function normalizeError<TPhase extends ActionRunPhase>(
-  error: ActionRunFailure<TPhase>,
-  expectedPhase?: TPhase
-): ActionRunFailure<TPhase> {
-  return expectedPhase === undefined
-    ? (parseActionRunFailure(error) as ActionRunFailure<TPhase>)
-    : parseActionRunFailure(error, expectedPhase)
-}
-
-function normalizeWriteback(
-  input: RecordActionWritebackInput,
-  completedAt: Date
-): ActionRunWritebackRecord {
-  if (input.status === "succeeded") {
-    return {
-      status: "succeeded",
-      completedAt,
-      result: structuredClone(input.result),
-    }
-  }
-
-  return {
-    status: "failed",
-    completedAt,
-    error: normalizeError(input.error, "writeback"),
-  }
-}
-
-function normalizeEffects(
-  input: RecordActionEffectsInput,
-  completedAt: Date
-): ActionRunEffectsRecord {
-  if (input.status === "succeeded") {
-    return {
-      status: "succeeded",
-      completedAt,
-    }
-  }
-
-  return {
-    status: "failed",
-    completedAt,
-    error: normalizeError(input.error, "effects"),
-  }
-}
-
 function compareRuns(a: ActionRunRecord, b: ActionRunRecord, order: "asc" | "desc"): number {
-  const leftAt = a.startedAt ?? a.queuedAt
-  const rightAt = b.startedAt ?? b.queuedAt
-  const delta = leftAt.getTime() - rightAt.getTime()
+  const delta = a.startedAt.getTime() - b.startedAt.getTime()
   if (delta !== 0) {
     return order === "asc" ? delta : -delta
   }
@@ -136,235 +59,49 @@ export class InMemoryActionRunStorage implements ActionRunStorage {
     }
   }
 
-  async lockForMaterialization(input: LockActionMaterializationRunInput): Promise<ActionRunRecord> {
-    return this.runRootOperation(() => cloneActionRunRecord(this.requireMaterializationRun(input)))
-  }
-
-  async queue(input: QueueActionRunInput): Promise<ActionRunRecord> {
+  async record(input: RecordActionRunInput): Promise<ActionRunRecord> {
     return this.runRootOperation(async () => {
-      const key = actionRunKey(input.projectId, input.id)
-      const existing = this.rows.get(key)
-      if (existing && !canRequeueActionRunAfterEnqueueFailure(existing, input)) {
+      const record = normalizeRecordActionRunInput(input)
+      const key = actionRunKey(record.projectId, record.id)
+      if (this.rows.has(key)) {
         throw new ActionRunError(
-          `[Sixb] Action run '${input.id}' already exists for project '${input.projectId}'.`
+          `[Sixb] Action run '${record.id}' is already recorded for project '${record.projectId}'.`
         )
       }
       if (
         [...this.rows.values()].some(
-          (run) =>
-            run.projectId === input.projectId &&
-            run.id !== input.id &&
-            run.executionId === input.executionId
+          (run) => run.projectId === record.projectId && run.executionId === record.executionId
         )
       ) {
         throw new ActionRunError(
-          `[Sixb] Execution '${input.executionId}' already belongs to another Action run.`
+          `[Sixb] Execution '${record.executionId}' already belongs to another Action run.`
         )
       }
       await assertActionRunExecution({
         executions: this.executions,
-        projectId: input.projectId,
-        executionId: input.executionId,
-        runId: input.id,
-        actionId: input.actionId,
+        projectId: record.projectId,
+        executionId: record.executionId,
+        runId: record.id,
+        actionId: record.actionId,
       })
 
-      const record: ActionRunRecord = {
-        id: input.id,
-        projectId: input.projectId,
-        executionId: input.executionId,
-        actionId: input.actionId,
-        subject: normalizeSubject(input.subject),
-        status: "queued",
-        phase: "request",
-        queuedAt: new Date(input.queuedAt ?? new Date()),
-        params: normalizeParams(input.params),
-        idempotencyKey: input.idempotencyKey,
-      }
-
-      if (existing) {
-        const next: ActionRunRecord = {
-          ...existing,
-          status: "queued",
-          phase: "request",
-          queuedAt: record.queuedAt,
-          startedAt: undefined,
-          finishedAt: undefined,
-          error: undefined,
-          writeback: undefined,
-          effects: undefined,
-        }
-        this.rows.set(key, structuredClone(next))
-        return cloneActionRunRecord(next)
-      }
-
       this.rows.set(key, structuredClone(record))
       return cloneActionRunRecord(record)
     })
   }
 
-  async start(input: StartActionRunInput): Promise<ActionRunRecord> {
-    return this.runRootOperation(() => {
-      const key = actionRunKey(input.projectId, input.id)
-      const existing = this.rows.get(key)
-
-      if (!existing) {
-        throw new ActionRunError(
-          `[Sixb] Action run '${input.id}' not found for project '${input.projectId}'.`
-        )
-      }
-
-      if (existing.status !== "queued") {
-        throw new ActionRunError(
-          `[Sixb] Action run '${input.id}' cannot start from status '${existing.status}'.`
-        )
-      }
-
-      const next: ActionRunRecord = {
-        ...existing,
-        status: "running",
-        phase: input.phase ?? "validation",
-        startedAt: new Date(input.startedAt ?? new Date()),
-        error: undefined,
-      }
-
-      this.rows.set(key, structuredClone(next))
-      return cloneActionRunRecord(next)
-    })
-  }
-
-  async enterPhase(input: EnterActionRunPhaseInput): Promise<ActionRunRecord> {
-    return this.runRootOperation(() => {
-      const key = actionRunKey(input.projectId, input.id)
-      const existing = this.requireRunningRun(key, input.projectId, input.id, "enter phase")
-      const next: ActionRunRecord = {
-        ...existing,
-        phase: input.phase,
-      }
-
-      this.rows.set(key, structuredClone(next))
-      return cloneActionRunRecord(next)
-    })
-  }
-
-  async recordWriteback(input: RecordActionWritebackInput): Promise<ActionRunRecord> {
-    return this.runRootOperation(() => {
-      const key = actionRunKey(input.projectId, input.id)
-      const existing = this.requireRunningRun(key, input.projectId, input.id, "record writeback")
-      const writeback = normalizeWriteback(input, new Date(input.completedAt ?? new Date()))
-
-      if (existing.writeback) {
-        if (actionRunPhaseRecordsEqual(existing.writeback, writeback)) {
-          return cloneActionRunRecord(existing)
-        }
-
-        throw new ActionRunError(
-          `[Sixb] Action run '${input.id}' already has a different writeback record.`
-        )
-      }
-
-      const next: ActionRunRecord = {
-        ...existing,
-        phase: "writeback",
-        writeback,
-      }
-
-      this.rows.set(key, structuredClone(next))
-      return cloneActionRunRecord(next)
-    })
-  }
-
   async recordEffects(input: RecordActionEffectsInput): Promise<ActionRunRecord> {
     return this.runRootOperation(() => {
       const key = actionRunKey(input.projectId, input.id)
-      const existing = this.requireRunningRun(key, input.projectId, input.id, "record effects")
-      const effects = normalizeEffects(input, new Date(input.completedAt ?? new Date()))
-
-      if (existing.effects) {
-        if (actionRunPhaseRecordsEqual(existing.effects, effects)) {
-          return cloneActionRunRecord(existing)
-        }
-
-        throw new ActionRunError(
-          `[Sixb] Action run '${input.id}' already has a different effects record.`
-        )
-      }
-
-      const next: ActionRunRecord = {
-        ...existing,
-        phase: "effects",
-        effects,
-      }
+      const { run, effects } = resolveActionRunEffects(this.rows.get(key) ?? null, input)
+      if (!effects) return cloneActionRunRecord(run)
 
+      const next: ActionRunRecord = { ...run, phase: "effects", effects }
       this.rows.set(key, structuredClone(next))
       return cloneActionRunRecord(next)
     })
   }
 
-  async finish(input: FinishActionRunInput): Promise<ActionRunRecord> {
-    return this.runRootOperation(() => {
-      const key = actionRunKey(input.projectId, input.id)
-      const existing = this.rows.get(key)
-
-      if (!existing) {
-        throw new ActionRunError(
-          `[Sixb] Action run '${input.id}' not found for project '${input.projectId}'.`
-        )
-      }
-
-      if (isTerminalActionRun(existing)) {
-        throw new ActionRunError(
-          `[Sixb] Action run '${input.id}' cannot finish from terminal status '${existing.status}'.`
-        )
-      }
-
-      const phase =
-        input.status === "succeeded" ? (input.phase ?? existing.phase) : input.error.details.phase
-
-      const base: ActionRunRecord = {
-        ...existing,
-        status: input.status,
-        phase,
-        finishedAt: new Date(input.finishedAt ?? new Date()),
-      }
-
-      const next: ActionRunRecord =
-        input.status === "succeeded"
-          ? {
-              ...base,
-              error: undefined,
-            }
-          : {
-              ...base,
-              error: normalizeError(input.error),
-            }
-
-      this.rows.set(key, structuredClone(next))
-      return cloneActionRunRecord(next)
-    })
-  }
-
-  private requireRunningRun(
-    key: string,
-    projectId: string,
-    id: string,
-    operation: string
-  ): ActionRunRecord {
-    const existing = this.rows.get(key)
-
-    if (!existing) {
-      throw new ActionRunError(`[Sixb] Action run '${id}' not found for project '${projectId}'.`)
-    }
-
-    if (existing.status !== "running") {
-      throw new ActionRunError(
-        `[Sixb] Action run '${id}' cannot ${operation} from status '${existing.status}'.`
-      )
-    }
-
-    return existing
-  }
-
   async getById(params: { projectId: string; id: string }): Promise<ActionRunRecord | null> {
     return this.runRootOperation(() => {
       const record = this.rows.get(actionRunKey(params.projectId, params.id))
@@ -408,12 +145,8 @@ export class InMemoryActionRunStorage implements ActionRunStorage {
             : true
         )
         .filter((record) => (statuses ? statuses.has(record.status) : true))
-        .filter((record) =>
-          input.startedAfter ? (record.startedAt ?? record.queuedAt) >= input.startedAfter : true
-        )
-        .filter((record) =>
-          input.startedBefore ? (record.startedAt ?? record.queuedAt) <= input.startedBefore : true
-        )
+        .filter((record) => (input.startedAfter ? record.startedAt >= input.startedAfter : true))
+        .filter((record) => (input.startedBefore ? record.startedAt <= input.startedBefore : true))
         .sort((a, b) => compareRuns(a, b, order))
 
       const total = filtered.length
@@ -421,30 +154,6 @@ export class InMemoryActionRunStorage implements ActionRunStorage {
       return { runs, hasMore: offset + runs.length < total, total }
     })
   }
-
-  private requireMaterializationRun(input: LockActionMaterializationRunInput): ActionRunRecord {
-    assertNonBlank(input.projectId, "projectId")
-    assertNonBlank(input.runId, "runId")
-    assertNonBlank(input.actionId, "actionId")
-
-    const existing = this.rows.get(actionRunKey(input.projectId, input.runId))
-    if (!existing) {
-      throw new ActionRunError(
-        `[Sixb] Action run '${input.runId}' not found for project '${input.projectId}'.`
-      )
-    }
-    if (existing.actionId !== input.actionId) {
-      throw new ActionRunError(
-        `[Sixb] Action run '${input.runId}' does not belong to action '${input.actionId}'.`
-      )
-    }
-    if (existing.status !== "running") {
-      throw new ActionRunError(
-        `[Sixb] Action run '${input.runId}' cannot materialize from status '${existing.status}'.`
-      )
-    }
-    return existing
-  }
 }
 
 export type InMemoryActionRunStorageSnapshot = Map<string, ActionRunRecord>

package/src/storage/action-runs/index.ts

@@ -1,13 +1,4 @@
 export { ActionRunError } from "./errors"
-export type { ActionRunPhaseRecord } from "./idempotency"
-export {
-  actionRunParamsEqual,
-  actionRunPhaseRecordsEqual,
-  actionSubjectsEqual,
-  canRequeueActionRunAfterEnqueueFailure,
-  finishActionRunPhase,
-  isTerminalActionRun,
-} from "./idempotency"
 export { InMemoryActionRunStorage } from "./in-memory"
 export type {
   ActionRunEffectsRecord,
@@ -16,19 +7,13 @@ export type {
   ActionRunFailureDetails,
   ActionRunParams,
   ActionRunPhase,
-  ActionRunPhaseStatus,
   ActionRunRecord,
   ActionRunStatus,
   ActionRunStorage,
   ActionRunWritebackRecord,
-  EnterActionRunPhaseInput,
-  FinishActionRunInput,
   ListActionRunsInput,
   ListActionRunsResult,
-  LockActionMaterializationRunInput,
-  QueueActionRunInput,
   RecordActionEffectsInput,
-  RecordActionWritebackInput,
-  StartActionRunInput,
+  RecordActionRunInput,
 } from "./types"
 export { ACTION_RUN_FAILURE_CODES, ACTION_RUN_PHASES } from "./types"