@zintrust/core 0.4.26 → 0.4.28

package/config/broadcast.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Broadcast 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: {
+        inmemory: {
+            driver: "inmemory";
+        };
+        pusher: {
+            driver: "pusher";
+            appId: string;
+            key: string;
+            secret: string;
+            cluster: string;
+            useTLS: boolean;
+        };
+        redis: {
+            driver: "redis";
+            host: string;
+            port: number;
+            password: string;
+            channelPrefix: string;
+        };
+        redishttps: {
+            driver: "redishttps";
+            endpoint: string;
+            token: string;
+            channelPrefix: string;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=broadcast.d.ts.map

package/config/broadcast.d.ts.map

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

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,21 @@
+import type { MiddlewaresType } from '../src/config/middleware';
+/**
+ * Middleware Configuration (template)
+ *
+ * Full project middleware flow:
+ * 1. Create `app/Middleware/YourMiddleware.ts` and export a `Middleware` function.
+ * 2. Import it below.
+ * 3. Register route middleware under `route` or append global middleware under `global`.
+ * 4. Use the route key in `routes/*.ts`.
+ *
+ * Built-in middleware keys are overrideable by reusing the same key under `route`.
+ * For example, `route.jwt = MyJwtMiddleware` replaces the framework `jwt` middleware
+ * anywhere that key is used, including shared global slots such as `log`, `error`,
+ * `security`, `rateLimit`, `csrf`, and `sanitizeBody`.
+ *
+ * For custom route keys, extend the framework type locally in your route file:
+ * `type AppMiddlewareKey = MiddlewareKey | 'yourMiddleware';`
+ */
+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;;;;;;;;;;;;;;;;GAgBG;wBA4CE,eAAe;AArCpB,wBAqCqB"}

package/config/middleware.js

@@ -0,0 +1,61 @@
+// @ts-ignore - config templates are excluded from the main TS project in this repo
+import { Env } from '../src/config/env.js';
+/**
+ * Middleware Configuration (template)
+ *
+ * Full project middleware flow:
+ * 1. Create `app/Middleware/YourMiddleware.ts` and export a `Middleware` function.
+ * 2. Import it below.
+ * 3. Register route middleware under `route` or append global middleware under `global`.
+ * 4. Use the route key in `routes/*.ts`.
+ *
+ * Built-in middleware keys are overrideable by reusing the same key under `route`.
+ * For example, `route.jwt = MyJwtMiddleware` replaces the framework `jwt` middleware
+ * anywhere that key is used, including shared global slots such as `log`, `error`,
+ * `security`, `rateLimit`, `csrf`, and `sanitizeBody`.
+ *
+ * For custom route keys, extend the framework type locally in your route file:
+ * `type AppMiddlewareKey = MiddlewareKey | 'yourMiddleware';`
+ */
+// Example custom middleware import:
+// import { AuthMiddleware } from '@app/Middleware/AuthMiddleware';
+// import { authFailureResponder } from '../app/Middleware/AuthFailureResponder';
+// import { JwtAuthOverrideMiddleware } from '@app/Middleware/JwtAuthOverrideMiddleware';
+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.',
+    },
+    responders: {
+    // auth: authFailureResponder,
+    // jwt: authFailureResponder,
+    // bulletproof: authFailureResponder,
+    // csrf: authFailureResponder,
+    // rateLimit: authFailureResponder,
+    // error: authFailureResponder,
+    },
+    global: [
+    // AuthMiddleware,
+    ],
+    route: {
+    // authMiddleware: AuthMiddleware,
+    // Plug-and-play built-in override example:
+    // jwt: JwtAuthOverrideMiddleware,
+    // log: RequestLogOverrideMiddleware,
+    },
+};

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"}