@zintrust/core 0.1.13 → 0.1.15

package/src/config/database.js

@@ -4,61 +4,79 @@
  * Sealed namespace for immutability
  */
 import { Env } from './env.js';
-const isDatabaseConnectionName = (value) => {
-    return value === 'sqlite' || value === 'postgresql' || value === 'mysql';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const hasOwn = (obj, key) => {
+    return Object.prototype.hasOwnProperty.call(obj, key);
 };
-const getDefaultConnection = () => {
-    const value = Env.DB_CONNECTION;
-    return isDatabaseConnectionName(value) ? value : 'sqlite';
+const getDefaultConnection = (connections) => {
+    const envSelectedRaw = Env.get('DB_CONNECTION', '');
+    const value = String(envSelectedRaw ?? '').trim();
+    if (value.length > 0 && hasOwn(connections, value))
+        return value;
+    if (envSelectedRaw.trim().length > 0) {
+        throw ErrorFactory.createConfigError(`Database connection not configured: ${value}`);
+    }
+    return hasOwn(connections, 'sqlite') ? 'sqlite' : (Object.keys(connections)[0] ?? 'sqlite');
 };
 const getDatabaseConnection = (config) => {
     const connName = config.default;
-    return config.connections[connName];
+    const resolved = config.connections[connName];
+    if (resolved !== undefined)
+        return resolved;
+    // Backwards-compatible fallback.
+    const sqliteFallback = config.connections['sqlite'];
+    if (sqliteFallback !== undefined)
+        return sqliteFallback;
+    const first = Object.values(config.connections)[0];
+    if (first !== undefined)
+        return first;
+    throw ErrorFactory.createConfigError(`No database connections are configured (default='${connName}').`);
+};
+const connections = {
+    sqlite: {
+        driver: 'sqlite',
+        database: Env.DB_DATABASE,
+        migrations: 'database/migrations',
+    },
+    postgresql: {
+        driver: 'postgresql',
+        host: Env.DB_HOST,
+        port: Env.DB_PORT,
+        database: Env.DB_DATABASE,
+        username: Env.DB_USERNAME,
+        password: Env.DB_PASSWORD,
+        ssl: Env.getBool('DB_SSL', false),
+        pooling: {
+            enabled: Env.getBool('DB_POOLING', true),
+            min: Env.getInt('DB_POOL_MIN', 5),
+            max: Env.getInt('DB_POOL_MAX', 20),
+            idleTimeout: Env.getInt('DB_IDLE_TIMEOUT', 30000),
+            connectionTimeout: Env.getInt('DB_CONNECTION_TIMEOUT', 10000),
+        },
+    },
+    mysql: {
+        driver: 'mysql',
+        host: Env.DB_HOST,
+        port: Env.DB_PORT,
+        database: Env.DB_DATABASE,
+        username: Env.DB_USERNAME,
+        password: Env.DB_PASSWORD,
+        pooling: {
+            enabled: Env.getBool('DB_POOLING', true),
+            min: Env.getInt('DB_POOL_MIN', 5),
+            max: Env.getInt('DB_POOL_MAX', 20),
+        },
+    },
 };
 const databaseConfigObj = {
     /**
      * Default database connection
      */
-    default: getDefaultConnection(),
+    default: getDefaultConnection(connections),
     /**
      * Database connections
      */
-    connections: {
-        sqlite: {
-            driver: 'sqlite',
-            database: Env.DB_DATABASE,
-            migrations: 'database/migrations',
-        },
-        postgresql: {
-            driver: 'postgresql',
-            host: Env.DB_HOST,
-            port: Env.DB_PORT,
-            database: Env.DB_DATABASE,
-            username: Env.DB_USERNAME,
-            password: Env.DB_PASSWORD,
-            ssl: Env.getBool('DB_SSL', false),
-            pooling: {
-                enabled: Env.getBool('DB_POOLING', true),
-                min: Env.getInt('DB_POOL_MIN', 5),
-                max: Env.getInt('DB_POOL_MAX', 20),
-                idleTimeout: Env.getInt('DB_IDLE_TIMEOUT', 30000),
-                connectionTimeout: Env.getInt('DB_CONNECTION_TIMEOUT', 10000),
-            },
-        },
-        mysql: {
-            driver: 'mysql',
-            host: Env.DB_HOST,
-            port: Env.DB_PORT,
-            database: Env.DB_DATABASE,
-            username: Env.DB_USERNAME,
-            password: Env.DB_PASSWORD,
-            pooling: {
-                enabled: Env.getBool('DB_POOLING', true),
-                min: Env.getInt('DB_POOL_MIN', 5),
-                max: Env.getInt('DB_POOL_MAX', 20),
-            },
-        },
-    },
+    connections,
     /**
      * Get current connection config
      */

package/src/config/index.d.ts

@@ -3,10 +3,12 @@
  * Central export point for all configuration
  */
 export { appConfig, type AppConfig } from './app';
+export { default as broadcastConfig } from './broadcast';
 export { cacheConfig, type CacheConfig } from './cache';
 export { databaseConfig, type DatabaseConfig } from './database';
 export { microservicesConfig, type MicroservicesConfig } from './microservices';
 export { middlewareConfig } from './middleware';
+export { notificationConfig, type NotificationConfig } from './notification';
 export { queueConfig, type QueueConfig } from './queue';
 export { securityConfig } from './security';
 export { storageConfig, type StorageConfig } from './storage';
@@ -29,8 +31,19 @@ export declare const config: Readonly<{
         readonly maxBodySize: string;
         readonly getSafeEnv: () => NodeJS.ProcessEnv;
     }>;
+    readonly broadcast: Readonly<{
+        readonly default: string;
+        readonly drivers: {
+            readonly inmemory: import("./type").InMemoryBroadcastDriverConfig;
+            readonly pusher: import("./type").PusherBroadcastDriverConfig;
+            readonly redis: import("./type").RedisBroadcastDriverConfig;
+            readonly redishttps: import("./type").RedisHttpsBroadcastDriverConfig;
+        };
+        readonly getDriverName: () => string;
+        readonly getDriverConfig: (name?: string) => import("./type").KnownBroadcastDriverConfig;
+    }>;
     readonly database: Readonly<{
-        default: keyof import("./type").DatabaseConnections;
+        default: string;
         connections: {
             sqlite: {
                 driver: "sqlite";
@@ -84,6 +97,7 @@ export declare const config: Readonly<{
         readonly default: string;
         readonly drivers: import("./type").StorageDrivers;
         getDriver(this: import("./type").StorageConfigRuntime): import("./type").StorageDriverConfig;
+        getDriverConfig(this: import("./type").StorageConfigRuntime, name?: string): import("./type").StorageDriverConfig;
         readonly temp: {
             path: string;
             maxAge: number;
@@ -98,6 +112,13 @@ export declare const config: Readonly<{
             driver: string;
         };
     }>;
+    readonly notification: Readonly<{
+        readonly default: string;
+        readonly drivers: import("./type").NotificationDrivers;
+        readonly providers: import("./type").NotificationProviders;
+        readonly getDriverName: () => string;
+        readonly getDriverConfig: (name?: string) => import("./type").KnownNotificationDriverConfig;
+    }>;
     readonly security: Readonly<{
         readonly jwt: {
             readonly enabled: boolean;
@@ -250,7 +271,7 @@ export declare const config: Readonly<{
                 ttl: number;
             };
         };
-        getDriver(): import("./type").CacheDriverConfig;
+        getDriver(name?: string): import("./type").CacheDriverConfig;
         keyPrefix: string;
         ttl: number;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,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,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASR,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,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,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACnF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWR,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}

package/src/config/index.js

@@ -3,18 +3,22 @@
  * Central export point for all configuration
  */
 import { appConfig } from './app.js';
+import broadcastConfig from './broadcast.js';
 import { cacheConfig } from './cache.js';
 import { databaseConfig } from './database.js';
 import { microservicesConfig } from './microservices.js';
 import { middlewareConfig } from './middleware.js';
+import notificationConfig from './notification.js';
 import { queueConfig } from './queue.js';
 import { securityConfig } from './security.js';
 import { storageConfig } from './storage.js';
 export { appConfig } from './app.js';
+export { default as broadcastConfig } from './broadcast.js';
 export { cacheConfig } from './cache.js';
 export { databaseConfig } from './database.js';
 export { microservicesConfig } from './microservices.js';
 export { middlewareConfig } from './middleware.js';
+export { notificationConfig } from './notification.js';
 export { queueConfig } from './queue.js';
 export { securityConfig } from './security.js';
 export { storageConfig } from './storage.js';
@@ -24,8 +28,10 @@ export { storageConfig } from './storage.js';
  */
 export const config = Object.freeze({
     app: appConfig,
+    broadcast: broadcastConfig,
     database: databaseConfig,
     storage: storageConfig,
+    notification: notificationConfig,
     security: securityConfig,
     middleware: middlewareConfig,
     microservices: microservicesConfig,

package/src/config/mail.d.ts

@@ -3,12 +3,12 @@
  * Runtime mail drivers and settings
  * Sealed namespace for immutability
  */
-import type { MailDriverConfig, MailDriverName } from './type';
+import type { MailDriverConfig } from './type';
 export declare const mailConfig: Readonly<{
     /**
      * Default mail driver
      */
-    readonly default: MailDriverName;
+    readonly default: string;
     /**
      * Default "From" identity
      */
@@ -57,7 +57,7 @@ export declare const mailConfig: Readonly<{
     /**
      * Get selected driver config
      */
-    readonly getDriver: () => MailDriverConfig;
+    readonly getDriver: (name?: string) => MailDriverConfig;
 }>;
 export type MailConfig = typeof mailConfig;
 //# sourceMappingURL=mail.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mail.d.ts","sourceRoot":"","sources":["../../../src/config/mail.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAmB,gBAAgB,EAAE,cAAc,EAAe,MAAM,cAAc,CAAC;AA2FnG,eAAO,MAAM,UAAU;IA7ErB;;OAEG;;IAGH;;OAEG;;;;;IAMH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsDH;;OAEG;8BACU,gBAAgB;EAKuB,CAAC;AACvD,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC"}
+{"version":3,"file":"mail.d.ts","sourceRoot":"","sources":["../../../src/config/mail.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAkHtE,eAAO,MAAM,UAAU;IA7ErB;;OAEG;;IAGH;;OAEG;;;;;IAMH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsDH;;OAEG;gCACc,MAAM,KAAG,gBAAgB;EAKU,CAAC;AACvD,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC"}

package/src/config/mail.js

@@ -4,19 +4,41 @@
  * Sealed namespace for immutability
  */
 import { Env } from './env.js';
-const getMailDriver = (config) => {
-    const defaultDriver = config.default;
-    if (Object.hasOwn(config.drivers, defaultDriver)) {
-        const driverName = defaultDriver;
-        return config.drivers[driverName];
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const isMailDriverConfig = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (!('driver' in value))
+        return false;
+    const driver = value.driver;
+    return typeof driver === 'string' && driver.trim().length > 0;
+};
+const getMailDriver = (config, name) => {
+    const drivers = config.drivers;
+    const envSelectedRaw = Env.get('MAIL_CONNECTION', Env.get('MAIL_DRIVER', '')).trim();
+    const selected = (name ??
+        (envSelectedRaw.length > 0 ? envSelectedRaw : undefined) ??
+        config.default)
+        .toString()
+        .trim();
+    if (selected.length === 0) {
+        const disabled = drivers['disabled'];
+        if (isMailDriverConfig(disabled))
+            return disabled;
+        throw ErrorFactory.createConfigError('Mail driver not configured: disabled');
+    }
+    if (Object.hasOwn(drivers, selected)) {
+        const resolved = drivers[selected];
+        if (isMailDriverConfig(resolved))
+            return resolved;
     }
-    return config.drivers.disabled;
+    throw ErrorFactory.createConfigError(`Mail driver not configured: ${selected}`);
 };
 const mailConfigObj = {
     /**
      * Default mail driver
      */
-    default: Env.get('MAIL_DRIVER', 'disabled') ?? 'disabled',
+    default: Env.get('MAIL_CONNECTION', Env.get('MAIL_DRIVER', 'disabled')).trim().toLowerCase(),
     /**
      * Default "From" identity
      */
@@ -83,8 +105,8 @@ const mailConfigObj = {
     /**
      * Get selected driver config
      */
-    getDriver() {
-        return getMailDriver(this);
+    getDriver(name) {
+        return getMailDriver(this, name);
     },
 };
 export const mailConfig = Object.freeze(mailConfigObj);

package/src/config/notification.d.ts

@@ -1,41 +1,37 @@
 /**
  * Notification Configuration
  *
- * Config-first mapping of notification providers.
- * Keeps runtime driver selection in one place and uses Env for safe access.
+ * Config-first mapping of notification providers/channels.
+ * Driver selection must be dynamic (tests may mutate process.env).
  */
-declare const _default: Readonly<{
+import type { KnownNotificationDriverConfig, NotificationDrivers, NotificationProviders } from './type';
+export declare const notificationConfig: Readonly<{
     /**
-     * Normalized notification driver name.
+     * Default notification channel name (normalized).
+     */
+    readonly default: string;
+    /**
+     * Notification channels.
      *
-     * NOTE: This intentionally supports custom driver names (e.g. project-specific drivers),
-     * so it returns a string rather than a strict union.
+     * You may add custom named channels (e.g. `opsSlack`, `smsMarketing`) that
+     * point to any known driver config.
+     */
+    readonly drivers: NotificationDrivers;
+    /**
+     * Legacy provider configs (kept for backwards compatibility with wrappers).
+     */
+    readonly providers: NotificationProviders;
+    /**
+     * Normalized notification channel name.
      */
     readonly getDriverName: () => string;
     /**
-     * Provider configs.
+     * Resolve a channel config.
+     * - Unknown names throw when explicitly selected.
+     * - `default` is a reserved alias of the configured default.
      */
-    readonly providers: {
-        console: {
-            driver: "console";
-        };
-        termii: {
-            driver: "termii";
-            apiKey: string;
-            sender: string;
-            endpoint: string;
-        };
-        twilio: {
-            driver: "twilio";
-            accountSid: string;
-            authToken: string;
-            fromNumber: string;
-        };
-        slack: {
-            driver: "slack";
-            webhookUrl: string;
-        };
-    };
+    readonly getDriverConfig: (name?: string) => KnownNotificationDriverConfig;
 }>;
-export default _default;
+export type NotificationConfig = typeof notificationConfig;
+export default notificationConfig;
 //# sourceMappingURL=notification.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"notification.d.ts","sourceRoot":"","sources":["../../../src/config/notification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;;IAMD;;;;;OAKG;kCACc,MAAM;IAIvB;;OAEG;;;;;;;;;;;;;;;;;;;;;;;AA2BL,wBAAoD"}
+{"version":3,"file":"notification.d.ts","sourceRoot":"","sources":["../../../src/config/notification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,6BAA6B,EAE7B,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,cAAc,CAAC;AAuHtB,eAAO,MAAM,kBAAkB;IA1C7B;;OAEG;sBACY,MAAM;IAIrB;;;;;OAKG;sBACY,mBAAmB;IAKlC;;OAEG;wBACc,qBAAqB;IAItC;;OAEG;kCACc,MAAM;IAIvB;;;;OAIG;sCACoB,MAAM,KAAG,6BAA6B;EAKO,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAE3D,eAAe,kBAAkB,CAAC"}

package/src/config/notification.js

@@ -1,27 +1,48 @@
 /**
  * Notification Configuration
  *
- * Config-first mapping of notification providers.
- * Keeps runtime driver selection in one place and uses Env for safe access.
+ * Config-first mapping of notification providers/channels.
+ * Driver selection must be dynamic (tests may mutate process.env).
  */
 import { Env } from './env.js';
-const notificationConfigObj = {
-    /**
-     * Normalized notification driver name.
-     *
-     * NOTE: This intentionally supports custom driver names (e.g. project-specific drivers),
-     * so it returns a string rather than a strict union.
-     */
-    getDriverName() {
-        return Env.get('NOTIFICATION_DRIVER', 'console').trim().toLowerCase();
-    },
-    /**
-     * Provider configs.
-     */
-    providers: {
-        console: {
-            driver: 'console',
-        },
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const normalizeName = (value) => value.trim().toLowerCase();
+const hasOwn = (obj, key) => {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+};
+const getDefaultChannel = (drivers) => {
+    const envSelectedRaw = Env.get('NOTIFICATION_CONNECTION', Env.get('NOTIFICATION_DRIVER', 'console'));
+    const value = normalizeName(envSelectedRaw ?? 'console');
+    if (value.length > 0 && hasOwn(drivers, value))
+        return value;
+    if (envSelectedRaw.trim().length > 0) {
+        throw ErrorFactory.createConfigError(`Notification channel not configured: ${value}`);
+    }
+    return hasOwn(drivers, 'console') ? 'console' : (Object.keys(drivers)[0] ?? 'console');
+};
+const getNotificationDriver = (config, name) => {
+    const selected = normalizeName(String(name ?? config.default));
+    const channelName = selected === 'default' ? normalizeName(config.default) : selected;
+    const isExplicitSelection = name !== undefined &&
+        String(name).trim().length > 0 &&
+        normalizeName(String(name)) !== 'default';
+    if (channelName.length > 0 && hasOwn(config.drivers, channelName)) {
+        const resolved = config.drivers[channelName];
+        if (resolved !== undefined)
+            return resolved;
+    }
+    if (Object.keys(config.drivers ?? {}).length === 0) {
+        throw ErrorFactory.createConfigError('No notification channels are configured');
+    }
+    if (isExplicitSelection) {
+        throw ErrorFactory.createConfigError(`Notification channel not configured: ${channelName}`);
+    }
+    // Default selection is strict: if `default` points at an unconfigured channel, throw.
+    throw ErrorFactory.createConfigError(`Notification channel not configured: ${channelName}`);
+};
+const getBaseProviders = () => {
+    return {
+        console: { driver: 'console' },
         termii: {
             driver: 'termii',
             apiKey: Env.get('TERMII_API_KEY', ''),
@@ -38,6 +59,45 @@ const notificationConfigObj = {
             driver: 'slack',
             webhookUrl: Env.get('SLACK_WEBHOOK_URL', ''),
         },
+    };
+};
+const notificationConfigObj = {
+    /**
+     * Default notification channel name (normalized).
+     */
+    get default() {
+        return getDefaultChannel(this.drivers);
+    },
+    /**
+     * Notification channels.
+     *
+     * You may add custom named channels (e.g. `opsSlack`, `smsMarketing`) that
+     * point to any known driver config.
+     */
+    get drivers() {
+        // Return a record of channels; can be extended by app-level config.
+        return getBaseProviders();
+    },
+    /**
+     * Legacy provider configs (kept for backwards compatibility with wrappers).
+     */
+    get providers() {
+        return getBaseProviders();
+    },
+    /**
+     * Normalized notification channel name.
+     */
+    getDriverName() {
+        return normalizeName(this.default);
+    },
+    /**
+     * Resolve a channel config.
+     * - Unknown names throw when explicitly selected.
+     * - `default` is a reserved alias of the configured default.
+     */
+    getDriverConfig(name) {
+        return getNotificationDriver(this, name);
     },
 };
-export default Object.freeze(notificationConfigObj);
+export const notificationConfig = Object.freeze(notificationConfigObj);
+export default notificationConfig;

package/src/config/storage.d.ts

@@ -17,6 +17,14 @@ export declare const storageConfig: Readonly<{
      * Get storage driver config
      */
     getDriver(this: StorageConfigRuntime): StorageDriverConfig;
+    /**
+     * Get a storage disk configuration by name.
+     *
+     * - When `name` is provided and not configured, this throws.
+     * - When `name` is omitted, it resolves the configured default with a backwards-compatible fallback.
+     * - Reserved name `default` aliases the configured default.
+     */
+    getDriverConfig(this: StorageConfigRuntime, name?: string): StorageDriverConfig;
     /**
      * Temporary file settings
      */

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

@@ -1 +1 @@
-{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/config/storage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EAEnB,cAAc,EACf,MAAM,cAAc,CAAC;AA4GtB,eAAO,MAAM,aAAa;IArDxB;;OAEG;sBACY,MAAM;IAIrB;;OAEG;sBACY,cAAc;IAI7B;;OAEG;oBACa,oBAAoB,GAAG,mBAAmB;IAI1D;;OAEG;mBACS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAO5C;;OAEG;sBACY;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAQtE;;OAEG;sBACY;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;EAQW,CAAC;AAE7D,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC"}
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/config/storage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmI9F,eAAO,MAAM,aAAa;IAhExB;;OAEG;sBACY,MAAM;IAIrB;;OAEG;sBACY,cAAc;IAI7B;;OAEG;oBACa,oBAAoB,GAAG,mBAAmB;IAI1D;;;;;;OAMG;0BACmB,oBAAoB,SAAS,MAAM,GAAG,mBAAmB;IAI/E;;OAEG;mBACS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAO5C;;OAEG;sBACY;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAQtE;;OAEG;sBACY;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;EAQW,CAAC;AAE7D,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC"}

package/src/config/storage.js

@@ -4,15 +4,26 @@
  * Sealed namespace for immutability
  */
 import { Env } from './env.js';
-const isStorageDriverName = (value, drivers) => {
-    return value in drivers;
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const hasOwn = (obj, key) => {
+    return Object.prototype.hasOwnProperty.call(obj, key);
 };
-const getStorageDriver = (config) => {
-    const driverName = config.default;
-    if (isStorageDriverName(driverName, config.drivers)) {
-        return config.drivers[driverName];
+const getStorageDriver = (config, name) => {
+    const selected = String(name ?? config.default).trim();
+    const diskName = selected === 'default' ? String(config.default).trim() : selected;
+    const isExplicitSelection = name !== undefined && String(name).trim().length > 0 && String(name).trim() !== 'default';
+    if (diskName !== '' && hasOwn(config.drivers, diskName)) {
+        const resolved = config.drivers[diskName];
+        if (resolved !== undefined)
+            return resolved;
     }
-    return config.drivers.local;
+    if (isExplicitSelection) {
+        throw ErrorFactory.createConfigError(`Storage disk not configured: ${diskName}`);
+    }
+    if (Object.keys(config.drivers ?? {}).length === 0) {
+        throw ErrorFactory.createConfigError('No storage disks are configured');
+    }
+    throw ErrorFactory.createConfigError(`Storage default disk not configured: ${diskName || '<empty>'}`);
 };
 const getDrivers = () => ({
     local: {
@@ -53,7 +64,7 @@ const storageConfigObj = {
      * Default storage driver (dynamic; tests may mutate process.env)
      */
     get default() {
-        return Env.get('STORAGE_DRIVER', 'local');
+        return Env.get('STORAGE_CONNECTION', Env.get('STORAGE_DRIVER', 'local')).trim().toLowerCase();
     },
     /**
      * Storage drivers configuration (dynamic; tests may mutate process.env)
@@ -67,6 +78,16 @@ const storageConfigObj = {
     getDriver() {
         return getStorageDriver(this);
     },
+    /**
+     * Get a storage disk configuration by name.
+     *
+     * - When `name` is provided and not configured, this throws.
+     * - When `name` is omitted, it resolves the configured default with a backwards-compatible fallback.
+     * - Reserved name `default` aliases the configured default.
+     */
+    getDriverConfig(name) {
+        return getStorageDriver(this, name);
+    },
     /**
      * Temporary file settings
      */