@entifix/mongo 0.1.1 → 0.1.3

package/README.md

@@ -12,10 +12,10 @@ pnpm add @entifix/mongo effect
 
 ## Entry points
 
-| Import                        | What it holds                                                                                           |
-| ----------------------------- | ------------------------------------------------------------------------------------------------------- |
-| `@entifix/mongo`              | Repository, link resolver, query translation, client and database Layers, tenant resolver, health probe |
-| `@entifix/mongo/transactions` | Transactional outbox and inbox for `@entifix/transactions`, with the relay that drains the outbox       |
+| Import                        | What it holds                                                                                                                                                  |
+| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@entifix/mongo`              | Repository, link resolver, query translation, client and database Layers, tenant resolver, health probe                                                        |
+| `@entifix/mongo/transactions` | Transactional outbox and inbox for `@entifix/transactions`, the relay that drains the outbox, and the saga store (`makeMongoSagaStore`, `MongoSagaStoreLayer`) |
 
 ## Optional peers
 

package/dist/saga/store.d.ts

@@ -0,0 +1,24 @@
+import { EntifixConnError } from '@entifix/core';
+import { type SagaStore, SagaStoreTag } from '@entifix/transactions';
+import { Effect, Layer } from 'effect';
+import type { Db } from 'mongodb';
+import { MongoDatabaseTag } from '../mongo-database/mongo-database.js';
+/**
+ * Saga instances: one document per flow, the durable record a coordinator
+ * resumes from (r10c ADR 0055).
+ */
+export declare const SAGA_COLLECTION = "saga_instances";
+/**
+ * A unique index on `sagaId`, so a resumed coordinator can never create a
+ * second instance for one flow, and `{ state, updatedAt }` for the sweep —
+ * without it every pass is a scan of every saga ever run, on a schedule.
+ */
+export declare const ensureSagaIndexes: (db: Db) => Effect.Effect<void, EntifixConnError, never>;
+/** {@link SagaStore} over one Mongo database. */
+export declare const makeMongoSagaStore: (db: Db) => SagaStore;
+/**
+ * Provides {@link SagaStoreTag} from the service's own database, creating the
+ * indexes first.
+ */
+export declare const MongoSagaStoreLayer: Layer.Layer<SagaStoreTag, EntifixConnError, MongoDatabaseTag>;
+//# sourceMappingURL=store.d.ts.map

package/dist/saga/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/saga/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAIL,KAAK,SAAS,EACd,YAAY,EACb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAEvE;;;GAGG;AACH,eAAO,MAAM,eAAe,mBAAmB,CAAC;AAahD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,IAAI,EAAE,iDAUpC,CAAC;AAEL,iDAAiD;AACjD,eAAO,MAAM,kBAAkB,GAAI,IAAI,EAAE,KAAG,SAoI3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,+DAO/B,CAAC"}

package/dist/saga/store.js

@@ -0,0 +1,210 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { EntifixConnError } from '@entifix/core';
+import { SagaStoreTag } from '@entifix/transactions';
+import { Effect, Layer } from 'effect';
+import { MongoDatabaseTag } from '../mongo-database/mongo-database.js';
+/**
+ * Saga instances: one document per flow, the durable record a coordinator
+ * resumes from (r10c ADR 0055).
+ */ export const SAGA_COLLECTION = 'saga_instances';
+/** The two states a sweep treats as unfinished. */ const UNFINISHED = [
+    'RUNNING',
+    'COMPENSATING'
+];
+const failed = (message, sagaId)=>(error)=>new EntifixConnError(message, error, {
+            sagaId
+        });
+const sagaCollection = (db)=>db.collection(SAGA_COLLECTION);
+const deadline = (olderThanMs)=>new Date(Date.now() - olderThanMs).toISOString();
+/**
+ * A unique index on `sagaId`, so a resumed coordinator can never create a
+ * second instance for one flow, and `{ state, updatedAt }` for the sweep —
+ * without it every pass is a scan of every saga ever run, on a schedule.
+ */ export const ensureSagaIndexes = (db)=>Effect.tryPromise({
+        try: async ()=>{
+            await sagaCollection(db).createIndex({
+                sagaId: 1
+            }, {
+                unique: true
+            });
+            await sagaCollection(db).createIndex({
+                state: 1,
+                updatedAt: 1
+            });
+        },
+        catch: (error)=>new EntifixConnError('Failed to ensure saga indexes', error, {
+                database: db.databaseName
+            })
+    });
+/** {@link SagaStore} over one Mongo database. */ export const makeMongoSagaStore = (db)=>{
+    const collection = sagaCollection(db);
+    const stamp = ()=>new Date().toISOString();
+    return {
+        start: (instance)=>Effect.tryPromise({
+                try: async ()=>{
+                    // `$setOnInsert` with an upsert rather than `insertOne`: a coordinator
+                    // restarted mid-flight re-enters with an id it already wrote, and
+                    // refusing that would turn a recoverable resume into a hard failure.
+                    await collection.updateOne({
+                        sagaId: instance.sagaId
+                    }, {
+                        $setOnInsert: _extends({}, instance, {
+                            updatedAt: stamp()
+                        })
+                    }, {
+                        upsert: true
+                    });
+                },
+                catch: failed('Failed to start the saga instance', instance.sagaId)
+            }),
+        beginStep: (sagaId, stepIndex)=>Effect.tryPromise({
+                try: async ()=>{
+                    await collection.updateOne({
+                        sagaId
+                    }, {
+                        $set: {
+                            stepIndex,
+                            updatedAt: stamp()
+                        }
+                    });
+                },
+                catch: failed('Failed to record the step transition', sagaId)
+            }),
+        recordOutcome: (sagaId, outcome)=>Effect.tryPromise({
+                try: async ()=>{
+                    await collection.updateOne({
+                        sagaId
+                    }, // `$push`, never a read-modify-write of the array: two outcomes
+                    // recorded from one process would otherwise lose one another, and a
+                    // lost outcome is a compensation that cannot address what it undoes.
+                    {
+                        $push: {
+                            outcomes: outcome
+                        },
+                        $set: {
+                            updatedAt: stamp()
+                        }
+                    });
+                },
+                catch: failed('Failed to record the step outcome', sagaId)
+            }),
+        settle: (sagaId, state, error)=>Effect.tryPromise({
+                try: async ()=>{
+                    await collection.updateOne({
+                        sagaId
+                    }, {
+                        $set: {
+                            state,
+                            error,
+                            updatedAt: stamp()
+                        }
+                    });
+                },
+                catch: failed('Failed to settle the saga instance', sagaId)
+            }),
+        /**
+     * Take ownership of a stale instance, or answer `undefined`.
+     *
+     * ⚠️ **One conditional write, not a read and then a write.** The filter
+     * repeats `findStale`'s predicate, so two sweepers racing the same instance
+     * produce one winner: the loser's filter no longer matches because the
+     * winner re-stamped `updatedAt`. That stamp is also what stops the next tick
+     * finding the instance this sweep is still working on.
+     */ claimForResume: (sagaId, olderThanMs)=>Effect.tryPromise({
+                try: async ()=>{
+                    const claimed = await collection.findOneAndUpdate({
+                        sagaId,
+                        state: {
+                            $in: [
+                                ...UNFINISHED
+                            ]
+                        },
+                        updatedAt: {
+                            $lt: deadline(olderThanMs)
+                        }
+                    }, {
+                        $inc: {
+                            resumeAttempts: 1
+                        },
+                        $set: {
+                            updatedAt: stamp()
+                        }
+                    }, {
+                        returnDocument: 'after',
+                        projection: {
+                            _id: 0
+                        }
+                    });
+                    return claimed != null ? claimed : undefined;
+                },
+                catch: failed('Failed to claim the saga instance', sagaId)
+            }),
+        /**
+     * Flag one step's calls as given back, addressing the outcome by its step
+     * id: outcomes are `$push`ed, so an index is a fact about arrival order and
+     * a resumed walk must not depend on one.
+     */ markCompensated: (sagaId, stepId)=>Effect.tryPromise({
+                try: async ()=>{
+                    await collection.updateOne({
+                        sagaId
+                    }, {
+                        $set: {
+                            'outcomes.$[entry].compensated': true,
+                            updatedAt: stamp()
+                        }
+                    }, {
+                        arrayFilters: [
+                            {
+                                'entry.stepId': stepId
+                            }
+                        ]
+                    });
+                },
+                catch: failed('Failed to mark the step compensated', sagaId)
+            }),
+        get: (sagaId)=>Effect.tryPromise({
+                try: async ()=>{
+                    var _ref;
+                    return (_ref = await collection.findOne({
+                        sagaId
+                    }, {
+                        projection: {
+                            _id: 0
+                        }
+                    })) != null ? _ref : undefined;
+                },
+                catch: failed('Failed to read the saga instance', sagaId)
+            }),
+        /**
+     * Instances stuck mid-flight past a deadline. ⚠️ `COMPENSATING` counts: a
+     * coordinator that died while unwinding is the state that leaves holds in
+     * place, and the one an operator most needs to find.
+     */ findStale: (olderThanMs)=>Effect.tryPromise({
+                try: async ()=>await collection.find({
+                        state: {
+                            $in: [
+                                ...UNFINISHED
+                            ]
+                        },
+                        updatedAt: {
+                            $lt: deadline(olderThanMs)
+                        }
+                    }, {
+                        projection: {
+                            _id: 0
+                        }
+                    }).toArray(),
+                catch: failed('Failed to find stale saga instances', '')
+            })
+    };
+};
+/**
+ * Provides {@link SagaStoreTag} from the service's own database, creating the
+ * indexes first.
+ */ export const MongoSagaStoreLayer = Layer.effect(SagaStoreTag, Effect.gen(function*() {
+    const db = yield* MongoDatabaseTag;
+    yield* ensureSagaIndexes(db);
+    return makeMongoSagaStore(db);
+}));
+
+//# sourceMappingURL=store.js.map

package/dist/saga/store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/saga/store.ts"],"sourcesContent":["import { EntifixConnError } from '@entifix/core';\nimport {\n  type SagaInstance,\n  type SagaState,\n  type SagaStepOutcome,\n  type SagaStore,\n  SagaStoreTag,\n} from '@entifix/transactions';\nimport { Effect, Layer } from 'effect';\nimport type { Db } from 'mongodb';\n\nimport { MongoDatabaseTag } from '../mongo-database/mongo-database.js';\n\n/**\n * Saga instances: one document per flow, the durable record a coordinator\n * resumes from (r10c ADR 0055).\n */\nexport const SAGA_COLLECTION = 'saga_instances';\n\n/** The two states a sweep treats as unfinished. */\nconst UNFINISHED: readonly SagaState[] = ['RUNNING', 'COMPENSATING'];\n\nconst failed = (message: string, sagaId: string) => (error: unknown) =>\n  new EntifixConnError(message, error, { sagaId });\n\nconst sagaCollection = (db: Db) => db.collection<SagaInstance>(SAGA_COLLECTION);\n\nconst deadline = (olderThanMs: number) =>\n  new Date(Date.now() - olderThanMs).toISOString();\n\n/**\n * A unique index on `sagaId`, so a resumed coordinator can never create a\n * second instance for one flow, and `{ state, updatedAt }` for the sweep —\n * without it every pass is a scan of every saga ever run, on a schedule.\n */\nexport const ensureSagaIndexes = (db: Db) =>\n  Effect.tryPromise({\n    try: async () => {\n      await sagaCollection(db).createIndex({ sagaId: 1 }, { unique: true });\n      await sagaCollection(db).createIndex({ state: 1, updatedAt: 1 });\n    },\n    catch: error =>\n      new EntifixConnError('Failed to ensure saga indexes', error, {\n        database: db.databaseName,\n      }),\n  });\n\n/** {@link SagaStore} over one Mongo database. */\nexport const makeMongoSagaStore = (db: Db): SagaStore => {\n  const collection = sagaCollection(db);\n  const stamp = () => new Date().toISOString();\n\n  return {\n    start: instance =>\n      Effect.tryPromise({\n        try: async () => {\n          // `$setOnInsert` with an upsert rather than `insertOne`: a coordinator\n          // restarted mid-flight re-enters with an id it already wrote, and\n          // refusing that would turn a recoverable resume into a hard failure.\n          await collection.updateOne(\n            { sagaId: instance.sagaId },\n            { $setOnInsert: { ...instance, updatedAt: stamp() } },\n            { upsert: true },\n          );\n        },\n        catch: failed('Failed to start the saga instance', instance.sagaId),\n      }),\n\n    beginStep: (sagaId, stepIndex) =>\n      Effect.tryPromise({\n        try: async () => {\n          await collection.updateOne(\n            { sagaId },\n            { $set: { stepIndex, updatedAt: stamp() } },\n          );\n        },\n        catch: failed('Failed to record the step transition', sagaId),\n      }),\n\n    recordOutcome: (sagaId, outcome: SagaStepOutcome) =>\n      Effect.tryPromise({\n        try: async () => {\n          await collection.updateOne(\n            { sagaId },\n            // `$push`, never a read-modify-write of the array: two outcomes\n            // recorded from one process would otherwise lose one another, and a\n            // lost outcome is a compensation that cannot address what it undoes.\n            { $push: { outcomes: outcome }, $set: { updatedAt: stamp() } },\n          );\n        },\n        catch: failed('Failed to record the step outcome', sagaId),\n      }),\n\n    settle: (sagaId, state, error) =>\n      Effect.tryPromise({\n        try: async () => {\n          await collection.updateOne(\n            { sagaId },\n            { $set: { state, error, updatedAt: stamp() } },\n          );\n        },\n        catch: failed('Failed to settle the saga instance', sagaId),\n      }),\n\n    /**\n     * Take ownership of a stale instance, or answer `undefined`.\n     *\n     * ⚠️ **One conditional write, not a read and then a write.** The filter\n     * repeats `findStale`'s predicate, so two sweepers racing the same instance\n     * produce one winner: the loser's filter no longer matches because the\n     * winner re-stamped `updatedAt`. That stamp is also what stops the next tick\n     * finding the instance this sweep is still working on.\n     */\n    claimForResume: (sagaId, olderThanMs) =>\n      Effect.tryPromise({\n        try: async () => {\n          const claimed = await collection.findOneAndUpdate(\n            {\n              sagaId,\n              state: { $in: [...UNFINISHED] },\n              updatedAt: { $lt: deadline(olderThanMs) },\n            },\n            { $inc: { resumeAttempts: 1 }, $set: { updatedAt: stamp() } },\n            { returnDocument: 'after', projection: { _id: 0 } },\n          );\n          return (claimed ?? undefined) as SagaInstance | undefined;\n        },\n        catch: failed('Failed to claim the saga instance', sagaId),\n      }),\n\n    /**\n     * Flag one step's calls as given back, addressing the outcome by its step\n     * id: outcomes are `$push`ed, so an index is a fact about arrival order and\n     * a resumed walk must not depend on one.\n     */\n    markCompensated: (sagaId, stepId) =>\n      Effect.tryPromise({\n        try: async () => {\n          await collection.updateOne(\n            { sagaId },\n            {\n              $set: {\n                'outcomes.$[entry].compensated': true,\n                updatedAt: stamp(),\n              },\n            },\n            { arrayFilters: [{ 'entry.stepId': stepId }] },\n          );\n        },\n        catch: failed('Failed to mark the step compensated', sagaId),\n      }),\n\n    get: sagaId =>\n      Effect.tryPromise({\n        try: async () =>\n          ((await collection.findOne({ sagaId }, { projection: { _id: 0 } })) ??\n            undefined) as SagaInstance | undefined,\n        catch: failed('Failed to read the saga instance', sagaId),\n      }),\n\n    /**\n     * Instances stuck mid-flight past a deadline. ⚠️ `COMPENSATING` counts: a\n     * coordinator that died while unwinding is the state that leaves holds in\n     * place, and the one an operator most needs to find.\n     */\n    findStale: olderThanMs =>\n      Effect.tryPromise({\n        try: async () =>\n          (await collection\n            .find(\n              {\n                state: { $in: [...UNFINISHED] },\n                updatedAt: { $lt: deadline(olderThanMs) },\n              },\n              { projection: { _id: 0 } },\n            )\n            .toArray()) as SagaInstance[],\n        catch: failed('Failed to find stale saga instances', ''),\n      }),\n  };\n};\n\n/**\n * Provides {@link SagaStoreTag} from the service's own database, creating the\n * indexes first.\n */\nexport const MongoSagaStoreLayer = Layer.effect(\n  SagaStoreTag,\n  Effect.gen(function* () {\n    const db = yield* MongoDatabaseTag;\n    yield* ensureSagaIndexes(db);\n    return makeMongoSagaStore(db);\n  }),\n);\n"],"names":["EntifixConnError","SagaStoreTag","Effect","Layer","MongoDatabaseTag","SAGA_COLLECTION","UNFINISHED","failed","message","sagaId","error","sagaCollection","db","collection","deadline","olderThanMs","Date","now","toISOString","ensureSagaIndexes","tryPromise","try","createIndex","unique","state","updatedAt","catch","database","databaseName","makeMongoSagaStore","stamp","start","instance","updateOne","$setOnInsert","upsert","beginStep","stepIndex","$set","recordOutcome","outcome","$push","outcomes","settle","claimForResume","claimed","findOneAndUpdate","$in","$lt","$inc","resumeAttempts","returnDocument","projection","_id","undefined","markCompensated","stepId","arrayFilters","get","findOne","findStale","find","toArray","MongoSagaStoreLayer","effect","gen"],"mappings":"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"}

package/dist/transactions/index.d.ts

@@ -13,4 +13,5 @@ export * from '../inbox/store.js';
 export * from '../outbox/metrics.js';
 export * from '../outbox/relay.js';
 export * from '../outbox/store.js';
+export * from '../saga/store.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/transactions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transactions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transactions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}

package/dist/transactions/index.js

@@ -12,5 +12,6 @@
 export * from '../outbox/metrics.js';
 export * from '../outbox/relay.js';
 export * from '../outbox/store.js';
+export * from '../saga/store.js';
 
 //# sourceMappingURL=index.js.map

package/dist/transactions/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/transactions/index.ts"],"sourcesContent":["/**\n * The half of this package that needs `@entifix/transactions`: the\n * transactional outbox ADR 0028 writes inside the entity's own Mongo\n * transaction, and the inbox that makes a redelivered command idempotent.\n *\n * Behind a subpath so entity CRUD over Mongo does not arrive with the saga\n * engine attached. Package-level dependencies are not per-subpath, so what\n * actually keeps it optional is the `peerDependenciesMeta.optional` entry in\n * the manifest — importing this module without that peer installed is the\n * error, and it is the adopter's to make deliberately.\n */\nexport * from '../inbox/store.js';\nexport * from '../outbox/metrics.js';\nexport * from '../outbox/relay.js';\nexport * from '../outbox/store.js';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;CAUC,GACD,cAAc,oBAAoB;AAClC,cAAc,uBAAuB;AACrC,cAAc,qBAAqB;AACnC,cAAc,qBAAqB"}
+{"version":3,"sources":["../../src/transactions/index.ts"],"sourcesContent":["/**\n * The half of this package that needs `@entifix/transactions`: the\n * transactional outbox ADR 0028 writes inside the entity's own Mongo\n * transaction, and the inbox that makes a redelivered command idempotent.\n *\n * Behind a subpath so entity CRUD over Mongo does not arrive with the saga\n * engine attached. Package-level dependencies are not per-subpath, so what\n * actually keeps it optional is the `peerDependenciesMeta.optional` entry in\n * the manifest — importing this module without that peer installed is the\n * error, and it is the adopter's to make deliberately.\n */\nexport * from '../inbox/store.js';\nexport * from '../outbox/metrics.js';\nexport * from '../outbox/relay.js';\nexport * from '../outbox/store.js';\nexport * from '../saga/store.js';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;CAUC,GACD,cAAc,oBAAoB;AAClC,cAAc,uBAAuB;AACrC,cAAc,qBAAqB;AACnC,cAAc,qBAAqB;AACnC,cAAc,mBAAmB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entifix/mongo",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "MongoDB adapter: an entity repository, RSQL-to-Mongo query translation, per-tenant databases, and an optional transactional outbox.",
   "license": "MIT",
   "repository": {
@@ -37,10 +37,6 @@
   ],
   "nx": {
     "tags": [
-      "layer:entifix",
-      "scope:shared",
-      "entifix:client",
-      "runtime:datastore",
       "tier:2"
     ],
     "sourceRoot": "packages/ts/mongo-client/src",
@@ -63,17 +59,17 @@
   "dependencies": {
     "@swc/helpers": "0.5.23",
     "mongodb": "7.5.0",
-    "@entifix/core": "0.1.1",
-    "@entifix/business": "0.1.1"
+    "@entifix/business": "0.1.3",
+    "@entifix/core": "0.1.3"
   },
   "devDependencies": {
     "effect": "3.22.1",
-    "@entifix/transactions": "0.1.1",
-    "@entifix/testing-unit": "0.1.1"
+    "@entifix/transactions": "0.1.3",
+    "@entifix/testing-unit": "0.1.3"
   },
   "peerDependencies": {
     "effect": ">=3.22 <4",
-    "@entifix/transactions": "0.1.1"
+    "@entifix/transactions": "0.1.3"
   },
   "peerDependenciesMeta": {
     "@entifix/transactions": {