@zintrust/core 0.1.0

package/src/config/features.js

@@ -0,0 +1,49 @@
+import { Env } from './env';
+import { Logger } from './logger';
+/**
+ * Feature Flags State
+ * Internal state managed by the module
+ */
+let _rawQueryEnabled = false;
+/**
+ * Feature Flags - Controls access to advanced/experimental features
+ * Sealed namespace for immutability
+ */
+export const FeatureFlags = Object.freeze({
+    /**
+     * Initialize all feature flags from environment
+     * Called once during application bootstrap
+     */
+    initialize() {
+        _rawQueryEnabled = Env.get('USE_RAW_QRY') === 'true';
+        if (_rawQueryEnabled) {
+            Logger.warn('⚠️  FEATURE FLAG ENABLED: Raw SQL Queries are now available via adapter.rawQuery()');
+            Logger.warn('⚠️  This bypasses QueryBuilder safety - use only when necessary');
+            Logger.warn('⚠️  Ensure parameters are properly bound to prevent SQL injection');
+        }
+        else {
+            Logger.info('🔒 Raw SQL Queries are DISABLED (default, recommended for production)');
+        }
+    },
+    /**
+     * Check if raw queries are enabled
+     * Returns cached flag value (no environment lookup)
+     */
+    isRawQueryEnabled() {
+        return _rawQueryEnabled;
+    },
+    /**
+     * Reset flags (primarily for testing)
+     */
+    reset() {
+        _rawQueryEnabled = false;
+    },
+    /**
+     * Set raw query enabled state
+     * Primarily for testing to avoid 'as any' type casting
+     */
+    setRawQueryEnabled(enabled) {
+        _rawQueryEnabled = enabled;
+    },
+});
+export default FeatureFlags;

package/src/config/index.d.ts

@@ -0,0 +1,554 @@
+/**
+ * Configuration Exports
+ * Central export point for all configuration
+ */
+export { appConfig, type AppConfig } from './app';
+export { cacheConfig, type CacheConfig } from './cache';
+export { databaseConfig, type DatabaseConfig } from './database';
+export { microservicesConfig, type MicroservicesConfig } from './microservices';
+export { queueConfig, type QueueConfig } from './queue';
+export { securityConfig } from './security';
+export { storageConfig, type StorageConfig } from './storage';
+/**
+ * Combined configuration object
+ * Sealed namespace for immutability
+ */
+export declare const config: Readonly<{
+    readonly app: Readonly<{
+        readonly name: string;
+        readonly environment: "development" | "production" | "testing";
+        readonly port: number;
+        readonly host: string;
+        readonly isDevelopment: () => boolean;
+        readonly isProduction: () => boolean;
+        readonly isTesting: () => boolean;
+        readonly debug: boolean;
+        readonly timezone: string;
+        readonly requestTimeout: number;
+        readonly maxBodySize: string;
+        readonly getSafeEnv: () => NodeJS.ProcessEnv;
+    }>;
+    readonly database: Readonly<{
+        default: keyof {
+            sqlite: {
+                driver: "sqlite";
+                database: string;
+                migrations: string;
+            };
+            postgresql: {
+                driver: "postgresql";
+                host: string;
+                port: number;
+                database: string;
+                username: string;
+                password: string;
+                ssl: boolean;
+                pooling: {
+                    enabled: boolean;
+                    min: number;
+                    max: number;
+                    idleTimeout: number;
+                    connectionTimeout: number;
+                };
+            };
+            mysql: {
+                driver: "mysql";
+                host: string;
+                port: number;
+                database: string;
+                username: string;
+                password: string;
+                pooling: {
+                    enabled: boolean;
+                    min: number;
+                    max: number;
+                };
+            };
+        };
+        connections: {
+            sqlite: {
+                driver: "sqlite";
+                database: string;
+                migrations: string;
+            };
+            postgresql: {
+                driver: "postgresql";
+                host: string;
+                port: number;
+                database: string;
+                username: string;
+                password: string;
+                ssl: boolean;
+                pooling: {
+                    enabled: boolean;
+                    min: number;
+                    max: number;
+                    idleTimeout: number;
+                    connectionTimeout: number;
+                };
+            };
+            mysql: {
+                driver: "mysql";
+                host: string;
+                port: number;
+                database: string;
+                username: string;
+                password: string;
+                pooling: {
+                    enabled: boolean;
+                    min: number;
+                    max: number;
+                };
+            };
+        };
+        getConnection(this: {
+            default: keyof {
+                sqlite: {
+                    driver: "sqlite";
+                    database: string;
+                    migrations: string;
+                };
+                postgresql: {
+                    driver: "postgresql";
+                    host: string;
+                    port: number;
+                    database: string;
+                    username: string;
+                    password: string;
+                    ssl: boolean;
+                    pooling: {
+                        enabled: boolean;
+                        min: number;
+                        max: number;
+                        idleTimeout: number;
+                        connectionTimeout: number;
+                    };
+                };
+                mysql: {
+                    driver: "mysql";
+                    host: string;
+                    port: number;
+                    database: string;
+                    username: string;
+                    password: string;
+                    pooling: {
+                        enabled: boolean;
+                        min: number;
+                        max: number;
+                    };
+                };
+            };
+            connections: {
+                sqlite: {
+                    driver: "sqlite";
+                    database: string;
+                    migrations: string;
+                };
+                postgresql: {
+                    driver: "postgresql";
+                    host: string;
+                    port: number;
+                    database: string;
+                    username: string;
+                    password: string;
+                    ssl: boolean;
+                    pooling: {
+                        enabled: boolean;
+                        min: number;
+                        max: number;
+                        idleTimeout: number;
+                        connectionTimeout: number;
+                    };
+                };
+                mysql: {
+                    driver: "mysql";
+                    host: string;
+                    port: number;
+                    database: string;
+                    username: string;
+                    password: string;
+                    pooling: {
+                        enabled: boolean;
+                        min: number;
+                        max: number;
+                    };
+                };
+            };
+        }): {
+            driver: "sqlite";
+            database: string;
+            migrations: string;
+        } | {
+            driver: "postgresql";
+            host: string;
+            port: number;
+            database: string;
+            username: string;
+            password: string;
+            ssl: boolean;
+            pooling: {
+                enabled: boolean;
+                min: number;
+                max: number;
+                idleTimeout: number;
+                connectionTimeout: number;
+            };
+        } | {
+            driver: "mysql";
+            host: string;
+            port: number;
+            database: string;
+            username: string;
+            password: string;
+            pooling: {
+                enabled: boolean;
+                min: number;
+                max: number;
+            };
+        };
+        logging: {
+            enabled: boolean;
+            level: string;
+        };
+        migrations: {
+            directory: string;
+            extension: string;
+        };
+        seeders: {
+            directory: string;
+        };
+    }>;
+    readonly storage: Readonly<{
+        default: string;
+        drivers: {
+            local: {
+                driver: "local";
+                root: string;
+                url: string;
+                visibility: string;
+            };
+            s3: {
+                driver: "s3";
+                key: string;
+                secret: string;
+                region: string;
+                bucket: string;
+                url: string;
+                endpoint: string;
+                usePathStyleUrl: boolean;
+            };
+            gcs: {
+                driver: "gcs";
+                projectId: string;
+                keyFile: string;
+                bucket: string;
+                url: string;
+            };
+        };
+        getDriver(this: {
+            default: string;
+            drivers: {
+                local: {
+                    driver: "local";
+                    root: string;
+                    url: string;
+                    visibility: string;
+                };
+                s3: {
+                    driver: "s3";
+                    key: string;
+                    secret: string;
+                    region: string;
+                    bucket: string;
+                    url: string;
+                    endpoint: string;
+                    usePathStyleUrl: boolean;
+                };
+                gcs: {
+                    driver: "gcs";
+                    projectId: string;
+                    keyFile: string;
+                    bucket: string;
+                    url: string;
+                };
+            };
+        }): {
+            driver: "local";
+            root: string;
+            url: string;
+            visibility: string;
+        } | {
+            driver: "s3";
+            key: string;
+            secret: string;
+            region: string;
+            bucket: string;
+            url: string;
+            endpoint: string;
+            usePathStyleUrl: boolean;
+        } | {
+            driver: "gcs";
+            projectId: string;
+            keyFile: string;
+            bucket: string;
+            url: string;
+        };
+        temp: {
+            path: string;
+            maxAge: number;
+        };
+        uploads: {
+            maxSize: string;
+            allowedMimes: string;
+            path: string;
+        };
+        backups: {
+            path: string;
+            driver: string;
+        };
+    }>;
+    readonly security: Readonly<{
+        readonly jwt: {
+            readonly enabled: boolean;
+            readonly secret: string;
+            readonly algorithm: "HS256" | "HS512" | "RS256";
+            readonly expiresIn: string;
+            readonly refreshExpiresIn: string;
+            readonly issuer: string;
+            readonly audience: string;
+        };
+        readonly csrf: {
+            readonly enabled: boolean;
+            readonly headerName: string;
+            readonly tokenName: string;
+            readonly cookieName: string;
+            readonly cookieHttpOnly: boolean;
+            readonly cookieSecure: boolean;
+            readonly cookieSameSite: "strict" | "lax" | "none";
+        };
+        readonly encryption: {
+            readonly algorithm: string;
+            readonly key: string;
+        };
+        readonly apiKey: {
+            readonly enabled: boolean;
+            readonly headerName: string;
+            readonly secret: string;
+        };
+        readonly cors: {
+            readonly enabled: boolean;
+            readonly origins: string[];
+            readonly methods: string[];
+            readonly allowedHeaders: string[];
+            readonly exposedHeaders: string[];
+            readonly credentials: boolean;
+            readonly maxAge: number;
+        };
+        readonly rateLimit: {
+            readonly enabled: boolean;
+            readonly windowMs: number;
+            readonly maxRequests: number;
+            readonly message: string;
+        };
+        readonly xss: {
+            readonly enabled: boolean;
+            readonly reportUri: string;
+        };
+        readonly helmet: {
+            readonly enabled: boolean;
+            readonly contentSecurityPolicy: boolean;
+            readonly hsts: {
+                readonly enabled: boolean;
+                readonly maxAge: number;
+                readonly includeSubDomains: boolean;
+            };
+        };
+        readonly session: {
+            readonly name: string;
+            readonly secret: string;
+            readonly expiresIn: number;
+            readonly secure: boolean;
+            readonly httpOnly: boolean;
+            readonly sameSite: "strict" | "lax" | "none";
+        };
+        readonly password: {
+            readonly minLength: number;
+            readonly requireUppercase: boolean;
+            readonly requireNumbers: boolean;
+            readonly requireSpecialChars: boolean;
+            readonly bcryptRounds: number;
+        };
+    }>;
+    readonly microservices: Readonly<{
+        readonly enabled: boolean;
+        readonly services: string[];
+        readonly discovery: {
+            readonly type: "filesystem" | "consul" | "etcd";
+            readonly servicesPath: string;
+            readonly refreshInterval: number;
+        };
+        readonly registry: {
+            readonly host: string;
+            readonly port: number;
+            readonly deregisterCriticalServiceAfter: string;
+        };
+        readonly auth: {
+            readonly strategy: "api-key" | "jwt" | "none" | "custom";
+            readonly apiKey: string;
+            readonly jwtSecret: string;
+        };
+        readonly tracing: {
+            readonly enabled: boolean;
+            readonly samplingRate: number;
+            readonly exportInterval: number;
+            readonly jaegerEndpoint: string;
+        };
+        readonly database: {
+            readonly isolation: "shared" | "isolated";
+            readonly schema: string;
+        };
+        readonly healthCheck: {
+            readonly enabled: boolean;
+            readonly interval: number;
+            readonly timeout: number;
+            readonly unhealthyThreshold: number;
+            readonly healthyThreshold: number;
+        };
+        readonly communication: {
+            readonly timeout: number;
+            readonly retries: number;
+            readonly retryDelay: number;
+            readonly circuitBreaker: {
+                readonly enabled: boolean;
+                readonly threshold: number;
+                readonly timeout: number;
+            };
+        };
+        readonly mesh: {
+            readonly enabled: boolean;
+            readonly type: "istio" | "linkerd";
+            readonly namespace: string;
+        };
+    }>;
+    readonly cache: Readonly<{
+        default: string;
+        drivers: {
+            memory: {
+                driver: "memory";
+                ttl: number;
+            };
+            redis: {
+                driver: "redis";
+                host: string;
+                port: number;
+                password: string;
+                database: number;
+                ttl: number;
+            };
+            memcached: {
+                driver: "memcached";
+                servers: string[];
+                ttl: number;
+            };
+            file: {
+                driver: "file";
+                path: string;
+                ttl: number;
+            };
+        };
+        getDriver(): {
+            driver: "memory";
+            ttl: number;
+        } | {
+            driver: "redis";
+            host: string;
+            port: number;
+            password: string | undefined;
+            database: number;
+            ttl: number;
+        } | {
+            driver: "memcached";
+            servers: string[];
+            ttl: number;
+        } | {
+            driver: "file";
+            path: string;
+            ttl: number;
+        };
+        keyPrefix: string;
+        ttl: number;
+    }>;
+    readonly queue: Readonly<{
+        default: "database" | "redis" | "sync" | "rabbitmq" | "sqs";
+        drivers: {
+            sync: {
+                driver: "sync";
+            };
+            database: {
+                driver: "database";
+                table: string;
+                connection: string;
+            };
+            redis: {
+                driver: "redis";
+                host: string;
+                port: number;
+                password: string;
+                database: number;
+            };
+            rabbitmq: {
+                driver: "rabbitmq";
+                host: string;
+                port: number;
+                username: string;
+                password: string;
+                vhost: string;
+            };
+            sqs: {
+                driver: "sqs";
+                key: string;
+                secret: string;
+                region: string;
+                queueUrl: string;
+            };
+        };
+        getDriver(): {
+            driver: "sync";
+        } | {
+            driver: "database";
+            table: string;
+            connection: string;
+        } | {
+            driver: "redis";
+            host: string;
+            port: number;
+            password?: string;
+            database: number;
+        } | {
+            driver: "rabbitmq";
+            host: string;
+            port: number;
+            username: string;
+            password: string;
+            vhost: string;
+        } | {
+            driver: "sqs";
+            key?: string;
+            secret?: string;
+            region: string;
+            queueUrl?: string;
+        };
+        failed: {
+            database: string;
+            table: string;
+        };
+        processing: {
+            timeout: number;
+            retries: number;
+            backoff: number;
+            workers: number;
+        };
+    }>;
+}>;
+export type Config = typeof config;
+//# sourceMappingURL=index.d.ts.map

package/src/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQR,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}

package/src/config/index.js

@@ -0,0 +1,31 @@
+/**
+ * Configuration Exports
+ * Central export point for all configuration
+ */
+import { appConfig } from './app';
+import { cacheConfig } from './cache';
+import { databaseConfig } from './database';
+import { microservicesConfig } from './microservices';
+import { queueConfig } from './queue';
+import { securityConfig } from './security';
+import { storageConfig } from './storage';
+export { appConfig } from './app';
+export { cacheConfig } from './cache';
+export { databaseConfig } from './database';
+export { microservicesConfig } from './microservices';
+export { queueConfig } from './queue';
+export { securityConfig } from './security';
+export { storageConfig } from './storage';
+/**
+ * Combined configuration object
+ * Sealed namespace for immutability
+ */
+export const config = Object.freeze({
+    app: appConfig,
+    database: databaseConfig,
+    storage: storageConfig,
+    security: securityConfig,
+    microservices: microservicesConfig,
+    cache: cacheConfig,
+    queue: queueConfig,
+});

package/src/config/logger.d.ts

@@ -0,0 +1,17 @@
+interface ILogger {
+    debug(message: string, data?: unknown, category?: string): void;
+    info(message: string, data?: unknown, category?: string): void;
+    warn(message: string, data?: unknown, category?: string): void;
+    error(message: string, error?: unknown, category?: string): void;
+    fatal(message: string, error?: unknown, category?: string): void;
+}
+export declare const Logger: Readonly<{
+    debug: (message: string, data?: unknown, category?: string) => void;
+    info: (message: string, data?: unknown, category?: string) => void;
+    warn: (message: string, data?: unknown, category?: string) => void;
+    error: (message: string, error?: unknown, category?: string) => void;
+    fatal: (message: string, error?: unknown, category?: string) => void;
+    scope: (scope: string) => ILogger;
+}>;
+export default Logger;
+//# sourceMappingURL=logger.d.ts.map

package/src/config/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/config/logger.ts"],"names":[],"mappings":"AAOA,UAAU,OAAO;IACf,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClE;AAwED,eAAO,MAAM,MAAM;qBArDQ,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAOjD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAKhD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;qBAK/C,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;qBAMjD,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;mBAS1C,MAAM,KAAG,OAAO;EA4BhD,CAAC;AAEH,eAAe,MAAM,CAAC"}