@fabricorg/platform-host 0.1.0

package/dist/index.js

@@ -0,0 +1,694 @@
+import { AdapterRegistry, resolveAction, createFabricId, evaluatePolicyDefinitions, aggregatePolicyOutcomes, validateTransition, executeWithAdapterRetry, resolveStateMachine } from '@fabricorg/platform';
+
+// src/host.ts
+var DEFAULT_EXTRACT_EVENTS = (data) => {
+  const value = data._events;
+  return Array.isArray(value) ? value : [];
+};
+function createGovernedActionHost(options) {
+  const adapters = new AdapterRegistry();
+  for (const adapter of options.adapters ?? []) adapters.register(adapter);
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const extractEvents = options.extractEvents ?? DEFAULT_EXTRACT_EVENTS;
+  async function submitAction(input) {
+    const action = resolveAction(input.actionId);
+    if (!action) throw new Error(`Unknown action: ${input.actionId}`);
+    const authorizationInput = toAuthorizationInput(action, input);
+    if (!await options.authorization.checkEntitlement(authorizationInput)) {
+      throw new Error(`Module "${action.namespace}" is not enabled for tenant ${input.tenantId}`);
+    }
+    if (!await options.authorization.authorize(authorizationInput)) {
+      throw new Error(`Actor ${input.actorId} is not authorized for action ${input.actionId}`);
+    }
+    const actionInvocationId = createFabricId("act");
+    const correlationId = input.correlationId ?? createFabricId("corr");
+    const workflowId = `action-invocation-${actionInvocationId}`;
+    await options.store.createActionInvocation({
+      id: actionInvocationId,
+      tenantId: input.tenantId,
+      spaceId: input.spaceId,
+      actionId: input.actionId,
+      actionVersion: action.version,
+      actorId: input.actorId,
+      actorType: input.actorType,
+      status: "pending",
+      parameters: input.parameters,
+      result: {},
+      correlationId,
+      ...input.causationId ? { causationId: input.causationId } : {}
+    });
+    if (options.dispatcher) {
+      try {
+        const dispatched = await options.dispatcher.dispatch({
+          actionInvocationId,
+          tenantId: input.tenantId,
+          spaceId: input.spaceId,
+          workflowId
+        });
+        return {
+          actionInvocationId,
+          status: "pending",
+          workflowId: dispatched.workflowId,
+          ...dispatched.runId ? { runId: dispatched.runId } : {}
+        };
+      } catch (error) {
+        const message = errorMessage(error);
+        await options.store.updateActionInvocation(
+          actionInvocationId,
+          input.tenantId,
+          input.spaceId,
+          { status: "failed", error: message }
+        );
+        throw error;
+      }
+    }
+    const executed = await executeInvocation(
+      actionInvocationId,
+      input.tenantId,
+      input.spaceId
+    );
+    return { ...executed, workflowId };
+  }
+  async function executeInvocation(actionInvocationId, tenantId, spaceId) {
+    const invocation = await options.store.getActionInvocation(
+      actionInvocationId,
+      tenantId,
+      spaceId
+    );
+    if (!invocation) throw new Error(`ActionInvocation not found: ${actionInvocationId}`);
+    if (isTerminal(invocation.status)) {
+      return {
+        actionInvocationId,
+        status: invocation.status,
+        result: invocation.result,
+        ...invocation.error ? { error: invocation.error } : {}
+      };
+    }
+    const action = resolveAction(invocation.actionId);
+    if (!action) {
+      return fail(invocation, "failed", `Unknown action: ${invocation.actionId}`);
+    }
+    await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
+      status: "running"
+    });
+    const parsed = action.schema.safeParse(invocation.parameters);
+    if (!parsed.success) {
+      const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+      return fail(invocation, "validation_failed", message);
+    }
+    const authorizationInput = toAuthorizationInput(action, invocation);
+    const definitions = options.resolvePolicies ? await options.resolvePolicies({
+      ...authorizationInput,
+      declaredPolicyIds: action.policies ?? []
+    }) : declaredPolicies(action.policies ?? []);
+    const outcomes = await evaluatePolicyDefinitions(definitions, {
+      tenantId,
+      spaceId,
+      actionInvocationId,
+      actionId: action.actionId,
+      actorId: invocation.actorId,
+      actorType: invocation.actorType,
+      parameters: parsed.data,
+      db: options.store.db,
+      services: options.services,
+      mode: "execute"
+    });
+    for (const outcome of outcomes) {
+      await options.store.appendPolicyEvaluation({
+        id: createFabricId("pol"),
+        actionInvocationId,
+        tenantId,
+        spaceId,
+        outcome,
+        createdAt: now()
+      });
+    }
+    const aggregate = aggregatePolicyOutcomes(outcomes);
+    if (aggregate?.result === "block") {
+      const reason = aggregate.reason ?? `Blocked by policy ${aggregate.policyId}`;
+      await appendEvent(invocation, {
+        eventType: "ComplianceBlocked",
+        subjectType: "ActionInvocation",
+        subjectId: actionInvocationId,
+        payload: { actionId: action.actionId, policyId: aggregate.policyId, reason }
+      });
+      return fail(invocation, "blocked_by_policy", reason);
+    }
+    const binding = action.stateMachine;
+    if (binding) {
+      const entityId = binding.getEntityId(parsed.data);
+      const currentState = entityId ? await options.store.getEntityState(
+        tenantId,
+        spaceId,
+        binding.entityType,
+        entityId
+      ) ?? initialState(binding.entityType) : initialState(binding.entityType);
+      const targetState = typeof binding.targetState === "function" ? binding.targetState(parsed.data) : binding.targetState;
+      const transition = validateTransition(
+        binding.entityType,
+        currentState,
+        targetState,
+        action.actionId
+      );
+      if (!transition.valid) {
+        return fail(invocation, "failed", transition.error ?? "Invalid state transition");
+      }
+    }
+    let data;
+    let domainEvents = [];
+    try {
+      const handlerResult = await options.store.transaction(
+        (db) => action.handler ? action.handler(
+          {
+            actionInvocationId,
+            tenantId,
+            spaceId,
+            actorId: invocation.actorId,
+            actorType: invocation.actorType,
+            correlationId: invocation.correlationId,
+            ...invocation.causationId ? { causationId: invocation.causationId } : {},
+            db,
+            services: options.services
+          },
+          parsed.data
+        ) : Promise.resolve({ success: true, data: {} })
+      );
+      if (!handlerResult.success) {
+        return fail(invocation, "failed", handlerResult.error ?? "Action handler failed");
+      }
+      data = handlerResult.data ?? {};
+      domainEvents = extractEvents(data);
+      if (action.eventPhase !== "after_adapters") {
+        for (const event of domainEvents) await appendEvent(invocation, event);
+      }
+    } catch (error) {
+      return fail(invocation, "failed", errorMessage(error));
+    }
+    for (const step of action.adapterSteps ?? []) {
+      const input = step.getInput(parsed.data, data);
+      if (!input) continue;
+      const adapter = adapters.require(step.adapterType, step.operation);
+      const adapterInvocationId = createFabricId("adp");
+      const adapterEventSubject = options.adapterEventSubject?.(
+        action.actionId,
+        parsed.data,
+        data
+      ) ?? { subjectType: "AdapterInvocation", subjectId: adapterInvocationId };
+      const recordedInput = options.redactAdapterInput ? options.redactAdapterInput(
+        action.actionId,
+        step.adapterType,
+        step.operation,
+        input
+      ) : input;
+      const startedAt = now();
+      const record = {
+        id: adapterInvocationId,
+        actionInvocationId,
+        tenantId,
+        spaceId,
+        adapterType: step.adapterType,
+        operation: step.operation,
+        vendor: adapter.vendor,
+        status: "running",
+        input: recordedInput,
+        attempt: 1,
+        createdAt: startedAt,
+        updatedAt: startedAt
+      };
+      await options.store.createAdapterInvocation(record);
+      await appendEvent(invocation, {
+        eventType: "AdapterInvocationStarted",
+        subjectType: adapterEventSubject.subjectType,
+        subjectId: adapterEventSubject.subjectId,
+        payload: { adapterType: step.adapterType, operation: step.operation }
+      });
+      try {
+        const result2 = await executeWithAdapterRetry({
+          policy: step.retryPolicy ?? adapter.retryPolicy,
+          defaultIdempotent: adapter.idempotent,
+          execute: async (attempt, maxAttempts) => {
+            await options.store.updateAdapterInvocation(adapterInvocationId, {
+              attempt,
+              updatedAt: now()
+            });
+            return adapter.execute(input, {
+              tenantId,
+              spaceId,
+              actionInvocationId,
+              adapterInvocationId,
+              correlationId: invocation.correlationId,
+              ...invocation.causationId ? { causationId: invocation.causationId } : {},
+              attempt,
+              maxAttempts
+            });
+          },
+          isSuccessful: (result3) => result3.success,
+          getError: (result3) => result3.error
+        });
+        if (!result2.success) {
+          await options.store.updateAdapterInvocation(adapterInvocationId, {
+            status: "failed",
+            error: result2.error ?? "Adapter failed",
+            updatedAt: now()
+          });
+          await appendEvent(invocation, {
+            eventType: "AdapterInvocationFailed",
+            subjectType: adapterEventSubject.subjectType,
+            subjectId: adapterEventSubject.subjectId,
+            payload: { adapterType: step.adapterType, operation: step.operation }
+          });
+          return fail(invocation, "failed", result2.error ?? "Adapter failed");
+        }
+        const resultRecord = result2;
+        const output = isRecord(resultRecord.output) ? resultRecord.output : Object.fromEntries(
+          Object.entries(resultRecord).filter(
+            ([key]) => key !== "success" && key !== "error"
+          )
+        );
+        await options.store.updateAdapterInvocation(adapterInvocationId, {
+          status: "succeeded",
+          output,
+          updatedAt: now()
+        });
+        await appendEvent(invocation, {
+          eventType: "AdapterInvocationSucceeded",
+          subjectType: adapterEventSubject.subjectType,
+          subjectId: adapterEventSubject.subjectId,
+          payload: {
+            adapterType: step.adapterType,
+            operation: step.operation,
+            input: recordedInput,
+            output
+          }
+        });
+      } catch (error) {
+        const message = errorMessage(error);
+        await options.store.updateAdapterInvocation(adapterInvocationId, {
+          status: "failed",
+          error: message,
+          updatedAt: now()
+        });
+        return fail(invocation, "failed", message);
+      }
+    }
+    if (action.eventPhase === "after_adapters") {
+      for (const event of domainEvents) await appendEvent(invocation, event);
+    }
+    const result = withoutPrivateHostFields(data);
+    await options.store.updateActionInvocation(actionInvocationId, tenantId, spaceId, {
+      status: "completed",
+      result
+    });
+    return { actionInvocationId, status: "completed", result };
+  }
+  async function appendEvent(invocation, event) {
+    const timestamp = now();
+    const envelope = {
+      id: createFabricId("evt"),
+      tenantId: invocation.tenantId,
+      spaceId: invocation.spaceId,
+      eventType: event.eventType,
+      eventSchemaVersion: event.eventSchemaVersion ?? 1,
+      subjectType: event.subjectType,
+      subjectId: event.subjectId,
+      actorId: invocation.actorId,
+      actorType: invocation.actorType,
+      actionInvocationId: invocation.id,
+      payload: event.payload,
+      sequence: await options.store.nextEventSequence(
+        invocation.tenantId,
+        invocation.spaceId
+      ),
+      occurredAt: timestamp,
+      recordedAt: timestamp,
+      correlationId: invocation.correlationId,
+      ...invocation.causationId ? { causationId: invocation.causationId } : {}
+    };
+    await options.store.appendEvent(envelope);
+  }
+  async function fail(invocation, status, error) {
+    await options.store.updateActionInvocation(
+      invocation.id,
+      invocation.tenantId,
+      invocation.spaceId,
+      { status, error }
+    );
+    return { actionInvocationId: invocation.id, status, error };
+  }
+  return { submitAction, executeInvocation };
+}
+function toAuthorizationInput(action, input) {
+  return {
+    actionId: action.actionId,
+    namespace: action.namespace,
+    requiredPermissions: action.requiredPermissions ?? [],
+    requiredRoles: action.requiredRoles ?? [],
+    tenantId: input.tenantId,
+    spaceId: input.spaceId,
+    actorId: input.actorId,
+    actorType: input.actorType
+  };
+}
+function declaredPolicies(policyIds) {
+  return policyIds.map((policyId) => ({
+    policyId,
+    policyVersion: Number(policyId.split(".v").at(-1) ?? 1),
+    kind: "code",
+    codeEvaluatorPolicyId: policyId
+  }));
+}
+function initialState(entityType) {
+  const machine = resolveStateMachine(entityType);
+  return Object.values(machine?.states ?? {}).find((state) => state.stateClass === "initial")?.id ?? "none";
+}
+function isTerminal(status) {
+  return ["completed", "failed", "blocked_by_policy", "validation_failed"].includes(status);
+}
+function withoutPrivateHostFields(data) {
+  const { _events: _ignored, ...result } = data;
+  return result;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/memory-store.ts
+var MemoryPlatformHostStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  invocations = [];
+  policyEvaluations = [];
+  adapterInvocations = [];
+  events = [];
+  async transaction(run) {
+    return run(this.db);
+  }
+  async createActionInvocation(input) {
+    const now = /* @__PURE__ */ new Date();
+    const record = { ...input, createdAt: now, updatedAt: now };
+    this.invocations.push(record);
+    return record;
+  }
+  async getActionInvocation(id, tenantId, spaceId) {
+    return this.invocations.find(
+      (record) => record.id === id && record.tenantId === tenantId && record.spaceId === spaceId
+    );
+  }
+  async updateActionInvocation(id, tenantId, spaceId, patch) {
+    const record = await this.getActionInvocation(id, tenantId, spaceId);
+    if (!record) throw new Error(`ActionInvocation not found: ${id}`);
+    Object.assign(record, patch, { updatedAt: /* @__PURE__ */ new Date() });
+  }
+  async appendPolicyEvaluation(record) {
+    this.policyEvaluations.push(record);
+  }
+  async createAdapterInvocation(record) {
+    this.adapterInvocations.push(record);
+  }
+  async updateAdapterInvocation(id, patch) {
+    const record = this.adapterInvocations.find((candidate) => candidate.id === id);
+    if (!record) throw new Error(`AdapterInvocation not found: ${id}`);
+    Object.assign(record, patch);
+  }
+  async appendEvent(event) {
+    this.events.push(event);
+  }
+  async nextEventSequence(tenantId, spaceId) {
+    return this.events.filter((event) => event.tenantId === tenantId && event.spaceId === spaceId).length + 1;
+  }
+  async getEntityState(tenantId, spaceId, entityType, entityId) {
+    let state;
+    for (const event of this.events) {
+      if (event.tenantId !== tenantId || event.spaceId !== spaceId || event.subjectType !== entityType || event.subjectId !== entityId) {
+        continue;
+      }
+      const candidate = event.payload?.toState;
+      if (typeof candidate === "string") state = candidate;
+    }
+    return state;
+  }
+};
+
+// src/postgres-store.ts
+var PostgresPlatformHostStore = class {
+  constructor(db, sql) {
+    this.db = db;
+    this.sql = sql;
+  }
+  db;
+  sql;
+  async ensureSchema() {
+    await this.sql.query(`
+			CREATE SCHEMA IF NOT EXISTS fabric_platform;
+			CREATE TABLE IF NOT EXISTS fabric_platform.action_invocations (
+				id text PRIMARY KEY, tenant_id text NOT NULL, space_id text NOT NULL,
+				action_id text NOT NULL, action_version integer NOT NULL,
+				actor_id text NOT NULL, actor_type text NOT NULL, status text NOT NULL,
+				parameters jsonb NOT NULL, result jsonb NOT NULL DEFAULT '{}'::jsonb,
+				correlation_id text NOT NULL, causation_id text, error text,
+				created_at timestamptz NOT NULL, updated_at timestamptz NOT NULL
+			);
+			CREATE TABLE IF NOT EXISTS fabric_platform.policy_evaluations (
+				id text PRIMARY KEY, action_invocation_id text NOT NULL,
+				tenant_id text NOT NULL, space_id text NOT NULL, outcome jsonb NOT NULL,
+				created_at timestamptz NOT NULL
+			);
+			CREATE TABLE IF NOT EXISTS fabric_platform.adapter_invocations (
+				id text PRIMARY KEY, action_invocation_id text NOT NULL,
+				tenant_id text NOT NULL, space_id text NOT NULL, adapter_type text NOT NULL,
+				operation text NOT NULL, vendor text NOT NULL, status text NOT NULL,
+				input jsonb NOT NULL, output jsonb, error text, attempt integer NOT NULL,
+				created_at timestamptz NOT NULL, updated_at timestamptz NOT NULL
+			);
+			CREATE TABLE IF NOT EXISTS fabric_platform.event_sequences (
+				tenant_id text NOT NULL, space_id text NOT NULL, next_sequence bigint NOT NULL,
+				PRIMARY KEY (tenant_id, space_id)
+			);
+			CREATE TABLE IF NOT EXISTS fabric_platform.asset_events (
+				id text PRIMARY KEY, tenant_id text NOT NULL, space_id text NOT NULL,
+				event_type text NOT NULL, event_schema_version integer NOT NULL,
+				subject_type text NOT NULL, subject_id text NOT NULL,
+				actor_id text NOT NULL, actor_type text NOT NULL, action_invocation_id text,
+				payload jsonb NOT NULL, sequence bigint NOT NULL,
+				occurred_at timestamptz NOT NULL, recorded_at timestamptz NOT NULL,
+				correlation_id text NOT NULL, causation_id text,
+				UNIQUE (tenant_id, space_id, sequence)
+			);
+			CREATE INDEX IF NOT EXISTS asset_events_subject_idx
+				ON fabric_platform.asset_events
+				(tenant_id, space_id, subject_type, subject_id, sequence);
+		`);
+  }
+  async transaction(run) {
+    return run(this.db);
+  }
+  async createActionInvocation(input) {
+    const now = /* @__PURE__ */ new Date();
+    await this.sql.query(
+      `INSERT INTO fabric_platform.action_invocations
+			 (id,tenant_id,space_id,action_id,action_version,actor_id,actor_type,status,
+			  parameters,result,correlation_id,causation_id,error,created_at,updated_at)
+			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14,$14)`,
+      [
+        input.id,
+        input.tenantId,
+        input.spaceId,
+        input.actionId,
+        input.actionVersion,
+        input.actorId,
+        input.actorType,
+        input.status,
+        JSON.stringify(input.parameters),
+        JSON.stringify(input.result),
+        input.correlationId,
+        input.causationId ?? null,
+        input.error ?? null,
+        now
+      ]
+    );
+    return { ...input, createdAt: now, updatedAt: now };
+  }
+  async getActionInvocation(id, tenantId, spaceId) {
+    const result = await this.sql.query(
+      `SELECT * FROM fabric_platform.action_invocations
+			 WHERE id=$1 AND tenant_id=$2 AND space_id=$3`,
+      [id, tenantId, spaceId]
+    );
+    return result.rows[0] ? toActionRecord(result.rows[0]) : void 0;
+  }
+  async updateActionInvocation(id, tenantId, spaceId, patch) {
+    await this.sql.query(
+      `UPDATE fabric_platform.action_invocations SET
+			 status=COALESCE($4,status), result=COALESCE($5::jsonb,result),
+			 error=CASE WHEN $6::boolean THEN $7 ELSE error END, updated_at=now()
+			 WHERE id=$1 AND tenant_id=$2 AND space_id=$3`,
+      [
+        id,
+        tenantId,
+        spaceId,
+        patch.status ?? null,
+        patch.result === void 0 ? null : JSON.stringify(patch.result),
+        Object.hasOwn(patch, "error"),
+        patch.error ?? null
+      ]
+    );
+  }
+  async appendPolicyEvaluation(record) {
+    await this.sql.query(
+      `INSERT INTO fabric_platform.policy_evaluations
+			 (id,action_invocation_id,tenant_id,space_id,outcome,created_at)
+			 VALUES ($1,$2,$3,$4,$5::jsonb,$6)`,
+      [
+        record.id,
+        record.actionInvocationId,
+        record.tenantId,
+        record.spaceId,
+        JSON.stringify(record.outcome),
+        record.createdAt
+      ]
+    );
+  }
+  async createAdapterInvocation(record) {
+    await this.sql.query(
+      `INSERT INTO fabric_platform.adapter_invocations
+			 (id,action_invocation_id,tenant_id,space_id,adapter_type,operation,vendor,status,
+			  input,output,error,attempt,created_at,updated_at)
+			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10::jsonb,$11,$12,$13,$14)`,
+      [
+        record.id,
+        record.actionInvocationId,
+        record.tenantId,
+        record.spaceId,
+        record.adapterType,
+        record.operation,
+        record.vendor,
+        record.status,
+        JSON.stringify(record.input),
+        record.output ? JSON.stringify(record.output) : null,
+        record.error ?? null,
+        record.attempt,
+        record.createdAt,
+        record.updatedAt
+      ]
+    );
+  }
+  async updateAdapterInvocation(id, patch) {
+    await this.sql.query(
+      `UPDATE fabric_platform.adapter_invocations SET
+			 status=COALESCE($2,status), output=COALESCE($3::jsonb,output),
+			 error=CASE WHEN $4::boolean THEN $5 ELSE error END,
+			 attempt=COALESCE($6,attempt), updated_at=COALESCE($7,now()) WHERE id=$1`,
+      [
+        id,
+        patch.status ?? null,
+        patch.output === void 0 ? null : JSON.stringify(patch.output),
+        Object.hasOwn(patch, "error"),
+        patch.error ?? null,
+        patch.attempt ?? null,
+        patch.updatedAt ?? null
+      ]
+    );
+  }
+  async appendEvent(event) {
+    await this.sql.query(
+      `INSERT INTO fabric_platform.asset_events
+			 (id,tenant_id,space_id,event_type,event_schema_version,subject_type,subject_id,
+			  actor_id,actor_type,action_invocation_id,payload,sequence,occurred_at,recorded_at,
+			  correlation_id,causation_id)
+			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11::jsonb,$12,$13,$14,$15,$16)`,
+      [
+        event.id,
+        event.tenantId,
+        event.spaceId,
+        event.eventType,
+        event.eventSchemaVersion,
+        event.subjectType,
+        event.subjectId,
+        event.actorId,
+        event.actorType,
+        event.actionInvocationId ?? null,
+        JSON.stringify(event.payload),
+        event.sequence,
+        event.occurredAt,
+        event.recordedAt,
+        event.correlationId,
+        event.causationId ?? null
+      ]
+    );
+  }
+  async nextEventSequence(tenantId, spaceId) {
+    const result = await this.sql.query(
+      `INSERT INTO fabric_platform.event_sequences (tenant_id,space_id,next_sequence)
+			 VALUES ($1,$2,1) ON CONFLICT (tenant_id,space_id) DO UPDATE
+			 SET next_sequence=fabric_platform.event_sequences.next_sequence+1
+			 RETURNING next_sequence`,
+      [tenantId, spaceId]
+    );
+    return Number(result.rows[0].next_sequence);
+  }
+  async getEntityState(tenantId, spaceId, entityType, entityId) {
+    const result = await this.sql.query(
+      `SELECT payload->>'toState' AS state FROM fabric_platform.asset_events
+			 WHERE tenant_id=$1 AND space_id=$2 AND subject_type=$3 AND subject_id=$4
+			 AND payload ? 'toState' ORDER BY sequence DESC LIMIT 1`,
+      [tenantId, spaceId, entityType, entityId]
+    );
+    return result.rows[0]?.state;
+  }
+  async listEvents(tenantId, spaceId) {
+    const result = await this.sql.query(
+      `SELECT * FROM fabric_platform.asset_events
+			 WHERE tenant_id=$1 AND space_id=$2 ORDER BY sequence`,
+      [tenantId, spaceId]
+    );
+    return result.rows.map(toEventRecord);
+  }
+};
+function toActionRecord(row) {
+  return {
+    id: String(row.id),
+    tenantId: String(row.tenant_id),
+    spaceId: String(row.space_id),
+    actionId: String(row.action_id),
+    actionVersion: Number(row.action_version),
+    actorId: String(row.actor_id),
+    actorType: String(row.actor_type),
+    status: String(row.status),
+    parameters: row.parameters,
+    result: row.result,
+    correlationId: String(row.correlation_id),
+    ...row.causation_id ? { causationId: String(row.causation_id) } : {},
+    ...row.error ? { error: String(row.error) } : {},
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+function toEventRecord(row) {
+  return {
+    id: String(row.id),
+    tenantId: String(row.tenant_id),
+    spaceId: String(row.space_id),
+    eventType: String(row.event_type),
+    eventSchemaVersion: Number(row.event_schema_version),
+    subjectType: String(row.subject_type),
+    subjectId: String(row.subject_id),
+    actorId: String(row.actor_id),
+    actorType: String(row.actor_type),
+    ...row.action_invocation_id ? { actionInvocationId: String(row.action_invocation_id) } : {},
+    payload: row.payload,
+    sequence: Number(row.sequence),
+    occurredAt: new Date(row.occurred_at),
+    recordedAt: new Date(row.recorded_at),
+    correlationId: String(row.correlation_id),
+    ...row.causation_id ? { causationId: String(row.causation_id) } : {}
+  };
+}
+
+export { MemoryPlatformHostStore, PostgresPlatformHostStore, createGovernedActionHost };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map