@zintrust/core 0.1.28 → 0.1.30

package/src/index.js

@@ -0,0 +1,212 @@
+/**
+ * @zintrust/core v0.1.30
+ *
+ * ZinTrust Framework - Production-Grade TypeScript Backend
+ * Built for performance, type safety, and exceptional developer experience
+ *
+ * Build Information:
+ *   Built: 2026-01-29T08:05:34.892Z
+ *   Node: >=20.0.0
+ *   License: MIT
+ *
+ * Copyright (c) 2026 ZinTrust
+ * https://zintrust.com
+ */
+/**
+ * ZinTrust Framework - Production-Grade TypeScript Backend
+ * Built for performance, type safety, and exceptional developer experience
+ */
+/**
+ * Framework version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export const ZINTRUST_VERSION = '0.1.23';
+export const ZINTRUST_BUILD_DATE = '2026-01-29T08:05:34.862Z'; // Replaced during build
+import { Application } from './boot/Application.js';
+import { AwsSigV4 } from './common/index.js';
+import { SignedRequest } from './security/SignedRequest.js';
+const ZintrustApplication = Application;
+const ZintrustAwsSigV4 = AwsSigV4;
+const ZintrustSignedRequest = SignedRequest;
+export { Server } from './boot/Server.js';
+export { ServiceContainer } from './container/ServiceContainer.js';
+export { createPaginator, getNextPageUrl, getPrevPageUrl, Paginator } from './database/Paginator.js';
+export { Controller } from './http/Controller.js';
+export { FileUpload } from './http/FileUpload.js';
+export { Kernel } from './http/Kernel.js';
+export { bodyParsingMiddleware } from './http/middleware/BodyParsingMiddleware.js';
+export { fileUploadMiddleware } from './http/middleware/FileUploadMiddleware.js';
+export { BodyParsers } from './http/parsers/BodyParsers.js';
+export { MultipartParser } from './http/parsers/MultipartParser.js';
+export { MultipartParserRegistry } from './http/parsers/MultipartParserRegistry.js';
+export { Request } from './http/Request.js';
+export { RequestContext } from './http/RequestContext.js';
+export { Response } from './http/Response.js';
+export { getValidatedBody, getValidatedHeaders, getValidatedParams, getValidatedQuery, hasValidatedBody, requireValidatedBody, ValidationHelper, } from './http/ValidationHelper.js';
+export { CsrfMiddleware } from './middleware/CsrfMiddleware.js';
+export { ErrorHandlerMiddleware } from './middleware/ErrorHandlerMiddleware.js';
+export { LoggingMiddleware } from './middleware/LoggingMiddleware.js';
+export { MiddlewareStack } from './middleware/MiddlewareStack.js';
+export { RateLimiter } from './middleware/RateLimiter.js';
+export { SecurityMiddleware } from './middleware/SecurityMiddleware.js';
+export { SessionMiddleware } from './middleware/SessionMiddleware.js';
+export { ValidationMiddleware } from './middleware/ValidationMiddleware.js';
+export { MySQLAdapter } from './orm/adapters/MySQLAdapter.js';
+export { PostgreSQLAdapter } from './orm/adapters/PostgreSQLAdapter.js';
+export { SQLiteAdapter } from './orm/adapters/SQLiteAdapter.js';
+export { SQLServerAdapter } from './orm/adapters/SQLServerAdapter.js';
+export { Database, resetDatabase, useDatabase, useEnsureDbConnected } from './orm/Database.js';
+export { Model } from './orm/Model.js';
+export { QueryBuilder } from './orm/QueryBuilder.js';
+export { ZintrustApplication as Application };
+// Time Utilities
+export { DateTime } from './time/DateTime.js';
+// Migrations
+// Note: `Schema` is already exported by Validation. We expose the migration schema runtime
+// as `MigrationSchema` to avoid name collisions.
+export { Schema as MigrationSchema } from './migrations/schema/index.js';
+// Adapter registry (for external adapter packages)
+export { OpenApiGenerator } from './openapi/OpenApiGenerator.js';
+export { Router } from './routes/Router.js';
+export { normalizeRouteMeta, RouteRegistry } from './routes/RouteRegistry.js';
+export { DatabaseAdapterRegistry } from './orm/DatabaseAdapterRegistry.js';
+// Common
+export { generateSecureJobId, generateUuid, getString, Utilities, } from './common/utility.js';
+export { delay, ensureDirSafe } from './common/index.js';
+export { ZintrustAwsSigV4 as AwsSigV4 };
+// Collections
+export { collect, Collection } from './collections/index.js';
+// HTTP Client
+export { HttpClient } from './tools/http/Http.js';
+// Profiling
+export { MemoryProfiler } from './profiling/MemoryProfiler.js';
+export { N1Detector } from './profiling/N1Detector.js';
+export { QueryLogger } from './profiling/QueryLogger.js';
+export { RequestProfiler } from './profiling/RequestProfiler.js';
+// Performance
+export { GenerationCache, LazyLoader, Memoize, ParallelGenerator, PerformanceOptimizer, runAll, runBatch, } from './performance/Optimizer.js';
+// Observability
+export { OpenTelemetry } from './observability/OpenTelemetry.js';
+export { PrometheusMetrics } from './observability/PrometheusMetrics.js';
+// Validation
+export { ValidationError } from './validation/ValidationError.js';
+export { Schema, Validator } from './validation/Validator.js';
+// Security
+export { CsrfTokenManager } from './security/CsrfTokenManager.js';
+export { EncryptedEnvelope } from './security/EncryptedEnvelope.js';
+export { Encryptor } from './security/Encryptor.js';
+export { Hash } from './security/Hash.js';
+export { JwtManager } from './security/JwtManager.js';
+export { PasswordResetTokenBroker } from './security/PasswordResetTokenBroker.js';
+export { createSanitizer, Sanitizer } from './security/Sanitizer.js';
+export { TokenRevocation } from './security/TokenRevocation.js';
+export { Xss } from './security/Xss.js';
+export { XssProtection } from './security/XssProtection.js';
+export { ZintrustSignedRequest as SignedRequest };
+// Exceptions
+export { ErrorFactory } from './exceptions/ZintrustError.js';
+// Events
+export { EventDispatcher } from './events/EventDispatcher.js';
+// Sessions
+export { SessionManager } from './session/SessionManager.js';
+// Config (core-owned)
+export { Env } from './config/env.js';
+export { Logger } from './config/logger.js';
+export { appConfig } from './config/app.js';
+export { cacheConfig } from './config/cache.js';
+// Cache helpers
+export { Cache, cache } from './cache/Cache.js';
+export { registerCachesFromRuntimeConfig } from './cache/CacheRuntimeRegistration.js';
+// Cache driver registry (for external driver packages)
+export { CacheDriverRegistry } from './cache/CacheDriverRegistry.js';
+export { databaseConfig } from './config/database.js';
+export { registerDatabasesFromRuntimeConfig } from './orm/DatabaseRuntimeRegistration.js';
+export { microservicesConfig } from './config/microservices.js';
+// Microservices
+export { MicroserviceBootstrap } from './microservices/MicroserviceBootstrap.js';
+export { MicroserviceManager } from './microservices/MicroserviceManager.js';
+export { RequestTracingMiddleware } from './microservices/RequestTracingMiddleware.js';
+export { ServiceAuthMiddleware } from './microservices/ServiceAuthMiddleware.js';
+export { HealthCheckHandler, ServiceHealthMonitor } from './microservices/ServiceHealthMonitor.js';
+export { middlewareConfig, MiddlewareKeys } from './config/middleware.js';
+export { createBaseDrivers, queueConfig } from './config/queue.js';
+export { default as broadcastConfig } from './config/broadcast.js';
+export { default as notificationConfig } from './config/notification.js';
+export { securityConfig } from './config/security.js';
+export { mailConfig } from './config/mail.js';
+export { storageConfig } from './config/storage.js';
+export { startupConfig } from './config/startup.js';
+export { Constants, DEFAULTS, ENV_KEYS, HTTP_HEADERS, MIME_TYPES } from './config/constants.js';
+export { FeatureFlags } from './config/features.js';
+export { Cloudflare } from './config/cloudflare.js';
+export { getDatabaseCredentials, getJwtSecrets, SECRETS, SecretsManager, } from './config/SecretsManager.js';
+// Config (validation)
+export { StartupConfigValidator } from './config/StartupConfigValidator.js';
+// Mail
+export { Mail } from './tools/mail/index.js';
+export { MailTemplateRenderer, MailTemplates } from './tools/mail/templates/index.js';
+// Mail driver registry (for external driver packages)
+export { MailDriverRegistry } from './tools/mail/MailDriverRegistry.js';
+export { registerQueuesFromRuntimeConfig } from './tools/queue/QueueRuntimeRegistration.js';
+export { SmtpDriver } from './tools/mail/drivers/Smtp.js';
+export { SendGridDriver } from './tools/mail/drivers/SendGrid.js';
+export { MailgunDriver } from './tools/mail/drivers/Mailgun.js';
+// Notifications
+export { sendSlackWebhook } from './tools/notification/drivers/Slack.js';
+export { TermiiDriver } from './tools/notification/drivers/Termii.js';
+export { sendSms } from './tools/notification/drivers/Twilio.js';
+export { Notification } from './tools/notification/Notification.js';
+export { NotificationRegistry } from './tools/notification/Registry.js';
+// Templates
+export { MarkdownRenderer } from './tools/templates/index.js';
+// Health & Runtime (for scaffolded routes and health checks)
+export { RuntimeHealthProbes } from './health/RuntimeHealthProbes.js';
+// Broadcast (for real-time features)
+export { Broadcast } from './tools/broadcast/Broadcast.js';
+export { BroadcastRegistry } from './tools/broadcast/BroadcastRegistry.js';
+export { registerBroadcastersFromRuntimeConfig } from './tools/broadcast/BroadcastRuntimeRegistration.js';
+export { BroadcastWorker } from '../packages/workers/src/index.js';
+// Notification Workers
+export { NotificationWorker } from '../packages/workers/src/index.js';
+// Storage (for file management and signed URLs)
+export { Storage } from './tools/storage/index.js';
+export { LocalSignedUrl } from './tools/storage/LocalSignedUrl.js';
+export { StorageDriverRegistry } from './tools/storage/StorageDriverRegistry.js';
+export { S3Driver } from './tools/storage/drivers/S3.js';
+export { R2Driver } from './tools/storage/drivers/R2.js';
+export { GcsDriver } from './tools/storage/drivers/Gcs.js';
+// Queue drivers (for external registration packages)
+export { RedisQueue } from './tools/queue/drivers/Redis.js';
+export { createLockProvider, getLockProvider, registerLockProvider } from './tools/queue/LockProvider.js';
+export { Queue, resolveLockPrefix } from './tools/queue/Queue.js';
+// Seeders (for database seeding)
+export { SeederLoader } from './seeders/SeederLoader.js';
+// Schedules
+export { default as logCleanup } from './schedules/log-cleanup.js';
+// Node Singletons (cross-runtime wrappers for Node.js APIs)
+export * as NodeSingletons from './node-singletons/index.js';
+// Auth features
+export { Auth } from './auth/Auth.js';
+// Microservice utilities
+export { MicroserviceGenerator } from './microservices/MicroserviceGenerator.js';
+// CLI utilities (for build tools and scripting)
+export { BaseCommand } from './cli/BaseCommand.js';
+export { CLI } from './cli/CLI.js';
+export { ErrorHandler, EXIT_CODES } from './cli/ErrorHandler.js';
+// Runtime detection and kernel
+export { getKernel } from './runtime/getKernel.js';
+export { useFileLoader } from './runtime/useFileLoader.js';
+// Plugin system
+export { PluginManager } from './runtime/PluginManager.js';
+export { PluginRegistry } from './runtime/PluginRegistry.js';
+export { nowIso } from './common/utility.js';
+export { randomBytes } from './node-singletons/crypto.js';
+// Redis config
+export * from './config/redis.js';
+export { ZintrustLang } from './lang/lang.js';
+// Workers config
+export { createRedisConnection, workersConfig } from './config/workers.js';
+// Redis config key
+export { createBullMQKey, createCacheKey, createKeyByType, createQueueKey, createRedisKey, createSessionKey, createWorkerKey, extractOriginalKey, getBullMQSafeQueueName, getPrefix, isAppKey, } from './tools/redis/RedisKeyManager.js';
+// NOTE: Node-only exports (like FileLogWriter, process) are intentionally not
+// exported from this root entrypoint. Use the '@zintrust/core/node' subpath.

package/src/lang/lang.d.ts

@@ -0,0 +1,23 @@
+export declare const ZintrustLang: {
+    readonly DATABASE: "database";
+    readonly REDIS: "redis";
+    readonly MEMORY: "memory";
+    readonly ZINTRUST_LOCKS_PREFIX: "zintrust:locks:";
+    readonly ZINTRUST_LOCKS_TTL: 300000;
+    readonly ZINTRUST_LOCKS_EXPIRE_AFTER: 300000;
+    readonly MEMORY_LOCKS: "memory:locks";
+    readonly QUEUED: "queued";
+    readonly DEDUPLICATED: "deduplicated";
+    readonly FAILED: "failed";
+    readonly REPLACE: "replace";
+    readonly DONT_RELEASE: "dontRelease";
+    readonly RELEASE_AFTER: "releaseAfter";
+    readonly AUTO_EXTEND: "autoExtend";
+    readonly RETRY_DELAY: "retryDelay";
+    readonly UNDEFINED: "undefined";
+    readonly OBJECT: "object";
+    readonly FILE_PROTOCOL: "file://";
+    readonly BOOTSTRAPJS: "bootstrap.js";
+    readonly CLI_LOCKS: "cli-locks";
+};
+//# sourceMappingURL=lang.d.ts.map

package/src/lang/lang.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lang.d.ts","sourceRoot":"","sources":["../../../src/lang/lang.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;CAqBf,CAAC"}

package/src/lang/lang.js

@@ -0,0 +1,22 @@
+export const ZintrustLang = {
+    DATABASE: 'database',
+    REDIS: 'redis',
+    MEMORY: 'memory',
+    ZINTRUST_LOCKS_PREFIX: 'zintrust:locks:',
+    ZINTRUST_LOCKS_TTL: 300000,
+    ZINTRUST_LOCKS_EXPIRE_AFTER: 300000,
+    MEMORY_LOCKS: 'memory:locks',
+    QUEUED: 'queued',
+    DEDUPLICATED: 'deduplicated',
+    FAILED: 'failed',
+    REPLACE: 'replace',
+    DONT_RELEASE: 'dontRelease',
+    RELEASE_AFTER: 'releaseAfter',
+    AUTO_EXTEND: 'autoExtend',
+    RETRY_DELAY: 'retryDelay',
+    UNDEFINED: 'undefined',
+    OBJECT: 'object',
+    FILE_PROTOCOL: 'file://',
+    BOOTSTRAPJS: 'bootstrap.js',
+    CLI_LOCKS: 'cli-locks',
+};

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":"AAaA;;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;AA2ED;;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,288 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import { MicroserviceManager, getEnabledServices, isMicroservicesEnabled, } from './MicroserviceManager.js';
+import fs from '../node-singletons/fs.js';
+import * as path from '../node-singletons/path.js';
+// Cache process.cwd() at module load time
+const projectCwd = process.cwd();
+/**
+ * Discover services from filesystem
+ */
+// eslint-disable-next-line @typescript-eslint/promise-function-async
+function runDiscoverServices(state) {
+    if (!isMicroservicesEnabled()) {
+        return Promise.resolve([]);
+    }
+    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 Promise.resolve(services);
+    }
+    catch (err) {
+        Logger.error('Failed to discover microservices', err);
+        handleDiscoveryError(err);
+        return Promise.resolve([]);
+    }
+}
+/**
+ * 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(projectCwd, '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"}