@sixb/core 0.1.0 → 0.1.2

package/src/actions/execution.ts

@@ -0,0 +1,83 @@
+import { canViewActionRun, isAllowed } from "../authorization"
+import type { ExecutionContext } from "../execution"
+import type { ObjectType } from "../ontology"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type {
+  ActionRunRecord,
+  ListActionRunsInput,
+  ListActionRunsResult,
+} from "../storage/action-runs"
+import {
+  type RequestActionAndWaitInput,
+  type RequestActionInput,
+  type RequestActionResult,
+  requestAction,
+  requestActionAndWait,
+} from "./request"
+import type { ActionDefinition } from "./types"
+
+export interface ActionRunsRuntime {
+  getById(runId: string): Promise<ActionRunRecord | null>
+  list(
+    input?: Omit<ListActionRunsInput, "projectId" | "actionIds" | "objectTypeIds">
+  ): Promise<ListActionRunsResult>
+}
+
+export interface ActionsRuntime {
+  list(): readonly ActionDefinition[]
+  getById(actionId: string): ActionDefinition | null
+  listGlobal(): readonly ActionDefinition[]
+  listForType(objectType: ObjectType): readonly ActionDefinition[]
+  request(input: RequestActionInput): Promise<RequestActionResult>
+  requestAndWait(input: RequestActionAndWaitInput): Promise<ActionRunRecord>
+  readonly runs: ActionRunsRuntime
+}
+
+export function createActionsRuntime(
+  runtime: SixbRuntimeContext,
+  execution: ExecutionContext
+): ActionsRuntime {
+  const canList = (action: ActionDefinition) =>
+    isAllowed(runtime.authorization, { kind: "action.apply", actionId: action.id }) &&
+    (action.binding.kind === "global" ||
+      isAllowed(runtime.authorization, {
+        kind: "object.view",
+        objectTypeId: action.binding.objectType.id,
+      }))
+
+  return {
+    list: () => runtime.actionRegistry.list().filter(canList),
+    getById: (actionId) => {
+      const action = runtime.actionRegistry.getById(actionId)
+      return action && canList(action) ? action : null
+    },
+    listGlobal: () => runtime.actionRegistry.listGlobal().filter(canList),
+    listForType: (objectType) => runtime.actionRegistry.listForType(objectType).filter(canList),
+    request: (input) => requestAction(runtime, execution, input),
+    requestAndWait: (input) => requestActionAndWait(runtime, execution, input),
+    runs: {
+      getById: async (runId) => {
+        const run =
+          (await runtime.storage.actionRuns?.getById({
+            projectId: runtime.projectId,
+            id: runId,
+          })) ?? null
+        return run && canViewActionRun(runtime.authorization, run) ? run : null
+      },
+      list: (input = {}) => {
+        const storage = runtime.storage.actionRuns
+        if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        return storage.list({
+          projectId: runtime.projectId,
+          ...input,
+          actionIds: runtime.authorization
+            ? [...runtime.authorization.grants["apply:action"]]
+            : undefined,
+          objectTypeIds: runtime.authorization
+            ? [...runtime.authorization.grants["view:object"]]
+            : undefined,
+        })
+      },
+    },
+  }
+}

package/src/actions/index.ts

@@ -9,6 +9,7 @@ export { commitActionEdits, findActionEditCommit } from "./commit-edits"
 export { ActionDefinitionError, ActionEditCommitError } from "./errors"
 export type { ActionReadFacadeOptions, ActionReadObjectSetSource } from "./read-facade"
 export { ActionReadRecorder, createActionReadFacade } from "./read-facade"
+export type { ActionDefinitionCatalog, ActionRegistryOptions } from "./registry"
 export { ActionRegistry } from "./registry"
 export type {
   RequestActionAndWaitInput,
@@ -19,7 +20,6 @@ export type {
   WaitForActionRunInput,
 } from "./request"
 export { requestAction, requestActionAndWait, waitForActionRun } from "./request"
-export { ActionsRuntime } from "./runtime"
 export type {
   ActionBinding,
   ActionBlobContext,

package/src/actions/registry.ts

@@ -1,5 +1,4 @@
-import type { ObjectType } from "../ontology"
-import type { OntologyRegistry } from "../ontology/registry"
+import type { ObjectType, OntologyDefinitionCatalog } from "../ontology"
 import {
   ActionDefinitionError,
   effectsWithoutEditsMessage,
@@ -8,16 +7,29 @@ import {
 import type { ActionDefinition, ObjectActionDefinition } from "./types"
 import { isObjectActionDefinition } from "./validation"
 
-export class ActionRegistry {
+export interface ActionDefinitionCatalog {
+  list(): readonly ActionDefinition[]
+  getById(id: string): ActionDefinition | null
+  listGlobal(): readonly ActionDefinition[]
+  listForType(type: ObjectType): readonly ObjectActionDefinition[]
+}
+
+export interface ActionRegistryOptions {
+  readonly actions: readonly ActionDefinition[]
+  readonly ontology: OntologyDefinitionCatalog
+}
+
+export class ActionRegistry implements ActionDefinitionCatalog {
   private readonly byId = new Map<string, ActionDefinition>()
   private readonly globalActions: ActionDefinition[] = []
   private readonly byTargetId = new Map<string, ObjectActionDefinition[]>()
 
-  constructor(
-    actions: readonly ActionDefinition[],
-    private readonly ontology: OntologyRegistry
-  ) {
-    for (const action of actions) {
+  private readonly ontology: OntologyDefinitionCatalog
+
+  constructor(options: ActionRegistryOptions) {
+    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)
@@ -76,11 +88,11 @@ export class ActionRegistry {
     return this.byId.get(id) ?? null
   }
 
-  getGlobalActions(): readonly ActionDefinition[] {
+  listGlobal(): readonly ActionDefinition[] {
     return [...this.globalActions]
   }
 
-  getActionsForType(type: ObjectType): readonly ObjectActionDefinition[] {
+  listForType(type: ObjectType): readonly ObjectActionDefinition[] {
     this.ontology.resolveObjectType(type.id)
 
     const seen = new Set<string>()

package/src/actions/request.ts

@@ -1,19 +1,22 @@
 import { assertAuthorized } from "../authorization"
-import { reportRunFailure } from "../error-reporting/capability"
+import {
+  createPrimitiveExecutionRecord,
+  ensureExecutionRecord,
+  executionRecordInputFromRuntime,
+} from "../execution/durable"
+import type { ExecutionContext } from "../execution/types"
 import { ActionRunTimeoutError } from "../objects/action/errors"
 import { OntologyValidationError } from "../ontology/errors"
 import type { ObjectTypeWithPropertyTokens } from "../ontology/tokens"
 import type { SixbRuntimeContext } from "../runtime/types"
 import {
   ActionRunError,
-  type ActionRunParams,
   type ActionRunRecord,
   type ActionRunStorage,
-  actionRunParamsEqual,
-  actionSubjectsEqual,
   isTerminalActionRun,
 } from "../storage"
-import { createActionRunId, createActionRunIdempotencyKey } from "./run-id"
+import { dispatchActionRun } from "./run-dispatch"
+import { createActionRunId } from "./run-id"
 import type { ActionDefinition, ActionSubject } from "./types"
 import {
   isObjectActionDefinition,
@@ -77,9 +80,10 @@ function getActionDefinition(runtime: SixbRuntimeContext, actionId: string): Act
 
 export async function requestAction(
   runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
   input: RequestActionInput
 ): Promise<RequestActionResult> {
-  const actionRuns = requireActionRunStorage(runtime)
+  requireActionRunStorage(runtime)
   const action = getActionDefinition(runtime, input.actionId)
   const actionId = action.id
   const rawParams: Record<string, unknown> = input.params ?? {}
@@ -103,147 +107,41 @@ export async function requestAction(
 
   const actionParams = normalizeActionParams(runtime, action.params, rawParams, pathPrefix)
 
-  const runId = createActionRunId(input.runId)
-  const existing = await actionRuns.getById({ projectId: runtime.projectId, id: runId })
-  if (existing) {
-    assertExistingRunMatchesRequest(existing, {
-      actionId,
-      subject,
-      params: actionParams,
-    })
-    if (isRetryableEnqueueFailure(existing)) {
-      const queuedAt = new Date()
-      await actionRuns.queue({
-        projectId: runtime.projectId,
-        id: runId,
-        actionId,
-        subject,
-        params: actionParams,
-        idempotencyKey: existing.idempotencyKey,
-        queuedAt,
-      })
-      return enqueueActionRunJob(runtime, {
-        actionRuns,
-        actionId,
-        subject,
-        params: actionParams,
-        runId,
-        queuedAt,
-        created: false,
-      })
-    }
-    return {
-      runId,
-      queuedAt: existing.queuedAt.toISOString(),
-      created: false,
-    }
-  }
-
-  const queuedAt = new Date()
-  const idempotencyKey = createActionRunIdempotencyKey(runtime.projectId, runId)
-
-  await actionRuns.queue({
+  return dispatchActionRun({
+    errorReporterHost: runtime,
     projectId: runtime.projectId,
-    id: runId,
-    actionId,
-    subject,
-    params: actionParams,
-    idempotencyKey,
-    queuedAt,
-  })
-
-  return enqueueActionRunJob(runtime, {
-    actionRuns,
+    storage: runtime.storage,
+    queue: runtime.queues.actions,
+    events: runtime.events,
     actionId,
     subject,
     params: actionParams,
-    runId,
-    queuedAt,
-    created: true,
-  })
-}
-
-async function enqueueActionRunJob(
-  runtime: SixbRuntimeContext,
-  params: {
-    readonly actionRuns: ActionRunStorage
-    readonly actionId: string
-    readonly subject: ActionSubject
-    readonly params: ActionRunParams
-    readonly runId: string
-    readonly queuedAt: Date
-    readonly created: boolean
-  }
-): Promise<RequestActionResult> {
-  let jobId: string | undefined
-  try {
-    const [job] = await runtime.queues.actions.enqueue({
-      projectId: runtime.projectId,
-      jobs: [
-        {
-          type: "action.run.requested",
-          payload: {
-            actionId: params.actionId,
-            runId: params.runId,
-          },
-        },
-      ],
-    })
-    jobId = job?.id
-  } catch (error) {
-    const failed = await params.actionRuns.finish({
-      projectId: runtime.projectId,
-      id: params.runId,
-      status: "failed",
-      phase: "enqueue",
-      error: toActionRunFailure(error, "enqueue"),
-    })
-    reportRunFailure(runtime, error, {
-      projectId: runtime.projectId,
-      occurredAt: failed.finishedAt,
-      run: {
-        kind: "action",
-        runId: params.runId,
-        actionId: params.actionId,
-      },
-    })
-    throw error
-  }
-
-  // The run is persisted and the job is queued, so the request has succeeded and the caller must not
-  // be told otherwise. `emit` keeps that promise and still escalates the lost trigger edge.
-  await runtime.events.emit(
-    {
-      events: [
-        {
-          type: "action.requested",
-          payload: {
-            actionId: params.actionId,
-            subject: params.subject,
-            params: params.params,
-            runId: params.runId,
-          },
-        },
-      ],
+    runId: input.runId,
+    createExecution: async (executionId, runId) => {
+      const caller = await ensureExecutionRecord(
+        runtime.storage.executions,
+        executionRecordInputFromRuntime({
+          execution,
+          runtimeAuthorization: runtime.runtimeAuthorization,
+        })
+      )
+      return createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "action", id: actionId, runId },
+        origin: { type: "execution", parent: caller },
+      })
     },
-    { source: "Sixb" }
-  )
-
-  return {
-    runId: params.runId,
-    queuedAt: params.queuedAt.toISOString(),
-    ...(jobId ? { jobId } : {}),
-    created: params.created,
-  }
+  })
 }
 
 export async function requestActionAndWait(
   runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
   input: RequestActionAndWaitInput
 ): Promise<ActionRunRecord> {
   const runId = createActionRunId(input.runId)
 
-  await requestAction(runtime, {
+  await requestAction(runtime, execution, {
     ...input,
     runId,
   })
@@ -276,13 +174,22 @@ export async function waitForActionRun(
     let settled = false
     let checking = false
 
+    const releaseSubscription = (release: (() => void) | undefined) => {
+      if (!release) return
+      try {
+        release()
+      } catch (error) {
+        console.error("[Sixb] Failed to release action run wait subscription:", error)
+      }
+    }
+
     const cleanup = () => {
       if (settled) return
       settled = true
       clearTimer(timer)
       clearTimer(pollTimer)
-      unsubscribe?.()
       signal?.removeEventListener("abort", onAbort)
+      releaseSubscription(unsubscribe)
     }
 
     const rejectWith = (error: unknown) => {
@@ -350,10 +257,22 @@ export async function waitForActionRun(
         }
       })
       .then((unsubscribeEvents) => {
+        // Timeout or abort can settle the wait before the asynchronous subscription resolves.
+        // `cleanup()` had no handle to release in that case, so release the late handle here.
+        if (settled) {
+          releaseSubscription(unsubscribeEvents)
+          return
+        }
         unsubscribe = unsubscribeEvents
         void check()
       })
-      .catch(rejectWith)
+      .catch((error: unknown) => {
+        if (settled) {
+          console.error("[Sixb] Action run wait subscription failed after the wait settled:", error)
+          return
+        }
+        rejectWith(error)
+      })
   })
 }
 
@@ -364,44 +283,3 @@ function requireActionRunStorage(runtime: SixbRuntimeContext): ActionRunStorage
   }
   return actionRuns
 }
-
-function assertExistingRunMatchesRequest(
-  existing: ActionRunRecord,
-  request: {
-    readonly actionId: string
-    readonly subject: ActionSubject
-    readonly params: ActionRunParams
-  }
-): void {
-  const matches =
-    existing.actionId === request.actionId &&
-    actionSubjectsEqual(existing.subject, request.subject) &&
-    actionRunParamsEqual(existing.params, request.params)
-
-  if (!matches) {
-    throw new ActionRunError(
-      `[Sixb] Action run '${existing.id}' already exists with a different request payload.`
-    )
-  }
-}
-
-function isRetryableEnqueueFailure(record: ActionRunRecord): boolean {
-  return record.status === "failed" && record.phase === "enqueue"
-}
-
-function toActionRunFailure(
-  error: unknown,
-  phase: "enqueue"
-): { name?: string; message: string; phase: "enqueue" } {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      phase,
-    }
-  }
-  return {
-    message: String(error),
-    phase,
-  }
-}