@zintrust/core 0.1.0

package/src/microservices/MicroserviceBootstrap.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Service configuration from service.config.json
+ */
+export interface ServiceConfig {
+    name: string;
+    domain: string;
+    port?: number;
+    version: string;
+    description?: string;
+    dependencies?: string[];
+    healthCheck?: string;
+    database?: {
+        isolation: 'shared' | 'isolated';
+        migrations: boolean;
+    };
+    auth?: {
+        strategy: 'api-key' | 'jwt' | 'none' | 'custom';
+        secretKey?: string;
+        publicKey?: string;
+    };
+    tracing?: {
+        enabled: boolean;
+        samplingRate?: number;
+    };
+}
+export interface IMicroserviceBootstrap {
+    setServicesDir(dir: string): void;
+    getServicesDir(): string;
+    discoverServices(): Promise<ServiceConfig[]>;
+    registerServices(): Promise<void>;
+    getServiceConfig(domain: string, name: string): ServiceConfig | undefined;
+    getAllServiceConfigs(): ServiceConfig[];
+    isServiceIsolated(domain: string, name: string): boolean;
+    getServiceAuthStrategy(domain: string, name: string): string;
+    isTracingEnabled(domain: string, name: string): boolean;
+    getTracingSamplingRate(domain: string, name: string): number;
+    initialize(): Promise<void>;
+}
+/**
+ * Microservice Bootstrap - Handles service discovery and initialization
+ */
+export declare const MicroserviceBootstrap: {
+    getInstance(): IMicroserviceBootstrap;
+    reset(): void;
+    create(): IMicroserviceBootstrap;
+};
+/**
+ * Check if using shared database isolation
+ */
+export declare function isDatabaseShared(): boolean;
+/**
+ * Get available authentication strategies
+ */
+export declare function getAuthStrategies(): string[];
+/**
+ * Get available database isolations
+ */
+export declare function getDatabaseIsolations(): string[];
+/**
+ * Check if request tracing is globally enabled
+ */
+export declare function isTracingGloballyEnabled(): boolean;
+/**
+ * Get global tracing sampling rate
+ */
+export declare function getGlobalTracingSamplingRate(): number;
+export declare const MicroservicesConfig: {
+    isDatabaseShared: typeof isDatabaseShared;
+    getAuthStrategies: typeof getAuthStrategies;
+    getDatabaseIsolations: typeof getDatabaseIsolations;
+    isTracingGloballyEnabled: typeof isTracingGloballyEnabled;
+    getGlobalTracingSamplingRate: typeof getGlobalTracingSamplingRate;
+};
+export default MicroserviceBootstrap;
+//# sourceMappingURL=MicroserviceBootstrap.d.ts.map

package/src/microservices/MicroserviceBootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MicroserviceBootstrap.d.ts","sourceRoot":"","sources":["../../../src/microservices/MicroserviceBootstrap.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE;QACT,SAAS,EAAE,QAAQ,GAAG,UAAU,CAAC;QACjC,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;IACF,IAAI,CAAC,EAAE;QACL,QAAQ,EAAE,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;QAChD,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,OAAO,EAAE,OAAO,CAAC;QACjB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,sBAAsB;IACrC,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,cAAc,IAAI,MAAM,CAAC;IACzB,gBAAgB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAC7C,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;IAC1E,oBAAoB,IAAI,aAAa,EAAE,CAAC;IACxC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACzD,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7D,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACxD,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AA0ED;;GAEG;AACH,eAAO,MAAM,qBAAqB;mBAEf,sBAAsB;aAC5B,IAAI;cACH,sBAAsB;CA8GjC,CAAC;AA2HJ;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAE5C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,EAAE,CAEhD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,CAGrD;AAED,eAAO,MAAM,mBAAmB;;;;;;CAM/B,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/src/microservices/MicroserviceBootstrap.js

@@ -0,0 +1,285 @@
+import { Env } from '../config/env';
+import { Logger } from '../config/logger';
+import { MicroserviceManager, getEnabledServices, isMicroservicesEnabled, } from './MicroserviceManager';
+import fs from '../node-singletons/fs';
+import * as path from '../node-singletons/path';
+/**
+ * Discover services from filesystem
+ */
+async function runDiscoverServices(state) {
+    if (!isMicroservicesEnabled()) {
+        return [];
+    }
+    try {
+        const domains = getDomains(state.servicesDir);
+        const services = [];
+        for (const domain of domains) {
+            const domainServices = discoverServicesInDomain(state, domain, services.length);
+            services.push(...domainServices);
+        }
+        Logger.info(`✅ Discovered ${services.length} microservices`);
+        return services;
+    }
+    catch (err) {
+        Logger.error('Failed to discover microservices', err);
+        handleDiscoveryError(err);
+        return [];
+    }
+}
+/**
+ * Register discovered services with manager
+ */
+async function runRegisterServices(self) {
+    const services = await self.discoverServices();
+    const manager = MicroserviceManager.getInstance();
+    for (const config of services) {
+        manager.register(config);
+    }
+    Logger.info(`📋 Registered ${services.length} services with manager`);
+}
+/**
+ * Initialize services (discover, register, run migrations if needed)
+ */
+async function runInitialize(self) {
+    if (isMicroservicesEnabled() === false) {
+        Logger.info('ℹ️  Microservices disabled (MICROSERVICES env var not set)');
+        return;
+    }
+    Logger.info('🚀 Initializing microservices...');
+    // Discover and register services
+    await self.registerServices();
+    // Run migrations if configured
+    const services = self.getAllServiceConfigs();
+    for (const config of services) {
+        if (config.database?.migrations === true) {
+            Logger.info(`📦 Service ${config.name} has migrations enabled (database isolation: ${config.database.isolation})`);
+        }
+    }
+    Logger.info('✅ Microservices initialized');
+}
+/**
+ * Microservice Bootstrap - Handles service discovery and initialization
+ */
+export const MicroserviceBootstrap = Object.freeze(() => {
+    let instance;
+    return {
+        getInstance() {
+            instance ??= this.create();
+            return instance;
+        },
+        /**
+         * Reset the singleton instance (for testing)
+         */
+        reset() {
+            instance = undefined;
+        },
+        /**
+         * Create a new microservice bootstrap instance
+         */
+        create() {
+            const state = {
+                serviceConfigs: new Map(),
+                servicesDir: path.join(process.cwd(), 'src', 'services'),
+            };
+            const self = {
+                /**
+                 * Set custom services directory
+                 */
+                setServicesDir(dir) {
+                    state.servicesDir = dir;
+                },
+                getServicesDir() {
+                    return state.servicesDir;
+                },
+                /**
+                 * Discover services from filesystem
+                 */
+                async discoverServices() {
+                    return runDiscoverServices(state);
+                },
+                /**
+                 * Register discovered services with manager
+                 */
+                async registerServices() {
+                    return runRegisterServices(this);
+                },
+                /**
+                 * Get service configuration
+                 */
+                getServiceConfig(domain, name) {
+                    return state.serviceConfigs.get(getServiceKey(domain, name));
+                },
+                /**
+                 * Get all discovered service configurations
+                 */
+                getAllServiceConfigs() {
+                    return Array.from(state.serviceConfigs.values());
+                },
+                /**
+                 * Check if service has database isolation
+                 */
+                isServiceIsolated(domain, name) {
+                    const config = this.getServiceConfig(domain, name);
+                    return config?.database?.isolation === 'isolated' || false;
+                },
+                /**
+                 * Get service auth strategy
+                 */
+                getServiceAuthStrategy(domain, name) {
+                    const config = this.getServiceConfig(domain, name);
+                    return config?.auth?.strategy || 'none';
+                },
+                /**
+                 * Check if service has tracing enabled
+                 */
+                isTracingEnabled(domain, name) {
+                    const config = this.getServiceConfig(domain, name);
+                    return config?.tracing?.enabled ?? false;
+                },
+                /**
+                 * Get tracing sampling rate (0.0 to 1.0)
+                 */
+                getTracingSamplingRate(domain, name) {
+                    const config = this.getServiceConfig(domain, name);
+                    return config?.tracing?.samplingRate ?? 1;
+                },
+                /**
+                 * Initialize services (discover, register, run migrations if needed)
+                 */
+                async initialize() {
+                    return runInitialize(this);
+                },
+            };
+            return self;
+        },
+    };
+})();
+/**
+ * Generate service key for registry lookup
+ */
+function getServiceKey(domain, name) {
+    return `${domain}/${name}`;
+}
+/**
+ * Get all domains in services directory
+ */
+function getDomains(servicesDir) {
+    if (!fs.existsSync(servicesDir))
+        return [];
+    return fs.readdirSync(servicesDir).filter((file) => {
+        const filePath = path.join(servicesDir, file);
+        return fs.statSync(filePath).isDirectory();
+    });
+}
+/**
+ * Check if a service is enabled via environment
+ */
+function isServiceEnabled(serviceName, enabledServices) {
+    return enabledServices.length === 0 || enabledServices.includes(serviceName);
+}
+/**
+ * Load service configuration from file
+ */
+function loadServiceConfig(domain, serviceName, configPath, index) {
+    const configData = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return {
+        name: serviceName,
+        domain,
+        port: configData.port ?? 3001 + index,
+        version: configData.version,
+        description: configData.description,
+        dependencies: configData.dependencies ?? [],
+        healthCheck: configData.healthCheck ?? '/health',
+        database: {
+            isolation: configData.database?.isolation ?? 'shared',
+            migrations: configData.database?.migrations !== false,
+        },
+        auth: {
+            strategy: configData.auth?.strategy ?? 'none',
+            secretKey: configData.auth?.secretKey,
+            publicKey: configData.auth?.publicKey,
+        },
+        tracing: {
+            enabled: configData.tracing?.enabled ?? false,
+            samplingRate: configData.tracing?.samplingRate ?? 1,
+        },
+    };
+}
+/**
+ * Try to load service configuration if it exists
+ */
+function tryLoadServiceConfig(state, domain, serviceName, domainPath, index) {
+    const configPath = path.join(domainPath, serviceName, 'service.config.json');
+    if (!fs.existsSync(configPath))
+        return null;
+    const config = loadServiceConfig(domain, serviceName, configPath, index);
+    state.serviceConfigs.set(getServiceKey(domain, serviceName), config);
+    return config;
+}
+/**
+ * Discover all services within a specific domain
+ */
+function discoverServicesInDomain(state, domain, startIndex) {
+    const domainPath = path.join(state.servicesDir, domain);
+    const serviceNames = fs.readdirSync(domainPath).filter((file) => {
+        const filePath = path.join(domainPath, file);
+        return fs.statSync(filePath).isDirectory() && file !== 'shared';
+    });
+    const services = [];
+    const enabledServices = getEnabledServices();
+    for (const serviceName of serviceNames) {
+        if (isServiceEnabled(serviceName, enabledServices)) {
+            const config = tryLoadServiceConfig(state, domain, serviceName, domainPath, startIndex + services.length);
+            if (config)
+                services.push(config);
+        }
+    }
+    return services;
+}
+/**
+ * Handle discovery errors gracefully
+ */
+function handleDiscoveryError(err) {
+    if (err.code !== 'ENOENT') {
+        Logger.error('Error discovering services:', err);
+    }
+}
+/**
+ * Check if using shared database isolation
+ */
+export function isDatabaseShared() {
+    return Env.DATABASE_ISOLATION !== 'isolated';
+}
+/**
+ * Get available authentication strategies
+ */
+export function getAuthStrategies() {
+    return ['api-key', 'jwt', 'none', 'custom'];
+}
+/**
+ * Get available database isolations
+ */
+export function getDatabaseIsolations() {
+    return ['shared', 'isolated'];
+}
+/**
+ * Check if request tracing is globally enabled
+ */
+export function isTracingGloballyEnabled() {
+    return Env.MICROSERVICES_TRACING === true;
+}
+/**
+ * Get global tracing sampling rate
+ */
+export function getGlobalTracingSamplingRate() {
+    const rate = Env.MICROSERVICES_TRACING_RATE;
+    return Math.min(Math.max(rate, 0), 1); // Clamp between 0 and 1
+}
+export const MicroservicesConfig = {
+    isDatabaseShared,
+    getAuthStrategies,
+    getDatabaseIsolations,
+    isTracingGloballyEnabled,
+    getGlobalTracingSamplingRate,
+};
+export default MicroserviceBootstrap;

package/src/microservices/MicroserviceGenerator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Microservice generator - auto-creates microservice folder structure
+ * Generates boilerplate code for domain-driven microservices
+ */
+export interface GenerateServiceOptions {
+    domain: string;
+    services: string[];
+    basePort?: number;
+    version?: string;
+}
+export interface IMicroserviceGenerator {
+    generate(options: GenerateServiceOptions): Promise<void>;
+}
+/**
+ * Microservice code generator
+ */
+export declare const MicroserviceGenerator: {
+    getInstance(): IMicroserviceGenerator;
+    create(): IMicroserviceGenerator;
+};
+/**
+ * CLI command to generate microservices
+ */
+export declare function generateMicroservices(domain: string, services: string[], port?: number): Promise<void>;
+export declare const generate: (options: GenerateServiceOptions) => Promise<void>;
+export default MicroserviceGenerator;
+//# sourceMappingURL=MicroserviceGenerator.d.ts.map

package/src/microservices/MicroserviceGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MicroserviceGenerator.d.ts","sourceRoot":"","sources":["../../../src/microservices/MicroserviceGenerator.ts"],"names":[],"mappings":"AACA;;;GAGG;AAMH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB;mBAEf,sBAAsB;cAC3B,sBAAsB;CAgDjC,CAAC;AAkbJ;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAAE,EAClB,IAAI,GAAE,MAAa,GAClB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,eAAO,MAAM,QAAQ,GAAU,SAAS,sBAAsB,KAAG,OAAO,CAAC,IAAI,CACtB,CAAC;AAExD,eAAe,qBAAqB,CAAC"}