@entifix/mongo 0.1.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r10c Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/adapters/filter-translator.d.ts

@@ -0,0 +1,19 @@
+import type { Entity, EntityFiltering, EntitySorting } from '@entifix/core';
+/** A Mongo query document (`{ field: condition, $and: [...], ... }`). */
+export type MongoFilter = Record<string, unknown>;
+/** A Mongo sort document (`{ field: 1 | -1 }`). */
+export type MongoSort = Record<string, 1 | -1>;
+/**
+ * Translates the request's `filtering` (an array of {@link EntityFiltering},
+ * each a single filter, an array of filters, or a {@link FilterGroup}) into a
+ * single Mongo query document. Every top-level entry is combined with `$and`;
+ * an empty/absent filtering yields the match-all `{}`.
+ */
+export declare function translateFiltering<TEntity extends Entity>(filtering?: EntityFiltering<TEntity>[]): MongoFilter;
+/**
+ * Translates the request's `sorting` (an array of {@link EntitySorting} records,
+ * each keyed by numeric priority) into a Mongo sort document, preserving the
+ * numeric ordering within each record.
+ */
+export declare function translateSorting<TEntity extends Entity>(sorting?: EntitySorting<TEntity>[]): MongoSort;
+//# sourceMappingURL=filter-translator.d.ts.map

package/dist/adapters/filter-translator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-translator.d.ts","sourceRoot":"","sources":["../../src/adapters/filter-translator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAEN,eAAe,EACf,aAAa,EAEd,MAAM,eAAe,CAAC;AAEvB,yEAAyE;AACzE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAClD,mDAAmD;AACnD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAsE/C;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,SAAS,MAAM,EACvD,SAAS,CAAC,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACrC,WAAW,CAiBb;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,MAAM,EACrD,OAAO,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,GACjC,SAAS,CAgBX"}

package/dist/adapters/filter-translator.js

@@ -0,0 +1,142 @@
+const BINARY_OPERATORS = {
+    eq: '$eq',
+    ne: '$ne',
+    gt: '$gt',
+    gte: '$gte',
+    lt: '$lt',
+    lte: '$lte'
+};
+/** Escapes a string so it is matched literally inside a Mongo `$regex`. */ function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function isFilterGroup(node) {
+    // A group carries `values` + a logic operator and, unlike the array filter,
+    // has no `property`.
+    return !('property' in node) && (node.operator === 'and' || node.operator === 'or');
+}
+function translateNode(node) {
+    if (isFilterGroup(node)) {
+        const clause = node.operator === 'or' ? '$or' : '$and';
+        return {
+            [clause]: node.values.map(translateNode)
+        };
+    }
+    const field = String(node.property);
+    switch(node.operator){
+        case 'eq':
+        case 'ne':
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            return {
+                [field]: {
+                    [BINARY_OPERATORS[node.operator]]: node.value
+                }
+            };
+        case 'in':
+            return {
+                [field]: {
+                    $in: node.values
+                }
+            };
+        case 'nin':
+            return {
+                [field]: {
+                    $nin: node.values
+                }
+            };
+        case 'between':
+            return {
+                [field]: {
+                    $gte: node.start,
+                    $lte: node.end
+                }
+            };
+        case 'nbetween':
+            return {
+                [field]: {
+                    $not: {
+                        $gte: node.start,
+                        $lte: node.end
+                    }
+                }
+            };
+        case 'like':
+            return {
+                [field]: {
+                    $regex: escapeRegex(node.value),
+                    $options: 'i'
+                }
+            };
+        case 'nlike':
+            return {
+                [field]: {
+                    $not: {
+                        $regex: escapeRegex(node.value),
+                        $options: 'i'
+                    }
+                }
+            };
+        case 'isNull':
+            return {
+                [field]: {
+                    $eq: null
+                }
+            };
+        case 'isNotNull':
+            return {
+                [field]: {
+                    $ne: null
+                }
+            };
+        default:
+            {
+                // Exhaustiveness guard — a new operator must be handled explicitly.
+                const _never = node;
+                return _never;
+            }
+    }
+}
+/**
+ * Translates the request's `filtering` (an array of {@link EntityFiltering},
+ * each a single filter, an array of filters, or a {@link FilterGroup}) into a
+ * single Mongo query document. Every top-level entry is combined with `$and`;
+ * an empty/absent filtering yields the match-all `{}`.
+ */ export function translateFiltering(filtering) {
+    if (!filtering || filtering.length === 0) {
+        return {};
+    }
+    const clauses = [];
+    for (const entry of filtering){
+        if (Array.isArray(entry)) {
+            clauses.push(...entry.map(translateNode));
+        } else {
+            clauses.push(translateNode(entry));
+        }
+    }
+    if (clauses.length === 0) return {};
+    if (clauses.length === 1) return clauses[0];
+    return {
+        $and: clauses
+    };
+}
+/**
+ * Translates the request's `sorting` (an array of {@link EntitySorting} records,
+ * each keyed by numeric priority) into a Mongo sort document, preserving the
+ * numeric ordering within each record.
+ */ export function translateSorting(sorting) {
+    const sort = {};
+    if (!sorting) return sort;
+    for (const record of sorting){
+        for (const priority of Object.keys(record).map(Number).sort((a, b)=>a - b)){
+            const entry = record[priority];
+            if (entry) {
+                sort[String(entry.property)] = entry.type === 'desc' ? -1 : 1;
+            }
+        }
+    }
+    return sort;
+}
+
+//# sourceMappingURL=filter-translator.js.map

package/dist/adapters/filter-translator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/filter-translator.ts"],"sourcesContent":["import type {\n  Entity,\n  EntityFilter,\n  EntityFiltering,\n  EntitySorting,\n  FilterGroup,\n} from '@entifix/core';\n\n/** A Mongo query document (`{ field: condition, $and: [...], ... }`). */\nexport type MongoFilter = Record<string, unknown>;\n/** A Mongo sort document (`{ field: 1 | -1 }`). */\nexport type MongoSort = Record<string, 1 | -1>;\n\nconst BINARY_OPERATORS: Record<string, string> = {\n  eq: '$eq',\n  ne: '$ne',\n  gt: '$gt',\n  gte: '$gte',\n  lt: '$lt',\n  lte: '$lte',\n};\n\n/** Escapes a string so it is matched literally inside a Mongo `$regex`. */\nfunction escapeRegex(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\nfunction isFilterGroup<TEntity extends Entity>(\n  node: EntityFilter<TEntity> | FilterGroup<TEntity>,\n): node is FilterGroup<TEntity> {\n  // A group carries `values` + a logic operator and, unlike the array filter,\n  // has no `property`.\n  return (\n    !('property' in node) && (node.operator === 'and' || node.operator === 'or')\n  );\n}\n\nfunction translateNode<TEntity extends Entity>(\n  node: EntityFilter<TEntity> | FilterGroup<TEntity>,\n): MongoFilter {\n  if (isFilterGroup(node)) {\n    const clause = node.operator === 'or' ? '$or' : '$and';\n    return { [clause]: node.values.map(translateNode) };\n  }\n\n  const field = String(node.property);\n\n  switch (node.operator) {\n    case 'eq':\n    case 'ne':\n    case 'gt':\n    case 'gte':\n    case 'lt':\n    case 'lte':\n      return { [field]: { [BINARY_OPERATORS[node.operator]]: node.value } };\n    case 'in':\n      return { [field]: { $in: node.values } };\n    case 'nin':\n      return { [field]: { $nin: node.values } };\n    case 'between':\n      return { [field]: { $gte: node.start, $lte: node.end } };\n    case 'nbetween':\n      return { [field]: { $not: { $gte: node.start, $lte: node.end } } };\n    case 'like':\n      return { [field]: { $regex: escapeRegex(node.value), $options: 'i' } };\n    case 'nlike':\n      return {\n        [field]: { $not: { $regex: escapeRegex(node.value), $options: 'i' } },\n      };\n    case 'isNull':\n      return { [field]: { $eq: null } };\n    case 'isNotNull':\n      return { [field]: { $ne: null } };\n    default: {\n      // Exhaustiveness guard — a new operator must be handled explicitly.\n      const _never: never = node;\n      return _never;\n    }\n  }\n}\n\n/**\n * Translates the request's `filtering` (an array of {@link EntityFiltering},\n * each a single filter, an array of filters, or a {@link FilterGroup}) into a\n * single Mongo query document. Every top-level entry is combined with `$and`;\n * an empty/absent filtering yields the match-all `{}`.\n */\nexport function translateFiltering<TEntity extends Entity>(\n  filtering?: EntityFiltering<TEntity>[],\n): MongoFilter {\n  if (!filtering || filtering.length === 0) {\n    return {};\n  }\n\n  const clauses: MongoFilter[] = [];\n  for (const entry of filtering) {\n    if (Array.isArray(entry)) {\n      clauses.push(...entry.map(translateNode));\n    } else {\n      clauses.push(translateNode(entry));\n    }\n  }\n\n  if (clauses.length === 0) return {};\n  if (clauses.length === 1) return clauses[0];\n  return { $and: clauses };\n}\n\n/**\n * Translates the request's `sorting` (an array of {@link EntitySorting} records,\n * each keyed by numeric priority) into a Mongo sort document, preserving the\n * numeric ordering within each record.\n */\nexport function translateSorting<TEntity extends Entity>(\n  sorting?: EntitySorting<TEntity>[],\n): MongoSort {\n  const sort: MongoSort = {};\n  if (!sorting) return sort;\n\n  for (const record of sorting) {\n    for (const priority of Object.keys(record)\n      .map(Number)\n      .sort((a, b) => a - b)) {\n      const entry = record[priority];\n      if (entry) {\n        sort[String(entry.property)] = entry.type === 'desc' ? -1 : 1;\n      }\n    }\n  }\n\n  return sort;\n}\n"],"names":["BINARY_OPERATORS","eq","ne","gt","gte","lt","lte","escapeRegex","value","replace","isFilterGroup","node","operator","translateNode","clause","values","map","field","String","property","$in","$nin","$gte","start","$lte","end","$not","$regex","$options","$eq","$ne","_never","translateFiltering","filtering","length","clauses","entry","Array","isArray","push","$and","translateSorting","sorting","sort","record","priority","Object","keys","Number","a","b","type"],"mappings":"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"}

package/dist/adapters/make-mongo-link-resolver.d.ts

@@ -0,0 +1,14 @@
+import { EntityLinkResolverTag } from '@entifix/business';
+import { Entity, EntityConstructor } from '@entifix/core';
+import { Context } from 'effect';
+import type { Db } from 'mongodb';
+/**
+ * Builds an {@link EntityLinkResolverTag} context backed by Mongo repositories,
+ * so a load use-case can materialize not-yet-loaded {@link EntityLink}s on the
+ * backend. Mirrors the REST `createEntityLinkResolver`, but each Mongo `get`
+ * already has no outstanding requirements, so nothing needs to be provided.
+ *
+ * `registrations` lists the link-target constructors this resolver can fetch.
+ */
+export declare function makeMongoLinkResolver(db: Db, registrations: ReadonlyArray<EntityConstructor<Entity>>): Context.Context<EntityLinkResolverTag>;
+//# sourceMappingURL=make-mongo-link-resolver.d.ts.map

package/dist/adapters/make-mongo-link-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-mongo-link-resolver.d.ts","sourceRoot":"","sources":["../../src/adapters/make-mongo-link-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAGL,MAAM,EACN,iBAAiB,EAElB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,OAAO,EAAU,MAAM,QAAQ,CAAC;AACzC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAIlC;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,EAAE,EACN,aAAa,EAAE,aAAa,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,GACtD,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAiCxC"}

package/dist/adapters/make-mongo-link-resolver.js

@@ -0,0 +1,31 @@
+import { EntityLinkResolverTag } from '@entifix/business';
+import { EntifixLogicError } from '@entifix/core';
+import { Context, Effect } from 'effect';
+import { makeMongoRepository } from './make-mongo-repository.js';
+/**
+ * Builds an {@link EntityLinkResolverTag} context backed by Mongo repositories,
+ * so a load use-case can materialize not-yet-loaded {@link EntityLink}s on the
+ * backend. Mirrors the REST `createEntityLinkResolver`, but each Mongo `get`
+ * already has no outstanding requirements, so nothing needs to be provided.
+ *
+ * `registrations` lists the link-target constructors this resolver can fetch.
+ */ export function makeMongoLinkResolver(db, registrations) {
+    const repositoryByConstructor = new Map(registrations.map((entityConstructor)=>[
+            entityConstructor,
+            makeMongoRepository(db, entityConstructor)
+        ]));
+    const resolver = {
+        resolve (entityConstructor, id) {
+            const repository = repositoryByConstructor.get(entityConstructor);
+            if (!repository) {
+                return Effect.fail(new EntifixLogicError(`No Mongo link resolver registered for entity "${entityConstructor.name}"`, undefined, {
+                    entity: entityConstructor.name
+                }));
+            }
+            return repository.get(id);
+        }
+    };
+    return Context.make(EntityLinkResolverTag, resolver);
+}
+
+//# sourceMappingURL=make-mongo-link-resolver.js.map

package/dist/adapters/make-mongo-link-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/make-mongo-link-resolver.ts"],"sourcesContent":["import { EntityLinkResolverTag } from '@entifix/business';\nimport {\n  EntifixError,\n  EntifixLogicError,\n  Entity,\n  EntityConstructor,\n  EntityLinkResolver,\n} from '@entifix/core';\nimport { Context, Effect } from 'effect';\nimport type { Db } from 'mongodb';\n\nimport { makeMongoRepository } from './make-mongo-repository.js';\n\n/**\n * Builds an {@link EntityLinkResolverTag} context backed by Mongo repositories,\n * so a load use-case can materialize not-yet-loaded {@link EntityLink}s on the\n * backend. Mirrors the REST `createEntityLinkResolver`, but each Mongo `get`\n * already has no outstanding requirements, so nothing needs to be provided.\n *\n * `registrations` lists the link-target constructors this resolver can fetch.\n */\nexport function makeMongoLinkResolver(\n  db: Db,\n  registrations: ReadonlyArray<EntityConstructor<Entity>>,\n): Context.Context<EntityLinkResolverTag> {\n  const repositoryByConstructor = new Map(\n    registrations.map(\n      entityConstructor =>\n        [\n          entityConstructor,\n          makeMongoRepository(db, entityConstructor),\n        ] as const,\n    ),\n  );\n\n  const resolver: EntityLinkResolver = {\n    resolve(entityConstructor, id) {\n      const repository = repositoryByConstructor.get(\n        entityConstructor as EntityConstructor<Entity>,\n      );\n      if (!repository) {\n        return Effect.fail(\n          new EntifixLogicError(\n            `No Mongo link resolver registered for entity \"${entityConstructor.name}\"`,\n            undefined,\n            { entity: entityConstructor.name },\n          ),\n        );\n      }\n      return repository.get(id) as unknown as Effect.Effect<\n        never,\n        EntifixError\n      >;\n    },\n  };\n\n  return Context.make(EntityLinkResolverTag, resolver);\n}\n"],"names":["EntityLinkResolverTag","EntifixLogicError","Context","Effect","makeMongoRepository","makeMongoLinkResolver","db","registrations","repositoryByConstructor","Map","map","entityConstructor","resolver","resolve","id","repository","get","fail","name","undefined","entity","make"],"mappings":"AAAA,SAASA,qBAAqB,QAAQ,oBAAoB;AAC1D,SAEEC,iBAAiB,QAIZ,gBAAgB;AACvB,SAASC,OAAO,EAAEC,MAAM,QAAQ,SAAS;AAGzC,SAASC,mBAAmB,QAAQ,6BAA6B;AAEjE;;;;;;;CAOC,GACD,OAAO,SAASC,sBACdC,EAAM,EACNC,aAAuD;IAEvD,MAAMC,0BAA0B,IAAIC,IAClCF,cAAcG,GAAG,CACfC,CAAAA,oBACE;YACEA;YACAP,oBAAoBE,IAAIK;SACzB;IAIP,MAAMC,WAA+B;QACnCC,SAAQF,iBAAiB,EAAEG,EAAE;YAC3B,MAAMC,aAAaP,wBAAwBQ,GAAG,CAC5CL;YAEF,IAAI,CAACI,YAAY;gBACf,OAAOZ,OAAOc,IAAI,CAChB,IAAIhB,kBACF,CAAC,8CAA8C,EAAEU,kBAAkBO,IAAI,CAAC,CAAC,CAAC,EAC1EC,WACA;oBAAEC,QAAQT,kBAAkBO,IAAI;gBAAC;YAGvC;YACA,OAAOH,WAAWC,GAAG,CAACF;QAIxB;IACF;IAEA,OAAOZ,QAAQmB,IAAI,CAACrB,uBAAuBY;AAC7C"}

package/dist/adapters/make-mongo-repository.d.ts

@@ -0,0 +1,19 @@
+import type { EntityRepository } from '@entifix/business';
+import { EntifixError, Entity, EntityConstructor } from '@entifix/core';
+import type { Db } from 'mongodb';
+/**
+ * Builds an {@link EntityRepository} for a single entity type, backed by a live
+ * mongodb {@link Db}. The `db` and `entityConstructor` are captured in closures,
+ * so every method's Effect has no outstanding requirements (`R = never`) and is
+ * assignable to the interface's `ConfigurationRepositoryTag` channel.
+ *
+ * Collection name = the entity's `key` (falling back to its class name). Reads
+ * reuse the shared entifix deserializer (rebuilding links from embedded objects
+ * or scalar FKs); writes reuse the shared serializer. Mongo failures surface as
+ * {@link EntifixConnError}.
+ *
+ * This is the Mongo mirror of the REST `buildEntityRestAdapter*` builders.
+ */
+export declare function makeMongoRepository<TEntity extends Entity>(db: Db, entityConstructor: EntityConstructor<TEntity>): EntityRepository;
+export type { EntifixError };
+//# sourceMappingURL=make-mongo-repository.d.ts.map

package/dist/adapters/make-mongo-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-mongo-repository.d.ts","sourceRoot":"","sources":["../../src/adapters/make-mongo-repository.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAIL,YAAY,EACZ,MAAM,EACN,iBAAiB,EAMlB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAoBlC;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,SAAS,MAAM,EACxD,EAAE,EAAE,EAAE,EACN,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,GAC5C,gBAAgB,CAoGlB;AAED,YAAY,EAAE,YAAY,EAAE,CAAC"}

package/dist/adapters/make-mongo-repository.js

@@ -0,0 +1,122 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { randomUUID } from 'node:crypto';
+import { deserializeEntityCollection, deserializeSingleEntity, EntifixConnError, extractMetaEntity, serializeEntity } from '@entifix/core';
+import { Effect } from 'effect';
+import { translateFiltering, translateSorting } from './filter-translator.js';
+/** Projection that drops Mongo's internal `_id` from read results. */ const WITHOUT_MONGO_ID = {
+    projection: {
+        _id: 0
+    }
+};
+function collectionName(entityConstructor) {
+    var _metaEntity_key;
+    const metaEntity = extractMetaEntity(entityConstructor);
+    return (_metaEntity_key = metaEntity.key) != null ? _metaEntity_key : metaEntity.name;
+}
+function toEntityId(entityOrId) {
+    return entityOrId != null && typeof entityOrId === 'object' ? entityOrId.id : entityOrId;
+}
+/**
+ * Builds an {@link EntityRepository} for a single entity type, backed by a live
+ * mongodb {@link Db}. The `db` and `entityConstructor` are captured in closures,
+ * so every method's Effect has no outstanding requirements (`R = never`) and is
+ * assignable to the interface's `ConfigurationRepositoryTag` channel.
+ *
+ * Collection name = the entity's `key` (falling back to its class name). Reads
+ * reuse the shared entifix deserializer (rebuilding links from embedded objects
+ * or scalar FKs); writes reuse the shared serializer. Mongo failures surface as
+ * {@link EntifixConnError}.
+ *
+ * This is the Mongo mirror of the REST `buildEntityRestAdapter*` builders.
+ */ export function makeMongoRepository(db, entityConstructor) {
+    const collection = db.collection(collectionName(entityConstructor));
+    const fail = (message, error, details)=>new EntifixConnError(message, error, _extends({
+            entity: entityConstructor.name
+        }, details));
+    const load = (request)=>Effect.gen(function*() {
+            var _request_page, _request_pageSize;
+            const filter = translateFiltering(request.filtering);
+            const sort = translateSorting(request.sorting);
+            const page = (_request_page = request.page) != null ? _request_page : 1;
+            const pageSize = (_request_pageSize = request.pageSize) != null ? _request_pageSize : 10;
+            const skip = (page - 1) * pageSize;
+            const docs = yield* Effect.tryPromise({
+                try: ()=>collection.find(filter, WITHOUT_MONGO_ID).sort(sort).skip(skip).limit(pageSize).toArray(),
+                catch: (error)=>fail('Failed to load entities from MongoDB', error)
+            });
+            const total = yield* Effect.tryPromise({
+                try: ()=>collection.countDocuments(filter),
+                catch: (error)=>fail('Failed to count entities in MongoDB', error)
+            });
+            const items = yield* deserializeEntityCollection(entityConstructor, docs);
+            return {
+                items: items,
+                total,
+                request
+            };
+        });
+    const get = (id)=>Effect.gen(function*() {
+            const doc = yield* Effect.tryPromise({
+                try: ()=>collection.findOne({
+                        id
+                    }, WITHOUT_MONGO_ID),
+                catch: (error)=>fail('Failed to read entity from MongoDB', error, {
+                        id
+                    })
+            });
+            const entity = yield* deserializeSingleEntity(entityConstructor, doc);
+            if (entity === undefined) {
+                return yield* Effect.fail(fail(`Entity not found`, undefined, {
+                    id
+                }));
+            }
+            return entity;
+        });
+    const save = (entity)=>Effect.gen(function*() {
+            var _entity_id;
+            const doc = serializeEntity(entityConstructor, entity);
+            // A create arrives without an id, so the store mints one. Entities are
+            // addressed by their own `id` field (never Mongo's `_id`, which reads
+            // project away), so an inserted document without one would be
+            // unreachable by `get` and by any later `replaceOne`.
+            const id = (_entity_id = entity.id) != null ? _entity_id : randomUUID();
+            yield* Effect.tryPromise({
+                // `doc` omits `id` when it was undefined (the serializer drops
+                // undefined), hence spreading the resolved id back in.
+                try: ()=>collection.replaceOne({
+                        id
+                    }, _extends({}, doc, {
+                        id
+                    }), {
+                        upsert: true
+                    }),
+                catch: (error)=>fail('Failed to save entity to MongoDB', error, {
+                        id
+                    })
+            });
+            entity.id = id;
+            return entity;
+        });
+    const del = (entityOrId)=>Effect.gen(function*() {
+            const id = toEntityId(entityOrId);
+            yield* Effect.tryPromise({
+                try: ()=>collection.deleteOne({
+                        id
+                    }),
+                catch: (error)=>fail('Failed to delete entity from MongoDB', error, {
+                        id
+                    })
+            });
+        });
+    // The interface types each method's requirement channel as
+    // `ConfigurationRepositoryTag`; these effects require nothing (`never`), which
+    // is assignable. Cast through the interface to keep the generic signatures.
+    return {
+        load,
+        get,
+        save,
+        delete: del
+    };
+}
+
+//# sourceMappingURL=make-mongo-repository.js.map

package/dist/adapters/make-mongo-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/make-mongo-repository.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\n\nimport type { EntityRepository } from '@entifix/business';\nimport {\n  deserializeEntityCollection,\n  deserializeSingleEntity,\n  EntifixConnError,\n  EntifixError,\n  Entity,\n  EntityConstructor,\n  EntityId,\n  EntityLoadRequest,\n  EntityPage,\n  extractMetaEntity,\n  serializeEntity,\n} from '@entifix/core';\nimport { Effect } from 'effect';\nimport type { Db } from 'mongodb';\n\nimport { translateFiltering, translateSorting } from './filter-translator.js';\n\n/** Projection that drops Mongo's internal `_id` from read results. */\nconst WITHOUT_MONGO_ID = { projection: { _id: 0 } } as const;\n\nfunction collectionName<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n): string {\n  const metaEntity = extractMetaEntity(entityConstructor);\n  return metaEntity.key ?? metaEntity.name;\n}\n\nfunction toEntityId(entityOrId: EntityId | Entity): EntityId {\n  return entityOrId != null && typeof entityOrId === 'object'\n    ? (entityOrId as Entity).id\n    : (entityOrId as EntityId);\n}\n\n/**\n * Builds an {@link EntityRepository} for a single entity type, backed by a live\n * mongodb {@link Db}. The `db` and `entityConstructor` are captured in closures,\n * so every method's Effect has no outstanding requirements (`R = never`) and is\n * assignable to the interface's `ConfigurationRepositoryTag` channel.\n *\n * Collection name = the entity's `key` (falling back to its class name). Reads\n * reuse the shared entifix deserializer (rebuilding links from embedded objects\n * or scalar FKs); writes reuse the shared serializer. Mongo failures surface as\n * {@link EntifixConnError}.\n *\n * This is the Mongo mirror of the REST `buildEntityRestAdapter*` builders.\n */\nexport function makeMongoRepository<TEntity extends Entity>(\n  db: Db,\n  entityConstructor: EntityConstructor<TEntity>,\n): EntityRepository {\n  const collection = db.collection(collectionName(entityConstructor));\n\n  const fail = (\n    message: string,\n    error: unknown,\n    details?: Record<string, unknown>,\n  ) =>\n    new EntifixConnError(message, error, {\n      entity: entityConstructor.name,\n      ...details,\n    });\n\n  const load = <T extends Entity>(request: EntityLoadRequest<T>) =>\n    Effect.gen(function* () {\n      const filter = translateFiltering(request.filtering);\n      const sort = translateSorting(request.sorting);\n      const page = request.page ?? 1;\n      const pageSize = request.pageSize ?? 10;\n      const skip = (page - 1) * pageSize;\n\n      const docs = yield* Effect.tryPromise({\n        try: () =>\n          collection\n            .find(filter, WITHOUT_MONGO_ID)\n            .sort(sort)\n            .skip(skip)\n            .limit(pageSize)\n            .toArray(),\n        catch: error => fail('Failed to load entities from MongoDB', error),\n      });\n      const total = yield* Effect.tryPromise({\n        try: () => collection.countDocuments(filter),\n        catch: error => fail('Failed to count entities in MongoDB', error),\n      });\n\n      const items = yield* deserializeEntityCollection(entityConstructor, docs);\n\n      return {\n        items: items as unknown as T[],\n        total,\n        request,\n      } satisfies EntityPage<T>;\n    });\n\n  const get = <T extends Entity>(id: EntityId) =>\n    Effect.gen(function* () {\n      const doc = yield* Effect.tryPromise({\n        try: () => collection.findOne({ id }, WITHOUT_MONGO_ID),\n        catch: error =>\n          fail('Failed to read entity from MongoDB', error, { id }),\n      });\n      const entity = yield* deserializeSingleEntity(entityConstructor, doc);\n      if (entity === undefined) {\n        return yield* Effect.fail(fail(`Entity not found`, undefined, { id }));\n      }\n      return entity as unknown as T;\n    });\n\n  const save = <T extends Entity>(entity: T) =>\n    Effect.gen(function* () {\n      const doc = serializeEntity(\n        entityConstructor,\n        entity as unknown as TEntity,\n      );\n      // A create arrives without an id, so the store mints one. Entities are\n      // addressed by their own `id` field (never Mongo's `_id`, which reads\n      // project away), so an inserted document without one would be\n      // unreachable by `get` and by any later `replaceOne`.\n      const id = entity.id ?? randomUUID();\n      yield* Effect.tryPromise({\n        // `doc` omits `id` when it was undefined (the serializer drops\n        // undefined), hence spreading the resolved id back in.\n        try: () =>\n          collection.replaceOne({ id }, { ...doc, id }, { upsert: true }),\n        catch: error => fail('Failed to save entity to MongoDB', error, { id }),\n      });\n      entity.id = id;\n      return entity;\n    });\n\n  const del = <T extends Entity>(entityOrId: EntityId | T) =>\n    Effect.gen(function* () {\n      const id = toEntityId(entityOrId);\n      yield* Effect.tryPromise({\n        try: () => collection.deleteOne({ id }),\n        catch: error =>\n          fail('Failed to delete entity from MongoDB', error, { id }),\n      });\n    });\n\n  // The interface types each method's requirement channel as\n  // `ConfigurationRepositoryTag`; these effects require nothing (`never`), which\n  // is assignable. Cast through the interface to keep the generic signatures.\n  return {\n    load,\n    get,\n    save,\n    delete: del,\n  } as unknown as EntityRepository;\n}\n\nexport type { EntifixError };\n"],"names":["randomUUID","deserializeEntityCollection","deserializeSingleEntity","EntifixConnError","extractMetaEntity","serializeEntity","Effect","translateFiltering","translateSorting","WITHOUT_MONGO_ID","projection","_id","collectionName","entityConstructor","metaEntity","key","name","toEntityId","entityOrId","id","makeMongoRepository","db","collection","fail","message","error","details","entity","load","request","gen","filter","filtering","sort","sorting","page","pageSize","skip","docs","tryPromise","try","find","limit","toArray","catch","total","countDocuments","items","get","doc","findOne","undefined","save","replaceOne","upsert","del","deleteOne","delete"],"mappings":"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"}

package/dist/inbox/store.d.ts

@@ -0,0 +1,50 @@
+import { EntifixConnError } from '@entifix/core';
+import type { InboxClaim, TransactionInbox } from '@entifix/transactions';
+import { Effect } from 'effect';
+import type { Db } from 'mongodb';
+/**
+ * The inbox collection, and it lives in **whichever database the side effect it
+ * guards writes to** — not in one central place.
+ *
+ * That is the whole mechanism, not a deployment preference: a claim is only
+ * worth anything if it commits in the same storage transaction as the effect,
+ * and two databases cannot be one transaction. So the saga tracker's inbox is in
+ * the `saga` database because its fold writes there, exactly as the outbox is
+ * per-tenant because the entity is.
+ */
+export declare const INBOX_COLLECTION = "transaction_inbox";
+export declare const isDuplicateKey: (error: unknown) => boolean;
+/**
+ * The stored shape of a claim.
+ *
+ * Exported for the same reason `outboxDocument` is: the claim that matters is
+ * **not** written through the port. It has to join the side effect's session to
+ * be atomic with it, and a session cannot live in a framework-free contract, so
+ * the consumer inserts this document itself. {@link makeMongoInbox} is for a
+ * consumer that can claim standalone.
+ */
+export declare const inboxDocument: (consumer: string, eventId: string) => InboxClaim;
+/**
+ * The unique index the claim rides, on **`(consumer, eventId)`**.
+ *
+ * Compound, and that is the half easy to get wrong. Two consumers legitimately
+ * process the same event — the tracker's fold and the SSE hub both bind
+ * `transaction.*` — so a unique index on `eventId` alone would let whichever
+ * claimed first starve every other consumer of every message, while the broker,
+ * the queue and the handler all went on reporting success.
+ *
+ * Called per handle rather than once at boot, matching `ensureOutboxIndexes`:
+ * the index must exist before the first claim, not eventually, or two
+ * concurrent first deliveries both insert.
+ */
+export declare const ensureInboxIndexes: (db: Db) => Effect.Effect<void, EntifixConnError, never>;
+/**
+ * A {@link TransactionInbox} over one database, for one consumer.
+ *
+ * `consumer` is the subscription's durable work-queue name
+ * (`<slice>.<pattern>`) — deterministic, and stable across restarts, which an
+ * anonymous broadcast queue's server-generated name is not. That is also why
+ * `dedupe: 'inbox'` is only legal on a `work` subscription.
+ */
+export declare const makeMongoInbox: (db: Db, consumer: string) => TransactionInbox;
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/inbox/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC1E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,sBAAsB,CAAC;AAKpD,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,OAGM,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACxB,UAAU,MAAM,EAChB,SAAS,MAAM,KACd,UAID,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,EAAE,iDAWrC,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,IAAI,EAAE,EAAE,UAAU,MAAM,KAAG,gBA2BzD,CAAC"}

package/dist/inbox/store.js

@@ -0,0 +1,86 @@
+import { EntifixConnError } from '@entifix/core';
+import { Effect } from 'effect';
+/**
+ * The inbox collection, and it lives in **whichever database the side effect it
+ * guards writes to** — not in one central place.
+ *
+ * That is the whole mechanism, not a deployment preference: a claim is only
+ * worth anything if it commits in the same storage transaction as the effect,
+ * and two databases cannot be one transaction. So the saga tracker's inbox is in
+ * the `saga` database because its fold writes there, exactly as the outbox is
+ * per-tenant because the entity is.
+ */ export const INBOX_COLLECTION = 'transaction_inbox';
+/** Mongo's duplicate-key error, which is how a redelivery is recognised. */ const DUPLICATE_KEY = 11000;
+export const isDuplicateKey = (error)=>typeof error === 'object' && error !== null && error.code === DUPLICATE_KEY;
+/**
+ * The stored shape of a claim.
+ *
+ * Exported for the same reason `outboxDocument` is: the claim that matters is
+ * **not** written through the port. It has to join the side effect's session to
+ * be atomic with it, and a session cannot live in a framework-free contract, so
+ * the consumer inserts this document itself. {@link makeMongoInbox} is for a
+ * consumer that can claim standalone.
+ */ export const inboxDocument = (consumer, eventId)=>({
+        consumer,
+        eventId,
+        claimedAt: new Date().toISOString()
+    });
+/**
+ * The unique index the claim rides, on **`(consumer, eventId)`**.
+ *
+ * Compound, and that is the half easy to get wrong. Two consumers legitimately
+ * process the same event — the tracker's fold and the SSE hub both bind
+ * `transaction.*` — so a unique index on `eventId` alone would let whichever
+ * claimed first starve every other consumer of every message, while the broker,
+ * the queue and the handler all went on reporting success.
+ *
+ * Called per handle rather than once at boot, matching `ensureOutboxIndexes`:
+ * the index must exist before the first claim, not eventually, or two
+ * concurrent first deliveries both insert.
+ */ export const ensureInboxIndexes = (db)=>Effect.tryPromise({
+        try: async ()=>{
+            await db.collection(INBOX_COLLECTION).createIndex({
+                consumer: 1,
+                eventId: 1
+            }, {
+                unique: true
+            });
+        },
+        catch: (error)=>new EntifixConnError('Failed to ensure inbox indexes', error, {
+                database: db.databaseName
+            })
+    });
+/**
+ * A {@link TransactionInbox} over one database, for one consumer.
+ *
+ * `consumer` is the subscription's durable work-queue name
+ * (`<slice>.<pattern>`) — deterministic, and stable across restarts, which an
+ * anonymous broadcast queue's server-generated name is not. That is also why
+ * `dedupe: 'inbox'` is only legal on a `work` subscription.
+ */ export const makeMongoInbox = (db, consumer)=>{
+    const collection = db.collection(INBOX_COLLECTION);
+    return {
+        claim: (eventId)=>Effect.tryPromise({
+                try: async ()=>{
+                    try {
+                        await collection.insertOne(inboxDocument(consumer, eventId));
+                        return 'claimed';
+                    } catch (error) {
+                        // Not a failure: the unique index rejected a second claim for this
+                        // consumer and message, which is precisely how a redelivery is
+                        // identified.
+                        if (isDuplicateKey(error)) {
+                            return 'duplicate';
+                        }
+                        throw error;
+                    }
+                },
+                catch: (error)=>new EntifixConnError('Failed to claim inbox entry', error, {
+                        consumer,
+                        eventId
+                    })
+            })
+    };
+};
+
+//# sourceMappingURL=store.js.map

package/dist/inbox/store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/inbox/store.ts"],"sourcesContent":["import { EntifixConnError } from '@entifix/core';\nimport type { InboxClaim, TransactionInbox } from '@entifix/transactions';\nimport { Effect } from 'effect';\nimport type { Db } from 'mongodb';\n\n/**\n * The inbox collection, and it lives in **whichever database the side effect it\n * guards writes to** — not in one central place.\n *\n * That is the whole mechanism, not a deployment preference: a claim is only\n * worth anything if it commits in the same storage transaction as the effect,\n * and two databases cannot be one transaction. So the saga tracker's inbox is in\n * the `saga` database because its fold writes there, exactly as the outbox is\n * per-tenant because the entity is.\n */\nexport const INBOX_COLLECTION = 'transaction_inbox';\n\n/** Mongo's duplicate-key error, which is how a redelivery is recognised. */\nconst DUPLICATE_KEY = 11000;\n\nexport const isDuplicateKey = (error: unknown): boolean =>\n  typeof error === 'object' &&\n  error !== null &&\n  (error as { code?: unknown }).code === DUPLICATE_KEY;\n\n/**\n * The stored shape of a claim.\n *\n * Exported for the same reason `outboxDocument` is: the claim that matters is\n * **not** written through the port. It has to join the side effect's session to\n * be atomic with it, and a session cannot live in a framework-free contract, so\n * the consumer inserts this document itself. {@link makeMongoInbox} is for a\n * consumer that can claim standalone.\n */\nexport const inboxDocument = (\n  consumer: string,\n  eventId: string,\n): InboxClaim => ({\n  consumer,\n  eventId,\n  claimedAt: new Date().toISOString(),\n});\n\n/**\n * The unique index the claim rides, on **`(consumer, eventId)`**.\n *\n * Compound, and that is the half easy to get wrong. Two consumers legitimately\n * process the same event — the tracker's fold and the SSE hub both bind\n * `transaction.*` — so a unique index on `eventId` alone would let whichever\n * claimed first starve every other consumer of every message, while the broker,\n * the queue and the handler all went on reporting success.\n *\n * Called per handle rather than once at boot, matching `ensureOutboxIndexes`:\n * the index must exist before the first claim, not eventually, or two\n * concurrent first deliveries both insert.\n */\nexport const ensureInboxIndexes = (db: Db) =>\n  Effect.tryPromise({\n    try: async () => {\n      await db\n        .collection<InboxClaim>(INBOX_COLLECTION)\n        .createIndex({ consumer: 1, eventId: 1 }, { unique: true });\n    },\n    catch: error =>\n      new EntifixConnError('Failed to ensure inbox indexes', error, {\n        database: db.databaseName,\n      }),\n  });\n\n/**\n * A {@link TransactionInbox} over one database, for one consumer.\n *\n * `consumer` is the subscription's durable work-queue name\n * (`<slice>.<pattern>`) — deterministic, and stable across restarts, which an\n * anonymous broadcast queue's server-generated name is not. That is also why\n * `dedupe: 'inbox'` is only legal on a `work` subscription.\n */\nexport const makeMongoInbox = (db: Db, consumer: string): TransactionInbox => {\n  const collection = db.collection<InboxClaim>(INBOX_COLLECTION);\n\n  return {\n    claim: eventId =>\n      Effect.tryPromise({\n        try: async () => {\n          try {\n            await collection.insertOne(inboxDocument(consumer, eventId));\n            return 'claimed' as const;\n          } catch (error) {\n            // Not a failure: the unique index rejected a second claim for this\n            // consumer and message, which is precisely how a redelivery is\n            // identified.\n            if (isDuplicateKey(error)) {\n              return 'duplicate' as const;\n            }\n            throw error;\n          }\n        },\n        catch: error =>\n          new EntifixConnError('Failed to claim inbox entry', error, {\n            consumer,\n            eventId,\n          }),\n      }),\n  };\n};\n"],"names":["EntifixConnError","Effect","INBOX_COLLECTION","DUPLICATE_KEY","isDuplicateKey","error","code","inboxDocument","consumer","eventId","claimedAt","Date","toISOString","ensureInboxIndexes","db","tryPromise","try","collection","createIndex","unique","catch","database","databaseName","makeMongoInbox","claim","insertOne"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,gBAAgB;AAEjD,SAASC,MAAM,QAAQ,SAAS;AAGhC;;;;;;;;;CASC,GACD,OAAO,MAAMC,mBAAmB,oBAAoB;AAEpD,0EAA0E,GAC1E,MAAMC,gBAAgB;AAEtB,OAAO,MAAMC,iBAAiB,CAACC,QAC7B,OAAOA,UAAU,YACjBA,UAAU,QACV,AAACA,MAA6BC,IAAI,KAAKH,cAAc;AAEvD;;;;;;;;CAQC,GACD,OAAO,MAAMI,gBAAgB,CAC3BC,UACAC,UACgB,CAAA;QAChBD;QACAC;QACAC,WAAW,IAAIC,OAAOC,WAAW;IACnC,CAAA,EAAG;AAEH;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,qBAAqB,CAACC,KACjCb,OAAOc,UAAU,CAAC;QAChBC,KAAK;YACH,MAAMF,GACHG,UAAU,CAAaf,kBACvBgB,WAAW,CAAC;gBAAEV,UAAU;gBAAGC,SAAS;YAAE,GAAG;gBAAEU,QAAQ;YAAK;QAC7D;QACAC,OAAOf,CAAAA,QACL,IAAIL,iBAAiB,kCAAkCK,OAAO;gBAC5DgB,UAAUP,GAAGQ,YAAY;YAC3B;IACJ,GAAG;AAEL;;;;;;;CAOC,GACD,OAAO,MAAMC,iBAAiB,CAACT,IAAQN;IACrC,MAAMS,aAAaH,GAAGG,UAAU,CAAaf;IAE7C,OAAO;QACLsB,OAAOf,CAAAA,UACLR,OAAOc,UAAU,CAAC;gBAChBC,KAAK;oBACH,IAAI;wBACF,MAAMC,WAAWQ,SAAS,CAAClB,cAAcC,UAAUC;wBACnD,OAAO;oBACT,EAAE,OAAOJ,OAAO;wBACd,mEAAmE;wBACnE,+DAA+D;wBAC/D,cAAc;wBACd,IAAID,eAAeC,QAAQ;4BACzB,OAAO;wBACT;wBACA,MAAMA;oBACR;gBACF;gBACAe,OAAOf,CAAAA,QACL,IAAIL,iBAAiB,+BAA+BK,OAAO;wBACzDG;wBACAC;oBACF;YACJ;IACJ;AACF,EAAE"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './adapters/filter-translator.js';
+export * from './adapters/make-mongo-link-resolver.js';
+export * from './adapters/make-mongo-repository.js';
+export * from './mongo-database/mongo-database.js';
+export * from './mongo-database/mongo-health-probe.js';
+export * from './mongo-database/mongo-tenant-resolver.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,wCAAwC,CAAC;AACvD,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './adapters/filter-translator.js';
+export * from './adapters/make-mongo-link-resolver.js';
+export * from './adapters/make-mongo-repository.js';
+export * from './mongo-database/mongo-database.js';
+export * from './mongo-database/mongo-health-probe.js';
+export * from './mongo-database/mongo-tenant-resolver.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './adapters/filter-translator.js';\nexport * from './adapters/make-mongo-link-resolver.js';\nexport * from './adapters/make-mongo-repository.js';\nexport * from './mongo-database/mongo-database.js';\nexport * from './mongo-database/mongo-health-probe.js';\nexport * from './mongo-database/mongo-tenant-resolver.js';\n"],"names":[],"mappings":"AAAA,cAAc,kCAAkC;AAChD,cAAc,yCAAyC;AACvD,cAAc,sCAAsC;AACpD,cAAc,qCAAqC;AACnD,cAAc,yCAAyC;AACvD,cAAc,4CAA4C"}