@entifix/workflow 0.0.0-stage → 0.12.1

package/dist/status/flow-status-store.d.ts

@@ -0,0 +1,59 @@
+import type { StoreFailure } from '@entifix/core';
+import type { FlowState } from '@entifix/transactions';
+import { Context, Effect, Metric, Option } from 'effect';
+/**
+ * What the engine knows about one flow beyond its journal: the state a reader
+ * is answered with, the step it is at, and the wait it is parked on.
+ *
+ * Kept beside the journal because the journal answers "did it finish" and
+ * nothing finer — a flow parked on a signal and one mid-call look the same to
+ * it, and a signal must be refused unless the flow is waiting for exactly it.
+ */
+export interface FlowRecord {
+    readonly flowId: string;
+    /** The workflow execution the flow runs as. */
+    readonly executionId: string;
+    readonly state: FlowState;
+    readonly step?: string;
+    /** The step whose signal the flow waits for, while `state` is `waiting`. */
+    readonly waitingFor?: string;
+    /** What that wait is correlated with — the order a delivery flow follows. */
+    readonly correlation?: string;
+}
+/** A change to a flow's record: its new state, and where it now stands. */
+export interface FlowRecordPatch {
+    readonly state: FlowState;
+    readonly step?: string;
+    readonly waitingFor?: string;
+    readonly correlation?: string;
+}
+export interface FlowStatusStore {
+    /**
+     * Records a flow under its idempotency key, unless the key already names
+     * one — then that flow is answered and nothing is written, so a repeated
+     * start finds the flow the first one started.
+     */
+    readonly register: (key: string, record: FlowRecord) => Effect.Effect<FlowRecord, StoreFailure>;
+    readonly find: (flowId: string) => Effect.Effect<Option.Option<FlowRecord>, StoreFailure>;
+    /** The flow parked on a wait correlated with `correlation`, if one is. */
+    readonly findByCorrelation: (correlation: string) => Effect.Effect<Option.Option<FlowRecord>, StoreFailure>;
+    readonly update: (flowId: string, patch: FlowRecordPatch) => Effect.Effect<void, StoreFailure>;
+}
+/**
+ * Every state the interpreter journals a flow into, by state and the slice it
+ * runs for. Counted inside the Activity that records it, so a replay — which
+ * reads the journal rather than executing again — never counts a state twice.
+ * `suspended` is the series to alert on: a flow past its commit point that
+ * cannot go on, which a person has to look at.
+ */
+export declare const flowStates: Metric.Counter<number>;
+declare const FlowStatusStoreTag_base: Context.ServiceClass<FlowStatusStoreTag, "@entifix/workflow/FlowStatusStore", FlowStatusStore>;
+export declare class FlowStatusStoreTag extends FlowStatusStoreTag_base {
+}
+/**
+ * A status store in memory, for a single process that keeps no flow past its
+ * life — specs, and the in-memory workflow engine.
+ */
+export declare const makeInMemoryFlowStatusStore: () => FlowStatusStore;
+export {};
+//# sourceMappingURL=flow-status-store.d.ts.map

package/dist/status/flow-status-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-status-store.d.ts","sourceRoot":"","sources":["../../src/status/flow-status-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzD;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,CACjB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,UAAU,KACf,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IAC7C,QAAQ,CAAC,IAAI,EAAE,CACb,MAAM,EAAE,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,CAAC;IAC5D,0EAA0E;IAC1E,QAAQ,CAAC,iBAAiB,EAAE,CAC1B,WAAW,EAAE,MAAM,KAChB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,CAAC;IAC5D,QAAQ,CAAC,MAAM,EAAE,CACf,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,eAAe,KACnB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;CACxC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,wBAErB,CAAC;;AAEH,qBAAa,kBAAmB,SAAQ,uBAGA;CAAG;AAE3C;;;GAGG;AACH,eAAO,MAAM,2BAA2B,QAAO,eAwC9C,CAAC"}

package/dist/status/flow-status-store.js

@@ -0,0 +1,50 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { Context, Effect, Metric, Option } from 'effect';
+/**
+ * Every state the interpreter journals a flow into, by state and the slice it
+ * runs for. Counted inside the Activity that records it, so a replay — which
+ * reads the journal rather than executing again — never counts a state twice.
+ * `suspended` is the series to alert on: a flow past its commit point that
+ * cannot go on, which a person has to look at.
+ */ export const flowStates = Metric.counter('entifix_flow_states_total', {
+    description: 'Flow states the interpreter journaled, by state and source.'
+});
+export class FlowStatusStoreTag extends Context.Service()('@entifix/workflow/FlowStatusStore') {
+}
+/**
+ * A status store in memory, for a single process that keeps no flow past its
+ * life — specs, and the in-memory workflow engine.
+ */ export const makeInMemoryFlowStatusStore = ()=>{
+    const byKey = new Map();
+    const records = new Map();
+    return {
+        register: (key, record)=>Effect.sync(()=>{
+                const known = byKey.get(key);
+                if (known !== undefined) return records.get(known);
+                byKey.set(key, record.flowId);
+                records.set(record.flowId, record);
+                return record;
+            }),
+        find: (flowId)=>Effect.sync(()=>Option.fromNullishOr(records.get(flowId))),
+        findByCorrelation: (correlation)=>Effect.sync(()=>Option.fromNullishOr([
+                    ...records.values()
+                ].find((record)=>record.correlation === correlation))),
+        update: (flowId, patch)=>Effect.sync(()=>{
+                const current = records.get(flowId);
+                if (current === undefined) return;
+                records.set(flowId, _extends({
+                    flowId: current.flowId,
+                    executionId: current.executionId,
+                    state: patch.state
+                }, patch.step === undefined ? {} : {
+                    step: patch.step
+                }, patch.waitingFor === undefined ? {} : {
+                    waitingFor: patch.waitingFor
+                }, patch.correlation === undefined ? {} : {
+                    correlation: patch.correlation
+                }));
+            })
+    };
+};
+
+//# sourceMappingURL=flow-status-store.js.map

package/dist/status/flow-status-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/status/flow-status-store.ts"],"sourcesContent":["import type { StoreFailure } from '@entifix/core';\nimport type { FlowState } from '@entifix/transactions';\nimport { Context, Effect, Metric, Option } from 'effect';\n\n/**\n * What the engine knows about one flow beyond its journal: the state a reader\n * is answered with, the step it is at, and the wait it is parked on.\n *\n * Kept beside the journal because the journal answers \"did it finish\" and\n * nothing finer — a flow parked on a signal and one mid-call look the same to\n * it, and a signal must be refused unless the flow is waiting for exactly it.\n */\nexport interface FlowRecord {\n  readonly flowId: string;\n  /** The workflow execution the flow runs as. */\n  readonly executionId: string;\n  readonly state: FlowState;\n  readonly step?: string;\n  /** The step whose signal the flow waits for, while `state` is `waiting`. */\n  readonly waitingFor?: string;\n  /** What that wait is correlated with — the order a delivery flow follows. */\n  readonly correlation?: string;\n}\n\n/** A change to a flow's record: its new state, and where it now stands. */\nexport interface FlowRecordPatch {\n  readonly state: FlowState;\n  readonly step?: string;\n  readonly waitingFor?: string;\n  readonly correlation?: string;\n}\n\nexport interface FlowStatusStore {\n  /**\n   * Records a flow under its idempotency key, unless the key already names\n   * one — then that flow is answered and nothing is written, so a repeated\n   * start finds the flow the first one started.\n   */\n  readonly register: (\n    key: string,\n    record: FlowRecord,\n  ) => Effect.Effect<FlowRecord, StoreFailure>;\n  readonly find: (\n    flowId: string,\n  ) => Effect.Effect<Option.Option<FlowRecord>, StoreFailure>;\n  /** The flow parked on a wait correlated with `correlation`, if one is. */\n  readonly findByCorrelation: (\n    correlation: string,\n  ) => Effect.Effect<Option.Option<FlowRecord>, StoreFailure>;\n  readonly update: (\n    flowId: string,\n    patch: FlowRecordPatch,\n  ) => Effect.Effect<void, StoreFailure>;\n}\n\n/**\n * Every state the interpreter journals a flow into, by state and the slice it\n * runs for. Counted inside the Activity that records it, so a replay — which\n * reads the journal rather than executing again — never counts a state twice.\n * `suspended` is the series to alert on: a flow past its commit point that\n * cannot go on, which a person has to look at.\n */\nexport const flowStates = Metric.counter('entifix_flow_states_total', {\n  description: 'Flow states the interpreter journaled, by state and source.',\n});\n\nexport class FlowStatusStoreTag extends Context.Service<\n  FlowStatusStoreTag,\n  FlowStatusStore\n>()('@entifix/workflow/FlowStatusStore') {}\n\n/**\n * A status store in memory, for a single process that keeps no flow past its\n * life — specs, and the in-memory workflow engine.\n */\nexport const makeInMemoryFlowStatusStore = (): FlowStatusStore => {\n  const byKey = new Map<string, string>();\n  const records = new Map<string, FlowRecord>();\n  return {\n    register: (key, record) =>\n      Effect.sync(() => {\n        const known = byKey.get(key);\n        if (known !== undefined) return records.get(known) as FlowRecord;\n        byKey.set(key, record.flowId);\n        records.set(record.flowId, record);\n        return record;\n      }),\n    find: flowId =>\n      Effect.sync(() => Option.fromNullishOr(records.get(flowId))),\n    findByCorrelation: correlation =>\n      Effect.sync(() =>\n        Option.fromNullishOr(\n          [...records.values()].find(\n            record => record.correlation === correlation,\n          ),\n        ),\n      ),\n    update: (flowId, patch) =>\n      Effect.sync(() => {\n        const current = records.get(flowId);\n        if (current === undefined) return;\n        records.set(flowId, {\n          flowId: current.flowId,\n          executionId: current.executionId,\n          state: patch.state,\n          ...(patch.step === undefined ? {} : { step: patch.step }),\n          ...(patch.waitingFor === undefined\n            ? {}\n            : { waitingFor: patch.waitingFor }),\n          ...(patch.correlation === undefined\n            ? {}\n            : { correlation: patch.correlation }),\n        });\n      }),\n  };\n};\n"],"names":["Context","Effect","Metric","Option","flowStates","counter","description","FlowStatusStoreTag","Service","makeInMemoryFlowStatusStore","byKey","Map","records","register","key","record","sync","known","get","undefined","set","flowId","find","fromNullishOr","findByCorrelation","correlation","values","update","patch","current","executionId","state","step","waitingFor"],"mappings":";AAEA,SAASA,OAAO,EAAEC,MAAM,EAAEC,MAAM,EAAEC,MAAM,QAAQ,SAAS;AAqDzD;;;;;;CAMC,GACD,OAAO,MAAMC,aAAaF,OAAOG,OAAO,CAAC,6BAA6B;IACpEC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMC,2BAA2BP,QAAQQ,OAAO,GAGnD;AAAsC;AAE1C;;;CAGC,GACD,OAAO,MAAMC,8BAA8B;IACzC,MAAMC,QAAQ,IAAIC;IAClB,MAAMC,UAAU,IAAID;IACpB,OAAO;QACLE,UAAU,CAACC,KAAKC,SACdd,OAAOe,IAAI,CAAC;gBACV,MAAMC,QAAQP,MAAMQ,GAAG,CAACJ;gBACxB,IAAIG,UAAUE,WAAW,OAAOP,QAAQM,GAAG,CAACD;gBAC5CP,MAAMU,GAAG,CAACN,KAAKC,OAAOM,MAAM;gBAC5BT,QAAQQ,GAAG,CAACL,OAAOM,MAAM,EAAEN;gBAC3B,OAAOA;YACT;QACFO,MAAMD,CAAAA,SACJpB,OAAOe,IAAI,CAAC,IAAMb,OAAOoB,aAAa,CAACX,QAAQM,GAAG,CAACG;QACrDG,mBAAmBC,CAAAA,cACjBxB,OAAOe,IAAI,CAAC,IACVb,OAAOoB,aAAa,CAClB;uBAAIX,QAAQc,MAAM;iBAAG,CAACJ,IAAI,CACxBP,CAAAA,SAAUA,OAAOU,WAAW,KAAKA;QAIzCE,QAAQ,CAACN,QAAQO,QACf3B,OAAOe,IAAI,CAAC;gBACV,MAAMa,UAAUjB,QAAQM,GAAG,CAACG;gBAC5B,IAAIQ,YAAYV,WAAW;gBAC3BP,QAAQQ,GAAG,CAACC,QAAQ;oBAClBA,QAAQQ,QAAQR,MAAM;oBACtBS,aAAaD,QAAQC,WAAW;oBAChCC,OAAOH,MAAMG,KAAK;mBACdH,MAAMI,IAAI,KAAKb,YAAY,CAAC,IAAI;oBAAEa,MAAMJ,MAAMI,IAAI;gBAAC,GACnDJ,MAAMK,UAAU,KAAKd,YACrB,CAAC,IACD;oBAAEc,YAAYL,MAAMK,UAAU;gBAAC,GAC/BL,MAAMH,WAAW,KAAKN,YACtB,CAAC,IACD;oBAAEM,aAAaG,MAAMH,WAAW;gBAAC;YAEzC;IACJ;AACF,EAAE"}

package/package.json

@@ -1,6 +1,112 @@
 {
   "name": "@entifix/workflow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.12.1",
+  "description": "Durable flows: the slip interpreter on Effect Workflow, behind the flow engine port, with Postgres storage and socket runners.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r10c-technologies/entifix.git",
+    "directory": "packages/ts/workflow"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./postgres": {
+      "types": "./dist/postgres/index.d.ts",
+      "import": "./dist/postgres/index.js",
+      "default": "./dist/postgres/index.js"
+    },
+    "./socket-runner": {
+      "types": "./dist/socket-runner/index.d.ts",
+      "import": "./dist/socket-runner/index.js",
+      "default": "./dist/socket-runner/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "nx": {
+    "tags": [
+      "tier:2"
+    ],
+    "sourceRoot": "packages/ts/workflow/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/ts/workflow/dist",
+          "main": "packages/ts/workflow/src/index.ts",
+          "tsConfig": "packages/ts/workflow/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      },
+      "test-integration": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "vitest run --config vitest.integration.mts",
+          "cwd": "packages/ts/workflow"
+        }
+      },
+      "test-engine": {
+        "executor": "nx:run-commands",
+        "dependsOn": [
+          "build",
+          "^build"
+        ],
+        "options": {
+          "command": "vitest run --config vitest.engine.mts",
+          "cwd": "packages/ts/workflow"
+        }
+      },
+      "record-journals": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "vitest run src/interpreter/journal.spec.ts",
+          "cwd": "packages/ts/workflow",
+          "env": {
+            "ENTIFIX_RECORD_JOURNALS": "1"
+          }
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "0.5.23",
+    "@entifix/business": "0.12.1",
+    "@entifix/core": "0.12.1",
+    "@entifix/sql": "0.12.1",
+    "@entifix/transactions": "0.12.1"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.6",
+    "@effect/sql-pg": "4.0.6",
+    "effect": "4.0.6",
+    "@entifix/testing-unit": "0.12.1"
+  },
+  "peerDependencies": {
+    "@effect/platform-node": "^4.0.6",
+    "effect": "^4.0.6"
+  },
+  "peerDependenciesMeta": {
+    "@effect/platform-node": {
+      "optional": true
+    }
+  }
 }