@lssm/lib.contracts 1.41.1 → 1.42.1

package/dist/tests/runner.d.ts

@@ -0,0 +1,43 @@
+import { HandlerCtx } from "../types.js";
+import { Assertion, TestScenario, TestSpec } from "./spec.js";
+import { OperationSpecRegistry } from "../operations/registry.js";
+import "../index.js";
+
+//#region src/tests/runner.d.ts
+interface ScenarioRunResult {
+  scenario: TestScenario;
+  status: 'passed' | 'failed';
+  error?: Error;
+  assertionResults: AssertionResult[];
+}
+interface AssertionResult {
+  assertion: Assertion;
+  status: 'passed' | 'failed';
+  message?: string;
+}
+interface TestRunResult {
+  spec: TestSpec;
+  scenarios: ScenarioRunResult[];
+  passed: number;
+  failed: number;
+}
+interface TestRunnerConfig {
+  registry: OperationSpecRegistry;
+  createContext?: () => HandlerCtx | Promise<HandlerCtx>;
+  beforeEach?: (scenario: TestScenario) => void | Promise<void>;
+  afterEach?: (scenario: TestScenario, result: ScenarioRunResult) => void | Promise<void>;
+}
+declare class TestRunner {
+  private readonly config;
+  constructor(config: TestRunnerConfig);
+  run(spec: TestSpec): Promise<TestRunResult>;
+  private runScenario;
+  private createContext;
+  private executeOperation;
+  private evaluateAssertion;
+  private evaluateOutputAssertion;
+  private evaluateErrorAssertion;
+  private evaluateEventsAssertion;
+}
+//#endregion
+export { AssertionResult, ScenarioRunResult, TestRunResult, TestRunner, TestRunnerConfig };

package/dist/tests/runner.js

@@ -1 +1,150 @@
-import"../index.js";import{deepStrictEqual as e}from"node:assert";var t=class{constructor(e){this.config=e}async run(e){let t=[],n=0,r=0;for(let i of e.scenarios){await this.config.beforeEach?.(i);let a=await this.runScenario(e,i);t.push(a),a.status===`passed`?n+=1:r+=1,await this.config.afterEach?.(i,a)}return{spec:e,scenarios:t,passed:n,failed:r}}async runScenario(e,t){let n=[];try{let r=await this.createContext(),i=[...e.fixtures??[],...t.given??[]],a=[];for(let e of i)await this.executeOperation(e,r,a);let o=await this.executeOperation(t.when,r,a),s=t.then??[];for(let e of s){let t=this.evaluateAssertion(e,o,a);n.push(t)}return{scenario:t,status:n.some(e=>e.status===`failed`)?`failed`:`passed`,assertionResults:n}}catch(e){return{scenario:t,status:`failed`,error:e,assertionResults:n}}}async createContext(){return{...await this.config.createContext?.()??{}}}async executeOperation(e,t,n){let r={...t,eventPublisher:async e=>{n.push({name:e.name,version:e.version,payload:e.payload}),await t.eventPublisher?.(e)}};try{return{output:await this.config.registry.execute(e.operation.name,e.operation.version,e.input??null,r),events:n}}catch(e){return{error:e,events:n}}}evaluateAssertion(e,t,n){switch(e.type){case`expectOutput`:return this.evaluateOutputAssertion(e,t);case`expectError`:return this.evaluateErrorAssertion(e,t);case`expectEvents`:return this.evaluateEventsAssertion(e,n);default:return{assertion:e,status:`failed`,message:`Unknown assertion type ${e.type}`}}}evaluateOutputAssertion(t,n){if(n.error)return{assertion:t,status:`failed`,message:`Expected output but operation threw error: ${n.error.message}`};try{return e(n.output,t.match),{assertion:t,status:`passed`}}catch(e){return{assertion:t,status:`failed`,message:e instanceof Error?e.message:`Output assertion failed`}}}evaluateErrorAssertion(e,t){return t.error?e.messageIncludes&&!t.error.message.includes(e.messageIncludes)?{assertion:e,status:`failed`,message:`Error message "${t.error.message}" did not include expected substring "${e.messageIncludes}"`}:{assertion:e,status:`passed`}:{assertion:e,status:`failed`,message:`Expected an error but operation completed successfully`}}evaluateEventsAssertion(e,t){let n=[];for(let r of e.events){let e=t.filter(e=>e.name===r.name&&e.version===r.version).length;typeof r.min==`number`&&e<r.min||typeof r.max==`number`&&e>r.max?n.push(`Event ${r.name}.v${r.version} occurred ${e} times (expected ${r.min??0} - ${r.max??`∞`})`):r.min===void 0&&r.max===void 0&&e===0&&n.push(`Event ${r.name}.v${r.version} did not occur`)}return n.length>0?{assertion:e,status:`failed`,message:n.join(`; `)}:{assertion:e,status:`passed`}}};export{t as TestRunner};
+import "../index.js";
+import { deepStrictEqual } from "node:assert";
+
+//#region src/tests/runner.ts
+var TestRunner = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async run(spec) {
+		const scenarios = [];
+		let passed = 0;
+		let failed = 0;
+		for (const scenario of spec.scenarios) {
+			await this.config.beforeEach?.(scenario);
+			const result = await this.runScenario(spec, scenario);
+			scenarios.push(result);
+			if (result.status === "passed") passed += 1;
+			else failed += 1;
+			await this.config.afterEach?.(scenario, result);
+		}
+		return {
+			spec,
+			scenarios,
+			passed,
+			failed
+		};
+	}
+	async runScenario(spec, scenario) {
+		const assertionResults = [];
+		try {
+			const context = await this.createContext();
+			const fixtures = [...spec.fixtures ?? [], ...scenario.given ?? []];
+			const events = [];
+			for (const fixture of fixtures) await this.executeOperation(fixture, context, events);
+			const actionResult = await this.executeOperation(scenario.when, context, events);
+			const assertions = scenario.then ?? [];
+			for (const assertion of assertions) {
+				const assertionResult = this.evaluateAssertion(assertion, actionResult, events);
+				assertionResults.push(assertionResult);
+			}
+			return {
+				scenario,
+				status: assertionResults.some((assertion) => assertion.status === "failed") ? "failed" : "passed",
+				assertionResults
+			};
+		} catch (error) {
+			return {
+				scenario,
+				status: "failed",
+				error,
+				assertionResults
+			};
+		}
+	}
+	async createContext() {
+		return { ...await this.config.createContext?.() ?? {} };
+	}
+	async executeOperation(action, baseCtx, recordedEvents) {
+		const ctx = {
+			...baseCtx,
+			eventPublisher: async (event) => {
+				recordedEvents.push({
+					key: event.key,
+					version: event.version,
+					payload: event.payload
+				});
+				await baseCtx.eventPublisher?.(event);
+			}
+		};
+		try {
+			return {
+				output: await this.config.registry.execute(action.operation.key, action.operation.version, action.input ?? null, ctx),
+				events: recordedEvents
+			};
+		} catch (error) {
+			return {
+				error,
+				events: recordedEvents
+			};
+		}
+	}
+	evaluateAssertion(assertion, result, events) {
+		switch (assertion.type) {
+			case "expectOutput": return this.evaluateOutputAssertion(assertion, result);
+			case "expectError": return this.evaluateErrorAssertion(assertion, result);
+			case "expectEvents": return this.evaluateEventsAssertion(assertion, events);
+			default: return {
+				assertion,
+				status: "failed",
+				message: `Unknown assertion type ${assertion.type}`
+			};
+		}
+	}
+	evaluateOutputAssertion(assertion, result) {
+		if (result.error) return {
+			assertion,
+			status: "failed",
+			message: `Expected output but operation threw error: ${result.error.message}`
+		};
+		try {
+			deepStrictEqual(result.output, assertion.match);
+			return {
+				assertion,
+				status: "passed"
+			};
+		} catch (error) {
+			return {
+				assertion,
+				status: "failed",
+				message: error instanceof Error ? error.message : "Output assertion failed"
+			};
+		}
+	}
+	evaluateErrorAssertion(assertion, result) {
+		if (!result.error) return {
+			assertion,
+			status: "failed",
+			message: "Expected an error but operation completed successfully"
+		};
+		if (assertion.messageIncludes && !result.error.message.includes(assertion.messageIncludes)) return {
+			assertion,
+			status: "failed",
+			message: `Error message "${result.error.message}" did not include expected substring "${assertion.messageIncludes}"`
+		};
+		return {
+			assertion,
+			status: "passed"
+		};
+	}
+	evaluateEventsAssertion(assertion, events) {
+		const failures = [];
+		for (const expected of assertion.events) {
+			const count = events.filter((event) => event.key === expected.key && event.version === expected.version).length;
+			if (typeof expected.min === "number" && count < expected.min || typeof expected.max === "number" && count > expected.max) failures.push(`Event ${expected.key}.v${expected.version} occurred ${count} times (expected ${expected.min ?? 0} - ${expected.max ?? "∞"})`);
+			else if (typeof expected.min === "undefined" && typeof expected.max === "undefined" && count === 0) failures.push(`Event ${expected.key}.v${expected.version} did not occur`);
+		}
+		if (failures.length > 0) return {
+			assertion,
+			status: "failed",
+			message: failures.join("; ")
+		};
+		return {
+			assertion,
+			status: "passed"
+		};
+	}
+};
+
+//#endregion
+export { TestRunner };

package/dist/tests/spec.d.ts

@@ -0,0 +1,89 @@
+import { Owner, Stability, Tag } from "../ownership.js";
+
+//#region src/tests/spec.d.ts
+interface OperationTargetRef {
+  key: string;
+  version?: number;
+}
+interface WorkflowTargetRef {
+  key: string;
+  version?: number;
+}
+type TestTarget = {
+  type: 'operation';
+  operation: OperationTargetRef;
+} | {
+  type: 'workflow';
+  workflow: WorkflowTargetRef;
+};
+interface Fixture {
+  description?: string;
+  operation: OperationTargetRef;
+  input?: unknown;
+}
+interface Action {
+  operation: OperationTargetRef;
+  input?: unknown;
+}
+interface ExpectOutputAssertion {
+  type: 'expectOutput';
+  match: unknown;
+}
+interface ExpectErrorAssertion {
+  type: 'expectError';
+  messageIncludes?: string;
+}
+interface ExpectedEvent {
+  key: string;
+  version: number;
+  min?: number;
+  max?: number;
+}
+interface ExpectEventsAssertion {
+  type: 'expectEvents';
+  events: ExpectedEvent[];
+}
+type Assertion = ExpectOutputAssertion | ExpectErrorAssertion | ExpectEventsAssertion;
+interface TestScenario {
+  key: string;
+  description?: string;
+  given?: Fixture[];
+  when: Action;
+  then?: Assertion[];
+}
+interface CoverageRequirement {
+  statements?: number;
+  branches?: number;
+  functions?: number;
+  lines?: number;
+  mutations?: number;
+}
+interface TestSpecMeta {
+  key: string;
+  version: number;
+  title: string;
+  description?: string;
+  owners: Owner[];
+  tags: Tag[];
+  stability: Stability;
+}
+interface TestSpec {
+  meta: TestSpecMeta;
+  target: TestTarget;
+  fixtures?: Fixture[];
+  scenarios: TestScenario[];
+  coverage?: CoverageRequirement;
+}
+interface TestSpecRef {
+  key: string;
+  version?: number;
+}
+declare class TestRegistry {
+  private readonly items;
+  register(spec: TestSpec): this;
+  list(): TestSpec[];
+  get(name: string, version?: number): TestSpec | undefined;
+}
+declare function makeTestKey(meta: TestSpecMeta): string;
+//#endregion
+export { Action, Assertion, CoverageRequirement, ExpectErrorAssertion, ExpectEventsAssertion, ExpectOutputAssertion, ExpectedEvent, Fixture, OperationTargetRef, TestRegistry, TestScenario, TestSpec, TestSpecMeta, TestSpecRef, TestTarget, WorkflowTargetRef, makeTestKey };

package/dist/tests/spec.js

@@ -1 +1,33 @@
-const e=e=>`${e.name}.v${e.version}`;var t=class{items=new Map;register(t){let n=e(t.meta);if(this.items.has(n))throw Error(`Duplicate TestSpec registration for ${n}`);return this.items.set(n,t),this}list(){return[...this.items.values()]}get(e,t){if(t!=null)return this.items.get(`${e}.v${t}`);let n,r=-1/0;for(let t of this.items.values())t.meta.name===e&&t.meta.version>r&&(r=t.meta.version,n=t);return n}};function n(t){return e(t)}export{t as TestRegistry,n as makeTestKey};
+//#region src/tests/spec.ts
+const testKey = (meta) => `${meta.key}.v${meta.version}`;
+var TestRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	register(spec) {
+		const key = testKey(spec.meta);
+		if (this.items.has(key)) throw new Error(`Duplicate TestSpec registration for ${key}`);
+		this.items.set(key, spec);
+		return this;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(name, version) {
+		if (version != null) return this.items.get(`${name}.v${version}`);
+		let latest;
+		let maxVersion = -Infinity;
+		for (const spec of this.items.values()) {
+			if (spec.meta.key !== name) continue;
+			if (spec.meta.version > maxVersion) {
+				maxVersion = spec.meta.version;
+				latest = spec;
+			}
+		}
+		return latest;
+	}
+};
+function makeTestKey(meta) {
+	return testKey(meta);
+}
+
+//#endregion
+export { TestRegistry, makeTestKey };

package/dist/themes.d.ts

@@ -0,0 +1,53 @@
+import { OwnerShipMeta } from "./ownership.js";
+
+//#region src/themes.d.ts
+type ThemeScope = 'global' | 'tenant' | 'user';
+interface ThemeToken<T> {
+  value: T;
+  description?: string;
+}
+interface ThemeTokens {
+  colors?: Record<string, ThemeToken<string>>;
+  radii?: Record<string, ThemeToken<number>>;
+  space?: Record<string, ThemeToken<number>>;
+  typography?: Record<string, ThemeToken<number>>;
+  shadows?: Record<string, ThemeToken<string>>;
+  motion?: Record<string, ThemeToken<string>>;
+}
+interface ComponentVariantDefinition {
+  props?: Record<string, unknown>;
+  tokens?: ThemeTokens;
+}
+interface ComponentVariantSpec {
+  component: string;
+  variants: Record<string, ComponentVariantDefinition>;
+}
+interface ThemeOverride {
+  scope: ThemeScope;
+  target: string;
+  tokens?: ThemeTokens;
+  components?: ComponentVariantSpec[];
+}
+interface ThemeMeta extends OwnerShipMeta {
+  extends?: ThemeRef;
+  scopes?: ThemeScope[];
+}
+interface ThemeSpec {
+  meta: ThemeMeta;
+  tokens: ThemeTokens;
+  components?: ComponentVariantSpec[];
+  overrides?: ThemeOverride[];
+}
+interface ThemeRef {
+  key: string;
+  version: number;
+}
+declare class ThemeRegistry {
+  private readonly items;
+  register(spec: ThemeSpec): this;
+  list(): ThemeSpec[];
+  get(key: string, version?: number): ThemeSpec | undefined;
+}
+declare function makeThemeRef(spec: ThemeSpec): ThemeRef;
+//#endregion
+export { ComponentVariantDefinition, ComponentVariantSpec, ThemeMeta, ThemeOverride, ThemeRef, ThemeRegistry, ThemeScope, ThemeSpec, ThemeToken, ThemeTokens, makeThemeRef };

package/dist/themes.js

@@ -1 +1,39 @@
-const e=e=>`${e.name}.v${e.version}`;var t=class{items=new Map;register(t){let n=e(t.meta);if(this.items.has(n))throw Error(`Duplicate theme ${n}`);return this.items.set(n,t),this}list(){return[...this.items.values()]}get(t,n){if(n!=null)return this.items.get(e({name:t,version:n}));let r,i=-1/0;for(let e of this.items.values())e.meta.name===t&&e.meta.version>i&&(i=e.meta.version,r=e);return r}};function n(e){return{name:e.meta.name,version:e.meta.version}}export{t as ThemeRegistry,n as makeThemeRef};
+//#region src/themes.ts
+const themeKey = (ref) => `${ref.key}.v${ref.version}`;
+var ThemeRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	register(spec) {
+		const key = themeKey(spec.meta);
+		if (this.items.has(key)) throw new Error(`Duplicate theme ${key}`);
+		this.items.set(key, spec);
+		return this;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(key, version) {
+		if (version != null) return this.items.get(themeKey({
+			key,
+			version
+		}));
+		let candidate;
+		let max = -Infinity;
+		for (const spec of this.items.values()) {
+			if (spec.meta.key !== key) continue;
+			if (spec.meta.version > max) {
+				max = spec.meta.version;
+				candidate = spec;
+			}
+		}
+		return candidate;
+	}
+};
+function makeThemeRef(spec) {
+	return {
+		key: spec.meta.key,
+		version: spec.meta.version
+	};
+}
+
+//#endregion
+export { ThemeRegistry, makeThemeRef };

package/dist/translations/catalog.d.ts

@@ -0,0 +1,28 @@
+//#region src/translations/catalog.d.ts
+type Locale = string;
+type MessageKey = string;
+interface TranslationEntry {
+  key: MessageKey;
+  locale: Locale;
+  value: string;
+  context?: string;
+}
+interface TranslationCatalogMeta {
+  key: string;
+  version: number;
+  description?: string;
+}
+interface PlatformTranslationCatalog {
+  meta: TranslationCatalogMeta;
+  defaultLocale: Locale;
+  supportedLocales: Locale[];
+  entries: TranslationEntry[];
+}
+interface BlueprintTranslationCatalog {
+  meta: TranslationCatalogMeta;
+  defaultLocale: Locale;
+  supportedLocales: Locale[];
+  entries: TranslationEntry[];
+}
+//#endregion
+export { BlueprintTranslationCatalog, Locale, MessageKey, PlatformTranslationCatalog, TranslationCatalogMeta, TranslationEntry };

package/dist/translations/tenant.d.ts

@@ -0,0 +1,15 @@
+import { Locale, TranslationEntry } from "./catalog.js";
+
+//#region src/translations/tenant.d.ts
+interface TenantTranslationOverride {
+  tenantId: string;
+  appId: string;
+  blueprintName: string;
+  blueprintVersion: number;
+  entries: TranslationEntry[];
+  defaultLocale?: Locale;
+  enabledLocales?: Locale[];
+  updatedAt?: string;
+}
+//#endregion
+export { TenantTranslationOverride };

package/dist/types.d.ts

@@ -0,0 +1,92 @@
+import { ConsentDefinition, PolicySpec, RateLimitDefinition } from "./policy/spec.js";
+import { TelemetryTracker } from "./telemetry/tracker.js";
+import "./telemetry/index.js";
+import { ResolvedBranding } from "./app-config/branding.js";
+import { Locale, MessageKey } from "./translations/catalog.js";
+import { ResolvedAppConfig, ResolvedIntegration, ResolvedKnowledge, ResolvedTranslation } from "./app-config/runtime.js";
+import { SecretProvider } from "./integrations/secrets/provider.js";
+import { SpecVariantResolver } from "./experiments/spec-resolver.js";
+import { EventRegistry } from "./events.js";
+
+//#region src/types.d.ts
+/**
+ * Common runtime types: execution context, policy decision & event emission.
+ */
+type Actor = 'anonymous' | 'user' | 'admin';
+type Channel = 'web' | 'mobile' | 'job' | 'agent';
+type ContractSpecType = 'app-config' | 'capability' | 'data-view' | 'experiment' | 'form' | 'integration' | 'knowledge' | 'operation' | 'policy' | 'presentation' | 'telemetry' | 'workflow' | 'event' | 'feature' | 'migration';
+interface FieldLevelDecision {
+  field: string;
+  effect: 'allow' | 'deny';
+  reason?: string;
+}
+interface PolicyDecision {
+  effect: 'allow' | 'deny';
+  reason?: string;
+  rateLimit?: Pick<RateLimitDefinition, 'rpm' | 'key' | 'windowSeconds' | 'burst'>;
+  escalate?: 'human_review' | null;
+  fieldDecisions?: FieldLevelDecision[];
+  pii?: PolicySpec['pii'];
+  requiredConsents?: ConsentDefinition[];
+  evaluatedBy?: 'engine' | 'opa';
+}
+interface PolicyDeciderInput {
+  service: string;
+  command: string;
+  version: number;
+  actor: Actor;
+  channel?: Channel;
+  roles?: string[];
+  organizationId?: string | null;
+  userId?: string | null;
+  flags?: string[];
+}
+type PolicyDecider = (input: PolicyDeciderInput) => Promise<PolicyDecision>;
+type RateLimiter = (key: string, cost: number, rpm: number) => Promise<void>;
+type TranslationResolver = (key: MessageKey, locale?: Locale) => Promise<string | null> | string | null;
+/** Outbox/bus event publisher (after validation & guarding) */
+type EventPublisher = (envelope: {
+  key: string;
+  version: number;
+  payload: unknown;
+  traceId?: string;
+}) => Promise<void>;
+interface HandlerCtx {
+  traceId?: string;
+  idemKey?: string;
+  organizationId?: string | null;
+  userId?: string | null;
+  actor?: Actor;
+  channel?: Channel;
+  roles?: string[];
+  /** Policy engine hook (policy.yaml) */
+  decide?: PolicyDecider;
+  /** Rate limiter (e.g., Redis) */
+  rateLimit?: RateLimiter;
+  /** Telemetry tracker */
+  telemetry?: TelemetryTracker;
+  /** Event publisher (outbox+bus) */
+  eventPublisher?: EventPublisher;
+  /** Secret provider for secure credentials */
+  secretProvider?: SecretProvider;
+  /** Internal pipe: filled by executor to enforce declared events */
+  __emitGuard__?: (key: string, version: number, payload: unknown) => Promise<void>;
+  /** Resolved application configuration for the current execution context */
+  appConfig?: ResolvedAppConfig;
+  /** Resolved integration connections available to this execution */
+  integrations?: ResolvedIntegration[];
+  /** Resolved knowledge spaces available to this execution */
+  knowledge?: ResolvedKnowledge[];
+  /** Resolved branding context */
+  branding?: ResolvedBranding;
+  /** Translation context */
+  translation?: {
+    config: ResolvedTranslation;
+    resolve?: TranslationResolver;
+  };
+  /** Optional spec variant resolver for experiments */
+  specVariantResolver?: SpecVariantResolver;
+  eventSpecResolver?: EventRegistry;
+}
+//#endregion
+export { Actor, Channel, ContractSpecType, EventPublisher, FieldLevelDecision, HandlerCtx, PolicyDecider, PolicyDeciderInput, PolicyDecision, RateLimiter, TranslationResolver };

package/dist/workflow/adapters/db-adapter.d.ts

@@ -0,0 +1,46 @@
+import { StateStore, WorkflowState, WorkflowStateFilters } from "../state.js";
+
+//#region src/workflow/adapters/db-adapter.d.ts
+interface WorkflowStateRecord {
+  id: string;
+  name: string;
+  version: string;
+  status: string;
+  currentStep: string;
+  data: unknown;
+  history: unknown[];
+  retryCounts: Record<string, number>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface PrismaClientLike {
+  workflowState: {
+    create: (args: {
+      data: Record<string, unknown>;
+    }) => Promise<WorkflowStateRecord>;
+    findUnique: (args: {
+      where: {
+        id: string;
+      };
+    }) => Promise<WorkflowStateRecord | null>;
+    update: (args: {
+      where: {
+        id: string;
+      };
+      data: Record<string, unknown>;
+    }) => Promise<WorkflowStateRecord>;
+    findMany: (args: {
+      where?: Record<string, unknown>;
+    }) => Promise<WorkflowStateRecord[]>;
+  };
+}
+declare class PrismaStateStore implements StateStore {
+  private readonly prisma;
+  constructor(prisma: PrismaClientLike);
+  create(state: WorkflowState): Promise<void>;
+  get(workflowId: string): Promise<WorkflowState | undefined>;
+  update(workflowId: string, updater: (current: WorkflowState) => WorkflowState): Promise<WorkflowState>;
+  list(filters?: WorkflowStateFilters): Promise<WorkflowState[]>;
+}
+//#endregion
+export { PrismaStateStore };

package/dist/workflow/adapters/db-adapter.js

@@ -1 +1,83 @@
-var e=class{constructor(e){this.prisma=e}async create(e){await this.prisma.workflowState.create({data:{id:e.workflowId,name:e.workflowName,version:e.workflowVersion,status:e.status,currentStep:e.currentStep,data:e.data,history:e.history,retryCounts:e.retryCounts??{},createdAt:e.createdAt,updatedAt:e.updatedAt}})}async get(e){let t=await this.prisma.workflowState.findUnique({where:{id:e}});if(t)return{workflowId:t.id,workflowName:t.name,workflowVersion:t.version,currentStep:t.currentStep,data:t.data,history:t.history,retryCounts:t.retryCounts,status:t.status,createdAt:t.createdAt,updatedAt:t.updatedAt}}async update(e,t){let n=await this.get(e);if(!n)throw Error(`Workflow ${e} not found`);let r=t(n),i=await this.prisma.workflowState.update({where:{id:e},data:{status:r.status,currentStep:r.currentStep,data:r.data,history:r.history,retryCounts:r.retryCounts,updatedAt:r.updatedAt}});return{workflowId:i.id,workflowName:i.name,workflowVersion:i.version,currentStep:i.currentStep,data:i.data,history:i.history,retryCounts:i.retryCounts,status:i.status,createdAt:i.createdAt,updatedAt:i.updatedAt}}async list(e){let t={};return e?.status&&(t.status=e.status),(await this.prisma.workflowState.findMany({where:t})).map(e=>({workflowId:e.id,workflowName:e.name,workflowVersion:e.version,currentStep:e.currentStep,data:e.data,history:e.history,retryCounts:e.retryCounts,status:e.status,createdAt:e.createdAt,updatedAt:e.updatedAt}))}};export{e as PrismaStateStore};
+//#region src/workflow/adapters/db-adapter.ts
+var PrismaStateStore = class {
+	constructor(prisma) {
+		this.prisma = prisma;
+	}
+	async create(state) {
+		await this.prisma.workflowState.create({ data: {
+			id: state.workflowId,
+			name: state.workflowName,
+			version: state.workflowVersion,
+			status: state.status,
+			currentStep: state.currentStep,
+			data: state.data,
+			history: state.history,
+			retryCounts: state.retryCounts ?? {},
+			createdAt: state.createdAt,
+			updatedAt: state.updatedAt
+		} });
+	}
+	async get(workflowId) {
+		const record = await this.prisma.workflowState.findUnique({ where: { id: workflowId } });
+		if (!record) return void 0;
+		return {
+			workflowId: record.id,
+			workflowName: record.name,
+			workflowVersion: parseInt(record.version, 10),
+			currentStep: record.currentStep,
+			data: record.data,
+			history: record.history,
+			retryCounts: record.retryCounts,
+			status: record.status,
+			createdAt: record.createdAt,
+			updatedAt: record.updatedAt
+		};
+	}
+	async update(workflowId, updater) {
+		const current = await this.get(workflowId);
+		if (!current) throw new Error(`Workflow ${workflowId} not found`);
+		const next = updater(current);
+		const updated = await this.prisma.workflowState.update({
+			where: { id: workflowId },
+			data: {
+				status: next.status,
+				currentStep: next.currentStep,
+				data: next.data,
+				history: next.history,
+				retryCounts: next.retryCounts,
+				updatedAt: next.updatedAt
+			}
+		});
+		return {
+			workflowId: updated.id,
+			workflowName: updated.name,
+			workflowVersion: parseInt(updated.version, 10),
+			currentStep: updated.currentStep,
+			data: updated.data,
+			history: updated.history,
+			retryCounts: updated.retryCounts,
+			status: updated.status,
+			createdAt: updated.createdAt,
+			updatedAt: updated.updatedAt
+		};
+	}
+	async list(filters) {
+		const where = {};
+		if (filters?.status) where.status = filters.status;
+		return (await this.prisma.workflowState.findMany({ where })).map((record) => ({
+			workflowId: record.id,
+			workflowName: record.name,
+			workflowVersion: parseInt(record.version, 10),
+			currentStep: record.currentStep,
+			data: record.data,
+			history: record.history,
+			retryCounts: record.retryCounts,
+			status: record.status,
+			createdAt: record.createdAt,
+			updatedAt: record.updatedAt
+		}));
+	}
+};
+
+//#endregion
+export { PrismaStateStore };