@ambiten/core 1.0.0

package/dist/tanancy/MultiTenantManager.d.ts

@@ -0,0 +1,98 @@
+import { MongoClient } from 'mongodb';
+export interface TenantConfig {
+    tenantId: string;
+    uri: string;
+    dbName: string;
+    client?: MongoClient;
+    lazy: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface RegisterTenantOptions {
+    dbName?: string;
+    client?: MongoClient;
+    lazy?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * MultiTenantManager is responsible for managing tenant configurations and MongoDB client connections in a multi-tenant application.
+ * It supports both lazy and immediate tenant registration, allowing for flexible connection management based on application needs.
+ */
+export declare class MultiTenantManager {
+    private static tenants;
+    constructor();
+    /**
+     * Checks if a tenant is already registered.
+     * @param {string} tenantId - The ID of the tenant to check.
+     * @returns {boolean} `true` if the tenant is registered, `false` otherwise.
+     */
+    static hasTenant(tenantId: string): boolean;
+    /**
+     * Registers a tenant for lazy connection.
+     * Connection is established only when the tenant is accessed for the first time.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @param {string} uri - The MongoDB URI.
+     * @param {RegisterTenantOptions} [options] - Optional tenant registration settings.
+     */
+    static registerLazyTenant(tenantId: string, uri: string, options?: Omit<RegisterTenantOptions, 'lazy' | 'client'>): TenantConfig;
+    /**
+     * Registers a tenant and establishes a connection immediately.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @param {string} uri - The MongoDB URI.
+     * @param {RegisterTenantOptions} [options] - Optional tenant registration settings.
+     * @returns {Promise<MongoClient>} The connected MongoClient instance.
+     */
+    static registerTenant(tenantId: string, uri: string, options?: Omit<RegisterTenantOptions, 'lazy'>): Promise<MongoClient>;
+    /**
+     * Retrieves the MongoClient instance for a specific tenant.
+     * If the tenant was registered lazily, connection is established on first access.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @returns {Promise<MongoClient | null>} The MongoClient or null if not registered.
+     */
+    static getClient(tenantId: string): Promise<MongoClient | null>;
+    /**
+     * Retrieves the full tenant configuration.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @returns {TenantConfig | undefined} The tenant configuration if found.
+     */
+    static getTenant(tenantId: string): TenantConfig | undefined;
+    /**
+     * Retrieves the configured database name for a tenant.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @returns {string | undefined} The database name if found.
+     */
+    static getTenantDbName(tenantId: string): string | undefined;
+    /**
+     * Returns the first connected tenant ID.
+     * Useful for backward compatibility, though not ideal in multi-tenant flows.
+     */
+    static getConnectedTenant(): string;
+    /**
+     * Returns all currently connected tenant IDs.
+     */
+    static getAllConnectedTenants(): string[];
+    /**
+     * Returns all registered tenant configs.
+     */
+    static getAllTenants(): TenantConfig[];
+    /**
+     * Returns true if at least one tenant is registered.
+     */
+    static isEnabled(): boolean;
+    /**
+     * Removes a tenant from the registry.
+     */
+    static removeTenant(tenantId: string): boolean;
+    /**
+     * Clears all tenants from the registry.
+     */
+    static clearTenants(): void;
+    private static validateTenantId;
+    private static validateUri;
+    private static extractDbNameFromUri;
+}
+//# sourceMappingURL=MultiTenantManager.d.ts.map

package/dist/tanancy/MultiTenantManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiTenantManager.d.ts","sourceRoot":"","sources":["../../src/tanancy/MultiTenantManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,OAAO,CAAwC;;IAI9D;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI3C;;;;;;;OAOG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,qBAAqB,EAAE,MAAM,GAAG,QAAQ,CAAM,GAC3D,YAAY;IAoBf;;;;;;;OAOG;WACU,cAAc,CACzB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAM,GAChD,OAAO,CAAC,WAAW,CAAC;IA6BvB;;;;;;OAMG;WACU,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IA4BrE;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAK5D;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI5D;;;OAGG;IACH,MAAM,CAAC,kBAAkB,IAAI,MAAM;IAKnC;;OAEG;IACH,MAAM,CAAC,sBAAsB,IAAI,MAAM,EAAE;IAMzC;;OAEG;IACH,MAAM,CAAC,aAAa,IAAI,YAAY,EAAE;IAItC;;OAEG;IACH,MAAM,CAAC,SAAS,IAAI,OAAO;IAI3B;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAK9C;;OAEG;IACH,MAAM,CAAC,YAAY,IAAI,IAAI;IAI3B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B,OAAO,CAAC,MAAM,CAAC,WAAW;IAU1B,OAAO,CAAC,MAAM,CAAC,oBAAoB;CAepC"}

package/dist/tanancy/MultiTenantManager.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTenantManager = void 0;
+const mongodb_1 = require("mongodb");
+/**
+ * MultiTenantManager is responsible for managing tenant configurations and MongoDB client connections in a multi-tenant application.
+ * It supports both lazy and immediate tenant registration, allowing for flexible connection management based on application needs.
+ */
+class MultiTenantManager {
+    static tenants = new Map();
+    constructor() { }
+    /**
+     * Checks if a tenant is already registered.
+     * @param {string} tenantId - The ID of the tenant to check.
+     * @returns {boolean} `true` if the tenant is registered, `false` otherwise.
+     */
+    static hasTenant(tenantId) {
+        return this.tenants.has(tenantId);
+    }
+    /**
+     * Registers a tenant for lazy connection.
+     * Connection is established only when the tenant is accessed for the first time.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @param {string} uri - The MongoDB URI.
+     * @param {RegisterTenantOptions} [options] - Optional tenant registration settings.
+     */
+    static registerLazyTenant(tenantId, uri, options = {}) {
+        this.validateTenantId(tenantId);
+        this.validateUri(uri);
+        const normalizedTenantId = tenantId.trim();
+        const tenantConfig = {
+            tenantId: normalizedTenantId,
+            uri: uri.trim(),
+            dbName: options.dbName?.trim() || this.extractDbNameFromUri(uri) || normalizedTenantId,
+            client: undefined,
+            lazy: true,
+            metadata: options.metadata
+        };
+        this.tenants.set(normalizedTenantId, tenantConfig);
+        return tenantConfig;
+    }
+    /**
+     * Registers a tenant and establishes a connection immediately.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @param {string} uri - The MongoDB URI.
+     * @param {RegisterTenantOptions} [options] - Optional tenant registration settings.
+     * @returns {Promise<MongoClient>} The connected MongoClient instance.
+     */
+    static async registerTenant(tenantId, uri, options = {}) {
+        this.validateTenantId(tenantId);
+        this.validateUri(uri);
+        const normalizedTenantId = tenantId.trim();
+        const existing = this.tenants.get(normalizedTenantId);
+        if (existing?.client) {
+            return existing.client;
+        }
+        const client = options.client ?? new mongodb_1.MongoClient(uri);
+        if (!options.client) {
+            await client.connect();
+        }
+        const tenantConfig = {
+            tenantId: normalizedTenantId,
+            uri: uri.trim(),
+            dbName: options.dbName?.trim() || this.extractDbNameFromUri(uri) || normalizedTenantId,
+            client,
+            lazy: false,
+            metadata: options.metadata
+        };
+        this.tenants.set(normalizedTenantId, tenantConfig);
+        return client;
+    }
+    /**
+     * Retrieves the MongoClient instance for a specific tenant.
+     * If the tenant was registered lazily, connection is established on first access.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @returns {Promise<MongoClient | null>} The MongoClient or null if not registered.
+     */
+    static async getClient(tenantId) {
+        this.validateTenantId(tenantId);
+        const normalizedTenantId = tenantId.trim();
+        const tenant = this.tenants.get(normalizedTenantId);
+        if (!tenant)
+            return null;
+        if (tenant.client) {
+            return tenant.client;
+        }
+        if (tenant.lazy) {
+            const client = new mongodb_1.MongoClient(tenant.uri);
+            await client.connect();
+            this.tenants.set(normalizedTenantId, {
+                ...tenant,
+                client,
+                lazy: false
+            });
+            return client;
+        }
+        return null;
+    }
+    /**
+     * Retrieves the full tenant configuration.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @returns {TenantConfig | undefined} The tenant configuration if found.
+     */
+    static getTenant(tenantId) {
+        this.validateTenantId(tenantId);
+        return this.tenants.get(tenantId.trim());
+    }
+    /**
+     * Retrieves the configured database name for a tenant.
+     *
+     * @param {string} tenantId - The tenant ID.
+     * @returns {string | undefined} The database name if found.
+     */
+    static getTenantDbName(tenantId) {
+        return this.getTenant(tenantId)?.dbName;
+    }
+    /**
+     * Returns the first connected tenant ID.
+     * Useful for backward compatibility, though not ideal in multi-tenant flows.
+     */
+    static getConnectedTenant() {
+        const connected = Array.from(this.tenants.values()).find(tenant => !!tenant.client);
+        return connected?.tenantId || '';
+    }
+    /**
+     * Returns all currently connected tenant IDs.
+     */
+    static getAllConnectedTenants() {
+        return Array.from(this.tenants.values())
+            .filter(tenant => !!tenant.client)
+            .map(tenant => tenant.tenantId);
+    }
+    /**
+     * Returns all registered tenant configs.
+     */
+    static getAllTenants() {
+        return Array.from(this.tenants.values());
+    }
+    /**
+     * Returns true if at least one tenant is registered.
+     */
+    static isEnabled() {
+        return this.tenants.size > 0;
+    }
+    /**
+     * Removes a tenant from the registry.
+     */
+    static removeTenant(tenantId) {
+        this.validateTenantId(tenantId);
+        return this.tenants.delete(tenantId.trim());
+    }
+    /**
+     * Clears all tenants from the registry.
+     */
+    static clearTenants() {
+        this.tenants.clear();
+    }
+    static validateTenantId(tenantId) {
+        if (!tenantId || typeof tenantId !== 'string' || !tenantId.trim()) {
+            throw new Error('Tenant ID is required.');
+        }
+    }
+    static validateUri(uri) {
+        if (!uri || typeof uri !== 'string' || !uri.trim()) {
+            throw new Error('MongoDB URI is required.');
+        }
+        if (!uri.startsWith('mongodb://') && !uri.startsWith('mongodb+srv://')) {
+            throw new Error(`Invalid MongoDB URI: ${uri}`);
+        }
+    }
+    static extractDbNameFromUri(uri) {
+        try {
+            const withoutQuery = uri.split('?')[0];
+            const parts = withoutQuery.split('/');
+            const lastPart = parts[parts.length - 1];
+            if (!lastPart || lastPart.includes(':')) {
+                return undefined;
+            }
+            return lastPart.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.MultiTenantManager = MultiTenantManager;

package/dist/tanancy/TenantContext.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @deprecated
+ * @internal
+ *
+ * This is legacy code and is not intended for public use. It may be removed in future versions without warning.
+ * Provides a thread-safe context for managing tenant-specific data using `AsyncLocalStorage`.
+ * This is useful for multi-tenant applications where the current tenant needs to be tracked across asynchronous operations.
+ */
+export declare class TenantContext {
+    /**
+     * Runs a callback function within a specific tenant context.
+     * @param {string} tenantId - The ID of the tenant to set in the context.
+     * @param {() => void} callback - The callback function to execute within the tenant context.
+     */
+    static run(tenantId: string, callback: () => void): void;
+    /**
+     * Sets the tenant ID in the current context.
+     * @param {string} tenantId - The ID of the tenant to set.
+     */
+    static setTenantId(tenantId: string): void;
+    /**
+     * Retrieves the tenant ID from the current context.
+     * @returns {string | undefined} The tenant ID, or `undefined` if no tenant ID is set.
+     */
+    static getTenantId(): string | undefined;
+    /**
+     * Clears the tenant ID from the current context.
+     */
+    static clear(): void;
+}
+//# sourceMappingURL=TenantContext.d.ts.map

package/dist/tanancy/TenantContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TenantContext.d.ts","sourceRoot":"","sources":["../../src/tanancy/TenantContext.ts"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,qBAAa,aAAa;IACxB;;;;OAIG;IACH,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAOxD;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK1C;;;OAGG;IACH,MAAM,CAAC,WAAW,IAAI,MAAM,GAAG,SAAS;IAIxC;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,IAAI;CAIrB"}

package/dist/tanancy/TenantContext.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantContext = void 0;
+/**
+ * This is legacy code and is not intended for public use. It may be removed in future versions without warning.
+ * @deprecated
+ * @internal
+ * TenantContext provides a thread-safe way to manage tenant-specific data using AsyncLocalStorage.
+ * This is particularly useful in multi-tenant applications where you need to track the current tenant across asynchronous operations.
+ */
+const node_async_hooks_1 = require("node:async_hooks");
+const tenantStorage = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * @deprecated
+ * @internal
+ *
+ * This is legacy code and is not intended for public use. It may be removed in future versions without warning.
+ * Provides a thread-safe context for managing tenant-specific data using `AsyncLocalStorage`.
+ * This is useful for multi-tenant applications where the current tenant needs to be tracked across asynchronous operations.
+ */
+class TenantContext {
+    /**
+     * Runs a callback function within a specific tenant context.
+     * @param {string} tenantId - The ID of the tenant to set in the context.
+     * @param {() => void} callback - The callback function to execute within the tenant context.
+     */
+    static run(tenantId, callback) {
+        if (!tenantId) {
+            throw new Error('tenantId is required to run tenant context');
+        }
+        tenantStorage.run({ tenantId: tenantId }, callback);
+    }
+    /**
+     * Sets the tenant ID in the current context.
+     * @param {string} tenantId - The ID of the tenant to set.
+     */
+    static setTenantId(tenantId) {
+        const store = tenantStorage.getStore();
+        if (store)
+            store.tenantId = tenantId;
+    }
+    /**
+     * Retrieves the tenant ID from the current context.
+     * @returns {string | undefined} The tenant ID, or `undefined` if no tenant ID is set.
+     */
+    static getTenantId() {
+        return tenantStorage.getStore()?.tenantId;
+    }
+    /**
+     * Clears the tenant ID from the current context.
+     */
+    static clear() {
+        const store = tenantStorage.getStore();
+        if (store)
+            store.tenantId = undefined;
+    }
+}
+exports.TenantContext = TenantContext;
+;

package/dist/tanancy/TenantModelResolver.d.ts

@@ -0,0 +1,10 @@
+import type { Document } from "mongodb";
+import type { AmbitenSchema } from "../lib-core";
+export type GetTenantModelParams<T extends Document> = {
+    collectionName: string;
+    schema: AmbitenSchema<T>;
+    tenantId?: string;
+    dbName?: string;
+};
+export declare const getTenantModel: <T extends Document>(params: GetTenantModelParams<T>) => Promise<any>;
+//# sourceMappingURL=TenantModelResolver.d.ts.map

package/dist/tanancy/TenantModelResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TenantModelResolver.d.ts","sourceRoot":"","sources":["../../src/tanancy/TenantModelResolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAM,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAMjD,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,QAAQ,IAAI;IACrD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAqBF,eAAO,MAAM,cAAc,GAAU,CAAC,SAAS,QAAQ,EACrD,QAAQ,oBAAoB,CAAC,CAAC,CAAC,KAC9B,OAAO,CAAC,GAAG,CAqCb,CAAC"}

package/dist/tanancy/TenantModelResolver.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTenantModel = void 0;
+const builders_1 = require("../utils/builders");
+const MultiTenantManager_1 = require("./MultiTenantManager");
+const context_1 = require("../context");
+const tenantModelsCache = new Map();
+function createTenantProvider(tenantId, dbName) {
+    return {
+        async db(ctx) {
+            const client = await MultiTenantManager_1.MultiTenantManager.getClient(tenantId);
+            if (!client) {
+                throw new Error(`Tenant "${tenantId}" not registered.`);
+            }
+            const resolvedDbName = ctx?.dbName ?? dbName;
+            return resolvedDbName ? client.db(resolvedDbName) : client.db();
+        },
+    };
+}
+const getTenantModel = async (params) => {
+    const collectionName = params?.collectionName?.trim();
+    const tenantId = params?.tenantId ?? context_1.AmbitenContext.getTenantId();
+    if (!collectionName) {
+        throw new Error("collectionName is required.");
+    }
+    if (!tenantId) {
+        throw new Error("tenantId is required to run tenant context");
+    }
+    if (!tenantModelsCache.has(tenantId)) {
+        tenantModelsCache.set(tenantId, new Map());
+    }
+    const tenantCache = tenantModelsCache.get(tenantId);
+    const cacheKey = params.dbName
+        ? `${collectionName}::${params.dbName}`
+        : collectionName;
+    if (tenantCache.has(cacheKey)) {
+        return tenantCache.get(cacheKey);
+    }
+    const provider = createTenantProvider(tenantId, params.dbName);
+    const model = (0, builders_1.Model)({
+        collectionName,
+        schema: params.schema,
+        provider,
+    });
+    tenantCache.set(cacheKey, model);
+    return model;
+};
+exports.getTenantModel = getTenantModel;
+// import { AmbitenSchema } from '../lib-core';
+// import { MultiTenantManager } from './MultiTenantManager';
+// import { TenantContext } from './TenantContext';
+// import { Model } from '../utils/builders/createModel';
+// import { ensureModelNameSafe } from '../utils/ensureModelNameSafe'; // <- wherever you put it
+// import { Document } from '../types';
+// import { Db } from 'mongodb';
+// type DbProvider = { db(ctx?: { dbName?: string }): Promise<Db> };
+// /**
+//  * Parameters required to resolve a tenant-specific model.
+//  * @template T - The type of the document in the model.
+//  */
+// export type GetTanantModelParams<T extends Document> = {
+//   collectionName: string;
+//   tenantId: string;
+//   schema?: AmbitenSchema<T>;
+// };
+// const tenantModelsCache: Map<string, Map<string, ReturnType<typeof Model>>> = new Map();
+// /**
+//  * Resolves a tenant-specific model by creating or retrieving it from the cache.
+//  * Ensures that each tenant has its own isolated model instance.
+//  *
+//  * @template T - The type of the document in the model.
+//  * @param {GetTanantModelParams<T>} param - The parameters required to resolve the model.
+//  * @param {string} param.modelName - The name of the model to resolve.
+//  * @param {AmbitenSchema<T>} [param.schema] - The schema definition for the model (optional).
+//  * @param {string} param.tenantId - The ID of the tenant for which the model is being resolved.
+//  * @returns {Promise<any>} A promise that resolves to the tenant-specific model instance.
+//  * @throws {Error} If no tenant context is found or the tenant is not registered.
+//  * @example
+//  * const userModel = await getTenantModel({
+//  *  modelName: 'User',
+//  *  schema: UserSchema,
+//  *  tenantId: 'tenant123'
+//  * });
+//  * // userModel is now a tenant-specific model for the 'User' collection in 'tenant123'
+//  * @example
+//  * const productModel = await getTenantModel({
+//  *  modelName: 'Product',
+//  *  schema: ProductSchema,
+//  *  tenantId: 'tenant456'
+//  * });
+//  */
+// export const getTenantModel = async <T extends Document>
+//   (param: GetTanantModelParams<T>): Promise<any> => {
+//   const safeCollectionName = ensureModelNameSafe(param.collectionName);
+//   const schema = param.schema;
+//   // const client = await MultiTenantManager.getClient(param.tenantId);
+//   const tenantId = param.tenantId ?? TenantContext.getTenantId();
+//   if (!tenantId) throw new Error('No tenant context found');
+//   if (!tenantModelsCache.has(tenantId)) {
+//     tenantModelsCache.set(tenantId, new Map());
+//   }
+//   const clientCache = tenantModelsCache.get(tenantId)!;
+//   if (clientCache.has(safeCollectionName)) {
+//     return clientCache.get(safeCollectionName);
+//   }
+//   const provider = tenantDbProvider(tenantId);
+//   const model = Model({
+//     collectionName: safeCollectionName,
+//     schema,
+//     provider: provider
+//   });
+//   clientCache.set(safeCollectionName, model as unknown as ReturnType<typeof Model>);
+//   return model;
+// };

package/dist/tanancy/index.d.ts

@@ -0,0 +1,5 @@
+export * from './MultiTenantManager';
+export * from './TenantContext';
+export * from './TenantModelResolver';
+export * from './init/initMultiTenancy';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tanancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}

package/dist/tanancy/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./MultiTenantManager"), exports);
+tslib_1.__exportStar(require("./TenantContext"), exports);
+tslib_1.__exportStar(require("./TenantModelResolver"), exports);
+tslib_1.__exportStar(require("./init/initMultiTenancy"), exports);

package/dist/tanancy/init/initMultiTenancy.d.ts

@@ -0,0 +1,29 @@
+import { AmbitenConfig } from '../../types/index';
+export interface InitMultiTenancyOptions {
+    lazy?: boolean;
+    config?: AmbitenConfig['logger'];
+}
+/**
+ * Initializes multi-tenancy by registering tenants with their respective MongoDB URIs.
+ * Supports both lazy (on-demand) and eager connection strategies.
+ *
+ * @param {Record<string, string>} tenants - A record of tenant IDs mapped to their MongoDB URIs.
+ * @param {InitMultiTenancyOptions} [options={}] - Optional configuration for multi-tenancy initialization.
+ * @param {boolean} [options.lazy=false] - If `true`, tenants are registered lazily (connected on-demand).
+ * @param {AmbitenConfig} [options.config] - Optional configuration, including a logger for logging messages.
+ * @returns {Promise<void>} A promise that resolves when all tenants are registered.
+ * @throws {Error} If a tenant's MongoDB URI is invalid or missing.
+ * @throws {Error} If a tenant is already registered and `lazy` is `false`.
+ * @example
+ * // Initialize multi-tenancy with eager connection. Practically, you should use applyMultiTenancy instead.
+ * that implements this function.
+ * await initMultiTenancy({
+ *   'tenant-a': 'mongodb://localhost:27017/tenant-a',
+ *  'tenant-b': 'mongodb://localhost:27017/tenant-b'
+ * }, {
+ *   lazy: false,
+ *  config: {}
+ */
+export declare const initMultiTenancy: (tenants: Record<string, string>, // tenantId => MongoDB URI
+options?: InitMultiTenancyOptions) => Promise<void>;
+//# sourceMappingURL=initMultiTenancy.d.ts.map

package/dist/tanancy/init/initMultiTenancy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initMultiTenancy.d.ts","sourceRoot":"","sources":["../../../src/tanancy/init/initMultiTenancy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGlD,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,0BAA0B;AAC3D,UAAS,uBAA4B,KACpC,OAAO,CAAC,IAAI,CA2Bd,CAAC"}

package/dist/tanancy/init/initMultiTenancy.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMultiTenancy = void 0;
+const MultiTenantManager_1 = require("../MultiTenantManager");
+/**
+ * Initializes multi-tenancy by registering tenants with their respective MongoDB URIs.
+ * Supports both lazy (on-demand) and eager connection strategies.
+ *
+ * @param {Record<string, string>} tenants - A record of tenant IDs mapped to their MongoDB URIs.
+ * @param {InitMultiTenancyOptions} [options={}] - Optional configuration for multi-tenancy initialization.
+ * @param {boolean} [options.lazy=false] - If `true`, tenants are registered lazily (connected on-demand).
+ * @param {AmbitenConfig} [options.config] - Optional configuration, including a logger for logging messages.
+ * @returns {Promise<void>} A promise that resolves when all tenants are registered.
+ * @throws {Error} If a tenant's MongoDB URI is invalid or missing.
+ * @throws {Error} If a tenant is already registered and `lazy` is `false`.
+ * @example
+ * // Initialize multi-tenancy with eager connection. Practically, you should use applyMultiTenancy instead.
+ * that implements this function.
+ * await initMultiTenancy({
+ *   'tenant-a': 'mongodb://localhost:27017/tenant-a',
+ *  'tenant-b': 'mongodb://localhost:27017/tenant-b'
+ * }, {
+ *   lazy: false,
+ *  config: {}
+ */
+const initMultiTenancy = async (tenants, // tenantId => MongoDB URI
+options = {}) => {
+    const { lazy = false, config } = options;
+    for (const [tenantId, uri] of Object.entries(tenants)) {
+        if (!uri || typeof uri !== 'string' || !uri.startsWith('mongodb')) {
+            throw new Error(`Invalid MongoDB URI for tenant "${tenantId}": ${uri}`);
+        }
+        if (MultiTenantManager_1.MultiTenantManager.hasTenant(tenantId)) {
+            config?.logger?.warn?.(`Tenant "${tenantId}" is already registered. Skipping.`);
+            continue;
+        }
+        if (lazy) {
+            // Ensure logger implements all required methods for core/src/types/logger.types.ts
+            if (config?.enabled && config.logger) {
+                const logger = config.logger;
+                return logger;
+            }
+            MultiTenantManager_1.MultiTenantManager.registerLazyTenant(tenantId, uri);
+            continue;
+        }
+        else {
+            // Eagerly connect
+            await MultiTenantManager_1.MultiTenantManager.registerTenant(tenantId, uri);
+        }
+    }
+};
+exports.initMultiTenancy = initMultiTenancy;
+function impl_Logger(logger) {
+    const { info, warn, error, fatal, debug } = logger;
+    return {
+        info: info?.bind(logger) ?? (() => { }),
+        warn: warn?.bind(logger) ?? (() => { }),
+        error: error?.bind(logger) ?? (() => { }),
+        fatal: fatal?.bind(logger) ?? (() => { }),
+        debug: debug?.bind(logger) ?? (() => { }),
+    };
+}

package/dist/templates/generateDefaultConfigContent.d.ts

@@ -0,0 +1,10 @@
+import type { AmbitenConfig } from "../types";
+export interface LoggerFormatOptions {
+    timestamp?: boolean | (() => string);
+    colorize?: boolean;
+    source?: string;
+    json?: boolean;
+    prefix?: string;
+}
+export declare function DEFAULT_CONFIG_CONTENT(options: AmbitenConfig): string;
+//# sourceMappingURL=generateDefaultConfigContent.d.ts.map

package/dist/templates/generateDefaultConfigContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateDefaultConfigContent.d.ts","sourceRoot":"","sources":["../../src/templates/generateDefaultConfigContent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAGD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CA+GrE"}