@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/modules/datasource/multi-tenant-datasource.service.js

@@ -1,212 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { DEFAULT_TENANT_HEADER, IDataSourceServiceOptions, MODULE_OPTIONS } from '@flusys/nestjs-core';
-import { BadRequestException, Inject, Injectable, InternalServerErrorException, Optional, Scope } from '@nestjs/common';
-import { SYSTEM_MESSAGES } from '../../constants';
-import { REQUEST } from '@nestjs/core';
-import { Request } from 'express';
-import { DataSource } from 'typeorm';
-import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
-export class MultiTenantDataSourceService {
-    get self() {
-        return this.constructor;
-    }
-    initializeFromOptions() {
-        if (!this.options) return;
-        if (!this.self.initialized) {
-            this.registerTenants();
-            this.self.initialized = true;
-        }
-    }
-    registerTenants() {
-        this.options?.tenants?.forEach((tenant)=>{
-            this.self.tenantsRegistry.set(tenant.id, tenant);
-        });
-    }
-    getDatabaseMode() {
-        return this.options?.bootstrapAppConfig?.databaseMode ?? 'single';
-    }
-    isMultiTenant() {
-        return this.getDatabaseMode() === 'multi-tenant';
-    }
-    getCurrentTenantId() {
-        if (!this.request) return null;
-        const tenantId = this.request.headers[this.tenantHeader];
-        if (!tenantId) return null;
-        if (!/^[a-zA-Z0-9_-]+$/.test(tenantId)) {
-            throw new BadRequestException({
-                message: 'Invalid tenant ID format',
-                messageKey: SYSTEM_MESSAGES.INVALID_TENANT_ID
-            });
-        }
-        return tenantId;
-    }
-    getCurrentTenant() {
-        const tenantId = this.getCurrentTenantId();
-        return tenantId ? this.getTenant(tenantId) : null;
-    }
-    getTenant(tenantId) {
-        return this.self.tenantsRegistry.get(tenantId) ?? null;
-    }
-    async getDataSource() {
-        return this.isMultiTenant() ? this.getTenantDataSource() : this.getSingleDataSource();
-    }
-    async getRepository(entity) {
-        const dataSource = await this.getDataSource();
-        return dataSource.getRepository(entity);
-    }
-    async closeTenantConnection(tenantId) {
-        const connection = this.self.tenantConnections.get(tenantId);
-        if (connection?.isInitialized) {
-            await connection.destroy();
-            this.self.tenantConnections.delete(tenantId);
-        }
-    }
-    async onModuleDestroy() {
-        for (const [tenantId] of this.self.tenantConnections){
-            await this.closeTenantConnection(tenantId);
-        }
-    }
-    async getSingleDataSource() {
-        if (this.self.singleDataSource?.isInitialized) {
-            return this.self.singleDataSource;
-        }
-        if (this.self.singleConnectionLock) {
-            return this.self.singleConnectionLock;
-        }
-        const config = this.getDefaultDatabaseConfig();
-        if (!config) {
-            throw new InternalServerErrorException({
-                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
-                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
-            });
-        }
-        const connectionPromise = this.createDataSourceFromConfig(config);
-        this.self.singleConnectionLock = connectionPromise;
-        try {
-            const dataSource = await connectionPromise;
-            this.self.singleDataSource = dataSource;
-            return dataSource;
-        } finally{
-            this.self.singleConnectionLock = null;
-        }
-    }
-    async getTenantDataSource() {
-        const tenant = this.getCurrentTenant();
-        if (!tenant) {
-            throw new BadRequestException({
-                message: `Tenant not found. Ensure '${this.tenantHeader}' header is set.`,
-                messageKey: SYSTEM_MESSAGES.TENANT_HEADER_REQUIRED,
-                messageVariables: {
-                    header: this.tenantHeader
-                }
-            });
-        }
-        return this.getOrCreateTenantConnection(tenant);
-    }
-    async getOrCreateTenantConnection(tenant) {
-        const existing = this.self.tenantConnections.get(tenant.id);
-        if (existing?.isInitialized) return existing;
-        const pendingConnection = this.self.connectionLocks.get(tenant.id);
-        if (pendingConnection) return pendingConnection;
-        const config = this.buildTenantDatabaseConfig(tenant);
-        const connectionPromise = this.createDataSourceFromConfig(config);
-        this.self.connectionLocks.set(tenant.id, connectionPromise);
-        try {
-            const dataSource = await connectionPromise;
-            this.self.tenantConnections.set(tenant.id, dataSource);
-            return dataSource;
-        } finally{
-            this.self.connectionLocks.delete(tenant.id);
-        }
-    }
-    getDefaultDatabaseConfig() {
-        return this.options?.defaultDatabaseConfig ?? this.options?.tenantDefaultDatabaseConfig;
-    }
-    buildTenantDatabaseConfig(tenant) {
-        const defaultConfig = this.getDefaultDatabaseConfig();
-        if (!defaultConfig) {
-            throw new InternalServerErrorException({
-                message: 'No default database config for multi-tenant mode.',
-                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
-            });
-        }
-        return {
-            type: defaultConfig.type,
-            host: tenant.host ?? defaultConfig.host,
-            port: tenant.port ?? defaultConfig.port,
-            username: tenant.username ?? defaultConfig.username,
-            password: tenant.password ?? defaultConfig.password,
-            database: tenant.database
-        };
-    }
-    async createDataSourceFromConfig(config, entities = []) {
-        const dataSource = new DataSource({
-            type: config.type,
-            host: config.host,
-            port: config.port,
-            username: config.username,
-            password: config.password,
-            database: config.database,
-            entities,
-            synchronize: false,
-            namingStrategy: new SnakeNamingStrategy()
-        });
-        if (!dataSource.isInitialized) await dataSource.initialize();
-        return dataSource;
-    }
-    constructor(options, request){
-        _define_property(this, "options", void 0);
-        _define_property(this, "request", void 0);
-        _define_property(this, "tenantHeader", void 0);
-        this.options = options;
-        this.request = request;
-        this.tenantHeader = DEFAULT_TENANT_HEADER;
-        this.initializeFromOptions();
-    }
-}
-_define_property(MultiTenantDataSourceService, "tenantConnections", new Map());
-_define_property(MultiTenantDataSourceService, "singleDataSource", null);
-_define_property(MultiTenantDataSourceService, "tenantsRegistry", new Map());
-_define_property(MultiTenantDataSourceService, "initialized", false);
-_define_property(MultiTenantDataSourceService, "connectionLocks", new Map());
-_define_property(MultiTenantDataSourceService, "singleConnectionLock", null);
-MultiTenantDataSourceService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Optional()),
-    _ts_param(0, Inject(MODULE_OPTIONS)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof IDataSourceServiceOptions === "undefined" ? Object : IDataSourceServiceOptions,
-        typeof Request === "undefined" ? Object : Request
-    ])
-], MultiTenantDataSourceService);

package/fesm/modules/datasource/multi-tenant-datasource.service.spec.js

@@ -1,377 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const mockInitialize = jest.fn();
-const mockDestroy = jest.fn();
-const mockGetRepository = jest.fn();
-let FakeDataSource = class FakeDataSource {
-    constructor(options){
-        _define_property(this, "isInitialized", false);
-        _define_property(this, "options", void 0);
-        _define_property(this, "initialize", jest.fn(async ()=>{
-            this.isInitialized = true;
-            await mockInitialize(this.options);
-            return this;
-        }));
-        _define_property(this, "destroy", jest.fn(async ()=>{
-            this.isInitialized = false;
-            await mockDestroy();
-        }));
-        _define_property(this, "getRepository", (entity)=>mockGetRepository(entity));
-        this.options = options;
-    }
-};
-jest.mock('typeorm', ()=>({
-        ...jest.requireActual('typeorm'),
-        DataSource: FakeDataSource
-    }));
-import { BadRequestException, InternalServerErrorException } from '@nestjs/common';
-import { MultiTenantDataSourceService } from './multi-tenant-datasource.service';
-import { SYSTEM_MESSAGES } from '../../constants';
-function resetStatics() {
-    const cls = MultiTenantDataSourceService;
-    cls.tenantConnections = new Map();
-    cls.singleDataSource = null;
-    cls.tenantsRegistry = new Map();
-    cls.initialized = false;
-    cls.connectionLocks = new Map();
-    cls.singleConnectionLock = null;
-}
-describe('MultiTenantDataSourceService', ()=>{
-    const defaultDatabaseConfig = {
-        type: 'postgres',
-        host: 'localhost',
-        port: 5432,
-        username: 'root',
-        password: 'pw',
-        database: 'flusys_default'
-    };
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        resetStatics();
-    });
-    function makeOptions(overrides = {}) {
-        return {
-            defaultDatabaseConfig,
-            bootstrapAppConfig: {
-                databaseMode: 'single'
-            },
-            ...overrides
-        };
-    }
-    function makeRequest(headers = {}) {
-        return {
-            headers
-        };
-    }
-    describe('database mode', ()=>{
-        it('should default to single mode when no options are provided', ()=>{
-            const service = new MultiTenantDataSourceService();
-            expect(service.getDatabaseMode()).toBe('single');
-            expect(service.isMultiTenant()).toBe(false);
-        });
-        it('should report multi-tenant mode from bootstrap config', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant'
-                }
-            }));
-            expect(service.isMultiTenant()).toBe(true);
-        });
-    });
-    describe('tenant registration', ()=>{
-        it('should register tenants from options exactly once across instances', ()=>{
-            const tenants = [
-                {
-                    id: 'tenant-a',
-                    database: 'db_a'
-                },
-                {
-                    id: 'tenant-b',
-                    database: 'db_b'
-                }
-            ];
-            const options = makeOptions({
-                tenants
-            });
-            const service1 = new MultiTenantDataSourceService(options);
-            const service2 = new MultiTenantDataSourceService(options);
-            expect(service1.getTenant('tenant-a')?.database).toBe('db_a');
-            expect(service2.getTenant('tenant-b')?.database).toBe('db_b');
-        });
-        it('should return null for an unregistered tenant', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions());
-            expect(service.getTenant('unknown')).toBeNull();
-        });
-        it('should be a no-op when constructed without options', ()=>{
-            expect(()=>new MultiTenantDataSourceService()).not.toThrow();
-        });
-    });
-    describe('getCurrentTenantId', ()=>{
-        it('should return null when there is no request (e.g. background job)', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions());
-            expect(service.getCurrentTenantId()).toBeNull();
-        });
-        it('should return null when the tenant header is missing', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions(), makeRequest());
-            expect(service.getCurrentTenantId()).toBeNull();
-        });
-        it('should return the tenant id from the header when valid', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions(), makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            expect(service.getCurrentTenantId()).toBe('tenant-a');
-        });
-        it('should reject tenant ids with invalid characters', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions(), makeRequest({
-                'x-tenant-id': 'tenant a; DROP TABLE users;'
-            }));
-            expect(()=>service.getCurrentTenantId()).toThrow(BadRequestException);
-            try {
-                service.getCurrentTenantId();
-            } catch (e) {
-                expect(e.getResponse().messageKey).toBe(SYSTEM_MESSAGES.INVALID_TENANT_ID);
-            }
-        });
-        it('should accept tenant ids with letters, numbers, underscores and dashes', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions(), makeRequest({
-                'x-tenant-id': 'Tenant_123-ABC'
-            }));
-            expect(service.getCurrentTenantId()).toBe('Tenant_123-ABC');
-        });
-    });
-    describe('getCurrentTenant', ()=>{
-        it('should resolve the registered tenant config for the current request', ()=>{
-            const tenants = [
-                {
-                    id: 'tenant-a',
-                    database: 'db_a'
-                }
-            ];
-            const service = new MultiTenantDataSourceService(makeOptions({
-                tenants
-            }), makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            expect(service.getCurrentTenant()?.database).toBe('db_a');
-        });
-        it('should return null when there is no current tenant id', ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions(), makeRequest());
-            expect(service.getCurrentTenant()).toBeNull();
-        });
-    });
-    describe('getSingleDataSource / getDataSource (single mode)', ()=>{
-        it('should create and initialize a datasource from the default config', async ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions());
-            const ds = await service.getDataSource();
-            expect(ds.isInitialized).toBe(true);
-            expect(mockInitialize).toHaveBeenCalledWith(expect.objectContaining({
-                database: 'flusys_default'
-            }));
-        });
-        it('should reuse the cached datasource on subsequent calls', async ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions());
-            const ds1 = await service.getDataSource();
-            const ds2 = await service.getDataSource();
-            expect(ds1).toBe(ds2);
-            expect(mockInitialize).toHaveBeenCalledTimes(1);
-        });
-        it('should dedupe concurrent creation attempts into a single connection', async ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions());
-            const [ds1, ds2] = await Promise.all([
-                service.getDataSource(),
-                service.getDataSource()
-            ]);
-            expect(ds1).toBe(ds2);
-            expect(mockInitialize).toHaveBeenCalledTimes(1);
-        });
-        it('should throw InternalServerErrorException when no database config is available', async ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions({
-                defaultDatabaseConfig: undefined
-            }));
-            await expect(service.getDataSource()).rejects.toThrow(InternalServerErrorException);
-        });
-        it('should fall back to tenantDefaultDatabaseConfig when defaultDatabaseConfig is absent', async ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions({
-                defaultDatabaseConfig: undefined,
-                tenantDefaultDatabaseConfig: defaultDatabaseConfig
-            }));
-            const ds = await service.getDataSource();
-            expect(ds.isInitialized).toBe(true);
-        });
-        it('getRepository should resolve the datasource then delegate to it', async ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions());
-            let Product = class Product {
-            };
-            mockGetRepository.mockReturnValue('the-repo');
-            const repo = await service.getRepository(Product);
-            expect(mockGetRepository).toHaveBeenCalledWith(Product);
-            expect(repo).toBe('the-repo');
-        });
-    });
-    describe('getTenantDataSource / getDataSource (multi-tenant mode)', ()=>{
-        function multiTenantOptions(tenants) {
-            return makeOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant'
-                },
-                tenants
-            });
-        }
-        it('should throw BadRequestException when no tenant header is present', async ()=>{
-            const service = new MultiTenantDataSourceService(multiTenantOptions([
-                {
-                    id: 'tenant-a',
-                    database: 'db_a'
-                }
-            ]), makeRequest());
-            await expect(service.getDataSource()).rejects.toThrow(BadRequestException);
-        });
-        it('should throw BadRequestException when the tenant is not registered', async ()=>{
-            const service = new MultiTenantDataSourceService(multiTenantOptions([]), makeRequest({
-                'x-tenant-id': 'ghost-tenant'
-            }));
-            await expect(service.getDataSource()).rejects.toThrow(BadRequestException);
-        });
-        it('should create a tenant-specific connection merging tenant overrides onto the default config', async ()=>{
-            const service = new MultiTenantDataSourceService(multiTenantOptions([
-                {
-                    id: 'tenant-a',
-                    database: 'db_a',
-                    host: 'tenant-a-host'
-                }
-            ]), makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            const ds = await service.getDataSource();
-            expect(ds.isInitialized).toBe(true);
-            expect(mockInitialize).toHaveBeenCalledWith(expect.objectContaining({
-                database: 'db_a',
-                host: 'tenant-a-host',
-                username: defaultDatabaseConfig.username
-            }));
-        });
-        it('should cache the tenant connection and reuse it for subsequent requests to the same tenant', async ()=>{
-            const tenants = [
-                {
-                    id: 'tenant-a',
-                    database: 'db_a'
-                }
-            ];
-            const service1 = new MultiTenantDataSourceService(multiTenantOptions(tenants), makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            const service2 = new MultiTenantDataSourceService(multiTenantOptions(tenants), makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            const ds1 = await service1.getDataSource();
-            const ds2 = await service2.getDataSource();
-            expect(ds1).toBe(ds2);
-            expect(mockInitialize).toHaveBeenCalledTimes(1);
-        });
-        it('should maintain separate connections per tenant', async ()=>{
-            const tenants = [
-                {
-                    id: 'tenant-a',
-                    database: 'db_a'
-                },
-                {
-                    id: 'tenant-b',
-                    database: 'db_b'
-                }
-            ];
-            const serviceA = new MultiTenantDataSourceService(multiTenantOptions(tenants), makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            const serviceB = new MultiTenantDataSourceService(multiTenantOptions(tenants), makeRequest({
-                'x-tenant-id': 'tenant-b'
-            }));
-            const dsA = await serviceA.getDataSource();
-            const dsB = await serviceB.getDataSource();
-            expect(dsA).not.toBe(dsB);
-            expect(mockInitialize).toHaveBeenCalledTimes(2);
-        });
-        it('should throw InternalServerErrorException when no default config exists to base tenant configs on', async ()=>{
-            const service = new MultiTenantDataSourceService({
-                ...multiTenantOptions([
-                    {
-                        id: 'tenant-a',
-                        database: 'db_a'
-                    }
-                ]),
-                defaultDatabaseConfig: undefined,
-                tenantDefaultDatabaseConfig: undefined
-            }, makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            await expect(service.getDataSource()).rejects.toThrow(InternalServerErrorException);
-        });
-    });
-    describe('closeTenantConnection', ()=>{
-        it('should destroy and remove an initialized tenant connection', async ()=>{
-            const tenants = [
-                {
-                    id: 'tenant-a',
-                    database: 'db_a'
-                }
-            ];
-            const service = new MultiTenantDataSourceService(makeOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant'
-                },
-                tenants
-            }), makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            await service.getDataSource();
-            await service.closeTenantConnection('tenant-a');
-            expect(mockDestroy).toHaveBeenCalledTimes(1);
-            expect(MultiTenantDataSourceService.tenantConnections.has('tenant-a')).toBe(false);
-        });
-        it('should be a no-op for a tenant with no active connection', async ()=>{
-            const service = new MultiTenantDataSourceService(makeOptions());
-            await expect(service.closeTenantConnection('never-connected')).resolves.toBeUndefined();
-            expect(mockDestroy).not.toHaveBeenCalled();
-        });
-    });
-    describe('onModuleDestroy', ()=>{
-        it('should close every tracked tenant connection', async ()=>{
-            const tenants = [
-                {
-                    id: 'tenant-a',
-                    database: 'db_a'
-                },
-                {
-                    id: 'tenant-b',
-                    database: 'db_b'
-                }
-            ];
-            const options = makeOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant'
-                },
-                tenants
-            });
-            const serviceA = new MultiTenantDataSourceService(options, makeRequest({
-                'x-tenant-id': 'tenant-a'
-            }));
-            const serviceB = new MultiTenantDataSourceService(options, makeRequest({
-                'x-tenant-id': 'tenant-b'
-            }));
-            await serviceA.getDataSource();
-            await serviceB.getDataSource();
-            await serviceA.onModuleDestroy();
-            expect(mockDestroy).toHaveBeenCalledTimes(2);
-        });
-    });
-});