@zintrust/core 0.1.41 → 0.1.43

package/config/broadcast.js

@@ -0,0 +1,37 @@
+import { Env } from '../src/config/env.js';
+/**
+ * Broadcast Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+export default {
+    default: Env.get('BROADCAST_CONNECTION', Env.get('BROADCAST_DRIVER', 'inmemory')),
+    drivers: {
+        inmemory: {
+            driver: 'inmemory',
+        },
+        pusher: {
+            driver: 'pusher',
+            appId: Env.get('PUSHER_APP_ID', ''),
+            key: Env.get('PUSHER_APP_KEY', ''),
+            secret: Env.get('PUSHER_APP_SECRET', ''),
+            cluster: Env.get('PUSHER_APP_CLUSTER', ''),
+            useTLS: Env.getBool('PUSHER_USE_TLS', true),
+        },
+        redis: {
+            driver: 'redis',
+            host: Env.get('BROADCAST_REDIS_HOST', Env.get('REDIS_HOST', 'localhost')),
+            port: Env.getInt('BROADCAST_REDIS_PORT', Env.getInt('REDIS_PORT', 6379)),
+            password: Env.get('BROADCAST_REDIS_PASSWORD', Env.get('REDIS_PASSWORD', '')),
+            channelPrefix: Env.get('BROADCAST_CHANNEL_PREFIX', 'broadcast:'),
+        },
+        redishttps: {
+            driver: 'redishttps',
+            endpoint: Env.get('REDIS_HTTPS_ENDPOINT', ''),
+            token: Env.get('REDIS_HTTPS_TOKEN', ''),
+            channelPrefix: Env.get('BROADCAST_CHANNEL_PREFIX', 'broadcast:'),
+        },
+    },
+};

package/config/cache.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Cache Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+declare const _default: {
+    default: string;
+    drivers: {
+        memory: {
+            driver: "memory";
+            ttl: number;
+        };
+        redis: {
+            driver: "redis";
+            host: string;
+            port: number;
+            ttl: number;
+        };
+        mongodb: {
+            driver: "mongodb";
+            uri: string;
+            db: string;
+            ttl: number;
+        };
+        kv: {
+            driver: "kv";
+            ttl: number;
+        };
+        'kv-remote': {
+            driver: "kv-remote";
+            ttl: number;
+        };
+    };
+    keyPrefix: string;
+    ttl: number;
+};
+export default _default;
+//# sourceMappingURL=cache.d.ts.map

package/config/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../config/cache.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,wBA8BiC"}

package/config/cache.js

@@ -0,0 +1,39 @@
+import { Env } from '../src/config/env.js';
+/**
+ * Cache Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+export default {
+    default: Env.get('CACHE_CONNECTION', Env.get('CACHE_DRIVER', 'memory')).trim().toLowerCase(),
+    drivers: {
+        memory: {
+            driver: 'memory',
+            ttl: Env.getInt('CACHE_MEMORY_TTL', 3600),
+        },
+        redis: {
+            driver: 'redis',
+            host: Env.get('REDIS_HOST', 'localhost'),
+            port: Env.getInt('REDIS_PORT', 6379),
+            ttl: Env.getInt('CACHE_REDIS_TTL', 3600),
+        },
+        mongodb: {
+            driver: 'mongodb',
+            uri: Env.get('MONGO_URI', ''),
+            db: Env.get('MONGO_DB', 'zintrust_cache'),
+            ttl: Env.getInt('CACHE_MONGO_TTL', 3600),
+        },
+        kv: {
+            driver: 'kv',
+            ttl: Env.getInt('CACHE_KV_TTL', 3600),
+        },
+        'kv-remote': {
+            driver: 'kv-remote',
+            ttl: Env.getInt('CACHE_KV_TTL', 3600),
+        },
+    },
+    keyPrefix: Env.get('CACHE_KEY_PREFIX', 'zintrust:'),
+    ttl: Env.getInt('CACHE_TTL', 3600),
+};

package/config/database.d.ts

@@ -0,0 +1,58 @@
+declare const _default: {
+    default: string;
+    connections: {
+        sqlite: {
+            driver: "sqlite";
+            database: string;
+            migrations: string;
+        };
+        d1: {
+            driver: "d1";
+        };
+        'd1-remote': {
+            driver: "d1-remote";
+        };
+        postgresql: {
+            driver: "postgresql";
+            host: string;
+            port: number;
+            database: string;
+            username: string;
+            password: string;
+            ssl: boolean;
+            readHosts: string[] | undefined;
+            pooling: {
+                enabled: boolean;
+                min: number;
+                max: number;
+                idleTimeout: number;
+                connectionTimeout: number;
+            };
+        };
+        mysql: {
+            driver: "mysql";
+            host: string;
+            port: number;
+            database: string;
+            username: string;
+            password: string;
+            readHosts: string[] | undefined;
+            pooling: {
+                enabled: boolean;
+                min: number;
+                max: number;
+            };
+        };
+        sqlserver: {
+            driver: "sqlserver";
+            host: string;
+            port: number;
+            database: string;
+            username: string;
+            password: string;
+            readHosts: string[] | undefined;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=database.d.ts.map

package/config/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../config/database.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,wBAGoC"}

package/config/database.js

@@ -0,0 +1,65 @@
+import { Env } from '../src/config/env.js';
+const parseReadHosts = (raw) => {
+    const list = String(raw ?? '')
+        .split(',')
+        .map((v) => v.trim())
+        .filter((v) => v.length > 0);
+    return list.length > 0 ? list : undefined;
+};
+const connections = {
+    sqlite: {
+        driver: 'sqlite',
+        database: Env.get('DB_DATABASE_SQLITE', '.zintrust/dbs/zintrust.sqlite'),
+        migrations: 'database/migrations',
+    },
+    d1: {
+        driver: 'd1',
+    },
+    'd1-remote': {
+        driver: 'd1-remote',
+    },
+    postgresql: {
+        driver: 'postgresql',
+        host: Env.get('DB_HOST', 'localhost'),
+        port: Env.getInt('DB_PORT_POSTGRESQL', 5432),
+        database: Env.get('DB_DATABASE_POSTGRESQL', 'postgres'),
+        username: Env.get('DB_USERNAME_POSTGRESQL', 'postgres'),
+        password: Env.get('DB_PASSWORD_POSTGRESQL', 'pass'),
+        ssl: Env.getBool('DB_SSL', false),
+        readHosts: parseReadHosts(Env.get('DB_READ_HOSTS_POSTGRESQL', '127.0.0.1')),
+        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.get('DB_HOST', 'localhost'),
+        port: Env.getInt('DB_PORT', 3306),
+        database: Env.get('DB_DATABASE', 'zintrust'),
+        username: Env.get('DB_USERNAME', 'root'),
+        password: Env.get('DB_PASSWORD', 'pass'),
+        readHosts: parseReadHosts(Env.get('DB_READ_HOSTS', '127.0.0.1')),
+        pooling: {
+            enabled: Env.getBool('DB_POOLING', true),
+            min: Env.getInt('DB_POOL_MIN', 5),
+            max: Env.getInt('DB_POOL_MAX', 20),
+        },
+    },
+    sqlserver: {
+        driver: 'sqlserver',
+        host: Env.get('DB_HOST_MSSQL', Env.get('DB_HOST', 'localhost')),
+        port: Env.getInt('DB_PORT_MSSQL', 1433),
+        database: Env.get('DB_DATABASE_MSSQL', 'zintrust'),
+        username: Env.get('DB_USERNAME_MSSQL', 'sa'),
+        password: Env.get('DB_PASSWORD_MSSQL', 'pass'),
+        readHosts: parseReadHosts(Env.get('DB_READ_HOSTS_MSSQL', '127.0.0.1')),
+    },
+};
+export default {
+    default: Env.get('DB_CONNECTION', 'mysql'),
+    connections,
+};

package/config/mail.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Mail Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+declare const _default: {
+    default: string;
+    from: {
+        address: string;
+        name: string;
+    };
+    drivers: {
+        disabled: {
+            driver: "disabled";
+        };
+        sendgrid: {
+            driver: "sendgrid";
+            apiKey: string;
+        };
+        mailgun: {
+            driver: "mailgun";
+            apiKey: string;
+            domain: string;
+            baseUrl: string;
+        };
+        smtp: {
+            driver: "smtp";
+            host: string;
+            port: number;
+            username: string;
+            password: string;
+            secure: boolean | "starttls";
+        };
+        nodemailer: {
+            driver: "nodemailer";
+            host: string;
+            port: number;
+            username: string;
+            password: string;
+            secure: boolean | "starttls";
+        };
+        ses: {
+            driver: "ses";
+            region: string;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=mail.d.ts.map

package/config/mail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mail.d.ts","sourceRoot":"","sources":["../../config/mail.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,wBAqDgC"}

package/config/mail.js

@@ -0,0 +1,69 @@
+// @ts-ignore - config templates are excluded from the main TS project in this repo
+import { Env } from '../src/config/env.js';
+/**
+ * Mail Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+export default {
+    default: Env.get('MAIL_CONNECTION', Env.get('MAIL_DRIVER', 'smtp')).trim().toLowerCase(),
+    from: {
+        address: Env.get('MAIL_FROM_ADDRESS', ''),
+        name: Env.get('MAIL_FROM_NAME', 'ZinTrust Framework'),
+    },
+    drivers: {
+        disabled: {
+            driver: 'disabled',
+        },
+        sendgrid: {
+            driver: 'sendgrid',
+            apiKey: Env.get('SENDGRID_API_KEY', ''),
+        },
+        mailgun: {
+            driver: 'mailgun',
+            apiKey: Env.get('MAILGUN_API_KEY', ''),
+            domain: Env.get('MAILGUN_DOMAIN', ''),
+            baseUrl: Env.get('MAILGUN_BASE_URL', 'https://api.mailgun.net').trim(),
+        },
+        smtp: {
+            driver: 'smtp',
+            host: Env.get('MAIL_HOST', ''),
+            port: Env.getInt('MAIL_PORT', 587),
+            username: Env.get('MAIL_USERNAME', ''),
+            password: Env.get('MAIL_PASSWORD', ''),
+            secure: (() => {
+                const raw = Env.get('MAIL_SECURE', '').trim().toLowerCase();
+                if (raw === 'starttls')
+                    return 'starttls';
+                if (raw === 'tls' || raw === 'ssl' || raw === 'smtps' || raw === 'implicit')
+                    return true;
+                if (raw === 'none' || raw === 'off' || raw === 'false' || raw === '0')
+                    return false;
+                return Env.getBool('MAIL_SECURE', false);
+            })(),
+        },
+        nodemailer: {
+            driver: 'nodemailer',
+            host: Env.get('MAIL_HOST', ''),
+            port: Env.getInt('MAIL_PORT', 587),
+            username: Env.get('MAIL_USERNAME', ''),
+            password: Env.get('MAIL_PASSWORD', ''),
+            secure: (() => {
+                const raw = Env.get('MAIL_SECURE', '').trim().toLowerCase();
+                if (raw === 'starttls')
+                    return 'starttls';
+                if (raw === 'tls' || raw === 'ssl' || raw === 'smtps' || raw === 'implicit')
+                    return true;
+                if (raw === 'none' || raw === 'off' || raw === 'false' || raw === '0')
+                    return false;
+                return Env.getBool('MAIL_SECURE', false);
+            })(),
+        },
+        ses: {
+            driver: 'ses',
+            region: Env.get('AWS_REGION', 'us-east-1'),
+        },
+    },
+};

package/config/middleware.d.ts

@@ -0,0 +1,11 @@
+import type { MiddlewaresType } from '../src/config/middleware';
+/**
+ * Middleware Configuration (template)
+ *
+ * Keep this file declarative:
+ * - Core owns middleware construction / any runtime behavior.
+ * - Projects can override by editing `middlewareConfigObj`.
+ */
+declare const _default: MiddlewaresType;
+export default _default;
+//# sourceMappingURL=middleware.d.ts.map

package/config/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../config/middleware.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D;;;;;;GAMG;wBAsBE,eAAe;AApBpB,wBAoBqB"}

package/config/middleware.js

@@ -0,0 +1,30 @@
+// @ts-ignore - config templates are excluded from the main TS project in this repo
+import { Env } from '../src/config/env.js';
+/**
+ * Middleware Configuration (template)
+ *
+ * Keep this file declarative:
+ * - Core owns middleware construction / any runtime behavior.
+ * - Projects can override by editing `middlewareConfigObj`.
+ */
+export default {
+    skipPaths: Env.get('CSRF_SKIP_PATHS', '')
+        .split(',')
+        .map((m) => m.trim())
+        .filter((m) => m.length > 0),
+    fillRateLimit: {
+        windowMs: 60_000,
+        max: 5,
+        message: 'Too many fill requests, please try again later.',
+    },
+    authRateLimit: {
+        windowMs: 60_000,
+        max: 4,
+        message: 'Too many authentication attempts, please try again later.',
+    },
+    userMutationRateLimit: {
+        windowMs: 60_000,
+        max: 20,
+        message: 'Too many user mutation requests, please try again later.',
+    },
+};

package/config/notification.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Notification Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+declare const _default: {
+    default: string;
+    drivers: {
+        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;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=notification.d.ts.map

package/config/notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.d.ts","sourceRoot":"","sources":["../../config/notification.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,wBAuBwC"}

package/config/notification.js

@@ -0,0 +1,33 @@
+// @ts-ignore - config templates are excluded from the main TS project in this repo
+import { Env } from '../src/config/env.js';
+/**
+ * Notification Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ */
+export default {
+    default: Env.get('NOTIFICATION_CONNECTION', Env.get('NOTIFICATION_DRIVER', 'console')),
+    drivers: {
+        console: {
+            driver: 'console',
+        },
+        termii: {
+            driver: 'termii',
+            apiKey: Env.get('TERMII_API_KEY', ''),
+            sender: Env.get('TERMII_SENDER', 'Zintrust'),
+            endpoint: Env.get('TERMII_ENDPOINT', 'https://api.termii.com/sms/send'),
+        },
+        twilio: {
+            driver: 'twilio',
+            accountSid: Env.get('TWILIO_ACCOUNT_SID', ''),
+            authToken: Env.get('TWILIO_AUTH_TOKEN', ''),
+            fromNumber: Env.get('TWILIO_FROM_NUMBER', ''),
+        },
+        slack: {
+            driver: 'slack',
+            webhookUrl: Env.get('SLACK_WEBHOOK_URL', ''),
+        },
+    },
+};

package/config/queue.d.ts

@@ -0,0 +1,55 @@
+import type { QueueDriverName } from '../src/config/type';
+declare const _default: {
+    default: QueueDriverName;
+    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;
+        };
+    };
+    failed: {
+        database: string;
+        table: string;
+    };
+    processing: {
+        timeout: number;
+        retries: number;
+        backoff: number;
+        workers: number;
+    };
+    monitor: {
+        enabled: boolean;
+        basePath: string;
+        middleware: ReadonlyArray<string>;
+        autoRefresh: boolean;
+        refreshIntervalMs: number;
+    };
+};
+export default _default;
+//# sourceMappingURL=queue.d.ts.map

package/config/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../config/queue.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;;aAGN,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAuDf,aAAa,CAAC,MAAM,CAAC;;;;;AAxDnE,wBA4DiC"}

package/config/queue.js

@@ -0,0 +1,87 @@
+/**
+ * Queue Configuration (default override)
+ *
+ * Keep this file declarative:
+ * - Core owns env parsing/default logic.
+ * - Projects can override config by editing values below.
+ *
+ * BullMQ Redis Driver Environment Variables:
+ * When QUEUE_DRIVER=redis, the system uses BullMQ for enterprise features.
+ * Additional BullMQ-specific settings can be configured via environment variables:
+ *
+ * | Environment Variable | Default | Description | Example |
+ * |---------------------|---------|-------------|---------|
+ * | BULLMQ_REMOVE_ON_COMPLETE | 100 | Number of completed jobs to keep in Redis | 200 |
+ * | BULLMQ_REMOVE_ON_FAIL | 50 | Number of failed jobs to keep in Redis | 25 |
+ * | BULLMQ_DEFAULT_ATTEMPTS | 3 | Default retry attempts for jobs | 5 |
+ * | BULLMQ_BACKOFF_DELAY | 2000 | Delay between retries (milliseconds) | 5000 |
+ * | BULLMQ_BACKOFF_TYPE | exponential | Backoff strategy: 'exponential', 'fixed', 'custom' | fixed |
+ *
+ * Usage Examples:
+ * Development: BULLMQ_REMOVE_ON_COMPLETE=500 BULLMQ_DEFAULT_ATTEMPTS=2
+ * Production: BULLMQ_REMOVE_ON_COMPLETE=50 BULLMQ_DEFAULT_ATTEMPTS=5
+ * High-Volume: BULLMQ_REMOVE_ON_COMPLETE=10 BULLMQ_BACKOFF_DELAY=500
+ */
+// @ts-ignore - config templates are excluded from the main TS project in this repo
+import { Env } from '../src/config/env.js';
+export default {
+    default: Env.get('QUEUE_DRIVER', 'sync'),
+    drivers: {
+        sync: {
+            driver: 'sync',
+        },
+        database: {
+            driver: 'database',
+            table: Env.get('QUEUE_TABLE', 'jobs'),
+            connection: Env.get('QUEUE_DB_CONNECTION', 'default'),
+        },
+        redis: {
+            driver: 'redis',
+            host: Env.getBool('USE_REDIS_PROXY', false)
+                ? Env.get('REDIS_PROXY_HOST', Env.get('REDIS_HOST', 'localhost'))
+                : Env.get('REDIS_HOST', 'localhost'),
+            port: Env.getBool('USE_REDIS_PROXY', false)
+                ? Env.getInt('REDIS_PROXY_PORT', Env.getInt('REDIS_PORT', 6379))
+                : Env.getInt('REDIS_PORT', 6379),
+            password: Env.get('REDIS_PASSWORD'),
+            database: Env.getInt('REDIS_QUEUE_DB', 1),
+            // Note: Redis driver uses BullMQ for enterprise features
+            // See BullMQ environment variables in file header for customization
+        },
+        rabbitmq: {
+            driver: 'rabbitmq',
+            host: Env.get('RABBITMQ_HOST', 'localhost'),
+            port: Env.getInt('RABBITMQ_PORT', 5672),
+            username: Env.get('RABBITMQ_USER', 'guest'),
+            password: Env.get('RABBITMQ_PASSWORD', 'guest'),
+            vhost: Env.get('RABBITMQ_VHOST', '/'),
+        },
+        sqs: {
+            driver: 'sqs',
+            key: Env.get('AWS_ACCESS_KEY_ID'),
+            secret: Env.get('AWS_SECRET_ACCESS_KEY'),
+            region: Env.AWS_REGION,
+            queueUrl: Env.get('AWS_SQS_QUEUE_URL'),
+        },
+    },
+    failed: {
+        database: Env.get('FAILED_JOBS_DB_CONNECTION', 'default'),
+        table: Env.get('FAILED_JOBS_TABLE', 'failed_jobs'),
+    },
+    processing: {
+        timeout: Env.getInt('QUEUE_JOB_TIMEOUT', 60),
+        retries: Env.getInt('QUEUE_JOB_RETRIES', 3),
+        backoff: Env.getInt('QUEUE_JOB_BACKOFF', 0),
+        workers: Env.getInt('QUEUE_WORKERS', 1),
+    },
+    monitor: {
+        enabled: Env.getBool('QUEUE_MONITOR_ENABLED', true),
+        basePath: Env.get('QUEUE_MONITOR_BASE_PATH', '/queue-monitor'),
+        middleware: Env.get('QUEUE_MONITOR_MIDDLEWARE')
+            .split(',')
+            .map((m) => m.trim())
+            .filter((m) => m.length > 0),
+        autoRefresh: Env.getBool('QUEUE_MONITOR_AUTO_REFRESH', true),
+        refreshIntervalMs: Env.getInt('QUEUE_MONITOR_REFRESH_MS', 5000),
+    },
+};