@zintrust/core 0.1.1 → 0.1.2

package/src/templates/project/basic/config/app.ts.tpl

@@ -6,6 +6,47 @@
 
 import { Env } from '@config/env';
 
+type ProcessLike = { env?: Record<string, string | undefined> };
+
+type Environment = 'development' | 'dev' | 'production' | 'prod' | 'pro' | 'testing' | 'test';
+type StartMode = 'development' | 'production' | 'testing';
+
+const getProcessLike = (): ProcessLike | undefined => {
+  return typeof process === 'undefined' ? undefined : (process as unknown as ProcessLike);
+};
+
+const readEnvString = (key: string, defaultValue: string = ''): string => {
+  const anyEnv = Env as unknown as { get?: unknown };
+  if (typeof anyEnv.get === 'function') {
+    return (anyEnv.get as (k: string, d?: string) => string)(key, defaultValue);
+  }
+
+  const proc = getProcessLike();
+  const raw = proc?.env?.[key];
+  return raw ?? defaultValue;
+};
+
+const readEnvInt = (key: string, defaultValue: number): number => {
+  const anyEnv = Env as unknown as { getInt?: unknown };
+  if (typeof anyEnv.getInt === 'function') {
+    return (anyEnv.getInt as (k: string, d?: number) => number)(key, defaultValue);
+  }
+
+  const raw = readEnvString(key, String(defaultValue));
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isNaN(parsed) ? defaultValue : parsed;
+};
+
+const readEnvBool = (key: string, defaultValue: boolean): boolean => {
+  const anyEnv = Env as unknown as { getBool?: unknown };
+  if (typeof anyEnv.getBool === 'function') {
+    return (anyEnv.getBool as (k: string, d?: boolean) => boolean)(key, defaultValue);
+  }
+
+  const raw = readEnvString(key, defaultValue ? 'true' : 'false');
+  return raw.toLowerCase() === 'true' || raw === '1';
+};
+
 const getSafeEnv = (): NodeJS.ProcessEnv => {
   const baseEnv: Partial<NodeJS.ProcessEnv> = typeof process === 'undefined' ? {} : process.env;
 
@@ -13,39 +54,64 @@ const getSafeEnv = (): NodeJS.ProcessEnv => {
     ...(baseEnv as NodeJS.ProcessEnv),
 
     // Ensure required keys exist (env.d.ts augments ProcessEnv with required fields)
-    NODE_ENV: baseEnv.NODE_ENV ?? (Env.NODE_ENV as NodeJS.ProcessEnv['NODE_ENV']),
-    USE_RAW_QRY: baseEnv.USE_RAW_QRY ?? (Env.get('USE_RAW_QRY') || undefined),
-    SERVICE_API_KEY: baseEnv.SERVICE_API_KEY ?? Env.get('SERVICE_API_KEY', ''),
-    SERVICE_JWT_SECRET: baseEnv.SERVICE_JWT_SECRET ?? Env.get('SERVICE_JWT_SECRET', ''),
-    BASE_URL: baseEnv.BASE_URL ?? Env.get('BASE_URL', ''),
-    MODE: baseEnv.MODE ?? Env.get('MODE', ''),
+    NODE_ENV:
+      baseEnv.NODE_ENV ??
+      (readEnvString('NODE_ENV', 'development') as NodeJS.ProcessEnv['NODE_ENV']),
+    USE_RAW_QRY: baseEnv.USE_RAW_QRY ?? (readEnvString('USE_RAW_QRY', '') || undefined),
+    SERVICE_API_KEY: baseEnv.SERVICE_API_KEY ?? readEnvString('SERVICE_API_KEY', ''),
+    SERVICE_JWT_SECRET: baseEnv.SERVICE_JWT_SECRET ?? readEnvString('SERVICE_JWT_SECRET', ''),
+    BASE_URL: baseEnv['BASE_URL'] ?? readEnvString('BASE_URL', ''),
+    MODE: baseEnv['MODE'] ?? readEnvString('MODE', ''),
 
     // Hardening for child-process usage
-    PATH: Env.SAFE_PATH,
+    PATH:
+      typeof (Env as unknown as { SAFE_PATH?: unknown }).SAFE_PATH === 'string'
+        ? (Env as unknown as { SAFE_PATH: string }).SAFE_PATH
+        : (baseEnv['PATH'] ?? ''),
     npm_config_scripts_prepend_node_path: 'true',
   };
 };
 
+const normalizeMode = (): StartMode => {
+  const value = (
+    typeof (Env as unknown as { NODE_ENV?: unknown }).NODE_ENV === 'string'
+      ? (Env as unknown as { NODE_ENV: string }).NODE_ENV
+      : readEnvString('NODE_ENV', 'development')
+  ) as Environment;
+  if (value === 'production' || value === 'pro' || value === 'prod') return 'production';
+  if (value === 'testing' || value === 'test') return 'testing';
+  return 'development';
+};
+
 const appConfigObj = {
   /**
    * Application name
    */
-  name: Env.APP_NAME,
+  name:
+    typeof (Env as unknown as { APP_NAME?: unknown }).APP_NAME === 'string'
+      ? (Env as unknown as { APP_NAME: string }).APP_NAME
+      : readEnvString('APP_NAME', 'ZinTrust'),
 
   /**
    * Application environment
    */
-  environment: Env.NODE_ENV as 'development' | 'production' | 'testing',
+  environment: normalizeMode(),
 
   /**
    * Application port
    */
-  port: Env.PORT,
+  port:
+    typeof (Env as unknown as { PORT?: unknown }).PORT === 'number'
+      ? (Env as unknown as { PORT: number }).PORT
+      : readEnvInt('APP_PORT', 3000),
 
   /**
    * Application host
    */
-  host: Env.HOST,
+  host:
+    typeof (Env as unknown as { HOST?: unknown }).HOST === 'string'
+      ? (Env as unknown as { HOST: string }).HOST
+      : readEnvString('HOST', 'localhost'),
 
   /**
    * Is development environment
@@ -71,22 +137,25 @@ const appConfigObj = {
   /**
    * Application debug mode
    */
-  debug: Env.DEBUG,
+  debug:
+    typeof (Env as unknown as { DEBUG?: unknown }).DEBUG === 'boolean'
+      ? (Env as unknown as { DEBUG: boolean }).DEBUG
+      : readEnvBool('DEBUG', false),
 
   /**
    * Application timezone
    */
-  timezone: Env.get('APP_TIMEZONE', 'UTC'),
+  timezone: readEnvString('APP_TIMEZONE', 'UTC'),
 
   /**
    * Request timeout (milliseconds)
    */
-  requestTimeout: Env.getInt('REQUEST_TIMEOUT', 30000),
+  requestTimeout: readEnvInt('REQUEST_TIMEOUT', 30000),
 
   /**
    * Max request body size
    */
-  maxBodySize: Env.get('MAX_BODY_SIZE', '10mb'),
+  maxBodySize: readEnvString('MAX_BODY_SIZE', '10mb'),
 
   getSafeEnv,
 } as const;

package/src/templates/project/basic/config/broadcast.ts.tpl

@@ -0,0 +1,97 @@
+/**
+ * Broadcast Configuration
+ *
+ * Centralizes broadcast driver selection and provider env mappings.
+ * Driver selection must be dynamic (tests may mutate process.env).
+ */
+
+import { Env } from '@config/env';
+
+export type KnownBroadcastDriverName = 'inmemory' | 'pusher' | 'redis' | 'redishttps';
+
+export type InMemoryBroadcastDriverConfig = {
+  driver: 'inmemory';
+};
+
+export type PusherBroadcastDriverConfig = {
+  driver: 'pusher';
+  appId: string;
+  key: string;
+  secret: string;
+  cluster: string;
+  useTLS: boolean;
+};
+
+export type RedisBroadcastDriverConfig = {
+  driver: 'redis';
+  host: string;
+  port: number;
+  password: string;
+  channelPrefix: string;
+};
+
+export type RedisHttpsBroadcastDriverConfig = {
+  driver: 'redishttps';
+  endpoint: string;
+  token: string;
+  channelPrefix: string;
+};
+
+export type KnownBroadcastDriverConfig =
+  | InMemoryBroadcastDriverConfig
+  | PusherBroadcastDriverConfig
+  | RedisBroadcastDriverConfig
+  | RedisHttpsBroadcastDriverConfig;
+
+const normalizeDriverName = (value: string): string => value.trim().toLowerCase();
+
+const getPusherConfig = (): PusherBroadcastDriverConfig => ({
+  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),
+});
+
+const getRedisConfig = (): RedisBroadcastDriverConfig => ({
+  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:'),
+});
+
+const getRedisHttpsConfig = (): RedisHttpsBroadcastDriverConfig => ({
+  driver: 'redishttps',
+  endpoint: Env.get('REDIS_HTTPS_ENDPOINT', ''),
+  token: Env.get('REDIS_HTTPS_TOKEN', ''),
+  channelPrefix: Env.get('BROADCAST_CHANNEL_PREFIX', 'broadcast:'),
+});
+
+const broadcastConfigObj = {
+  /**
+   * Normalized broadcast driver name.
+   *
+   * NOTE: Allows custom driver names (project-specific drivers), so returns string.
+   */
+  getDriverName(): string {
+    return normalizeDriverName(Env.get('BROADCAST_DRIVER', 'inmemory'));
+  },
+
+  /**
+   * Get a config object for the currently selected driver.
+   * Defaults to inmemory for unknown/unsupported names.
+   */
+  getDriverConfig(): KnownBroadcastDriverConfig {
+    const driver = this.getDriverName();
+
+    if (driver === 'pusher') return getPusherConfig();
+    if (driver === 'redis') return getRedisConfig();
+    if (driver === 'redishttps') return getRedisHttpsConfig();
+
+    return { driver: 'inmemory' };
+  },
+} as const;
+
+export default Object.freeze(broadcastConfigObj);

package/src/templates/project/basic/config/cache.ts.tpl

@@ -15,34 +15,32 @@ type RedisCacheDriverConfig = {
   driver: 'redis';
   host: string;
   port: number;
-  password: string | undefined;
-  database: number;
   ttl: number;
 };
 
-type MemcachedCacheDriverConfig = {
-  driver: 'memcached';
-  servers: string[];
+type MongoCacheDriverConfig = {
+  driver: 'mongodb';
+  uri: string;
+  db: string;
   ttl: number;
 };
 
-type FileCacheDriverConfig = {
-  driver: 'file';
-  path: string;
+type KvCacheDriverConfig = {
+  driver: 'kv';
   ttl: number;
 };
 
 type CacheDriverConfig =
   | MemoryCacheDriverConfig
   | RedisCacheDriverConfig
-  | MemcachedCacheDriverConfig
-  | FileCacheDriverConfig;
+  | MongoCacheDriverConfig
+  | KvCacheDriverConfig;
 
 type CacheDrivers = {
   memory: MemoryCacheDriverConfig;
   redis: RedisCacheDriverConfig;
-  memcached: MemcachedCacheDriverConfig;
-  file: FileCacheDriverConfig;
+  mongodb: MongoCacheDriverConfig;
+  kv: KvCacheDriverConfig;
 };
 
 type CacheConfigInput = {
@@ -53,7 +51,7 @@ type CacheConfigInput = {
 const getCacheDriver = (config: CacheConfigInput): CacheDriverConfig => {
   const defaultDriver = config.default;
 
-  if (Object.prototype.hasOwnProperty.call(config.drivers, defaultDriver)) {
+  if (Object.hasOwn(config.drivers, defaultDriver)) {
     const driverName = defaultDriver as keyof CacheDrivers;
     return config.drivers[driverName];
   }
@@ -79,19 +77,17 @@ const cacheConfigObj = {
       driver: 'redis' as const,
       host: Env.get('REDIS_HOST', 'localhost'),
       port: Env.getInt('REDIS_PORT', 6379),
-      password: Env.get('REDIS_PASSWORD'),
-      database: Env.getInt('REDIS_DB', 0),
       ttl: Env.getInt('CACHE_REDIS_TTL', 3600),
     },
-    memcached: {
-      driver: 'memcached' as const,
-      servers: Env.get('MEMCACHED_SERVERS', 'localhost:11211').split(','),
-      ttl: Env.getInt('CACHE_MEMCACHED_TTL', 3600),
+    mongodb: {
+      driver: 'mongodb' as const,
+      uri: Env.get('MONGO_URI'),
+      db: Env.get('MONGO_DB', 'zintrust_cache'),
+      ttl: Env.getInt('CACHE_MONGO_TTL', 3600),
     },
-    file: {
-      driver: 'file' as const,
-      path: Env.get('CACHE_FILE_PATH', 'storage/cache'),
-      ttl: Env.getInt('CACHE_FILE_TTL', 3600),
+    kv: {
+      driver: 'kv' as const,
+      ttl: Env.getInt('CACHE_KV_TTL', 3600),
     },
   },
 

package/src/templates/project/basic/config/cloudflare.ts.tpl

@@ -0,0 +1,57 @@
+/**
+ * Cloudflare Workers Environment Access
+ *
+ * Centralizes access to Workers bindings via globalThis.env.
+ * This keeps runtime-specific globals out of adapters/drivers.
+ */
+
+import type { DatabaseConfig, ID1Database } from '@orm/DatabaseAdapter';
+
+export type WorkersEnv = Record<string, unknown>;
+
+type KVNamespace = {
+  get(
+    key: string,
+    options?: { type: 'text' | 'json' | 'arrayBuffer' | 'stream' }
+  ): Promise<unknown>;
+  put(
+    key: string,
+    value: string | ReadableStream | ArrayBuffer | FormData,
+    options?: { expiration?: number; expirationTtl?: number; metadata?: unknown }
+  ): Promise<void>;
+  delete(key: string): Promise<void>;
+};
+
+const getWorkersEnv = (): WorkersEnv | null => {
+  const env = (globalThis as unknown as { env?: unknown }).env;
+  if (env === undefined || env === null) return null;
+  if (typeof env !== 'object') return null;
+  return env as WorkersEnv;
+};
+
+const getD1Binding = (config: DatabaseConfig): ID1Database | null => {
+  if (config.d1 !== undefined && config.d1 !== null) return config.d1;
+
+  const env = getWorkersEnv();
+  const envDb = env === null ? undefined : (env['DB'] as ID1Database | undefined);
+  if (envDb !== undefined) return envDb;
+
+  const globalDb = (globalThis as unknown as { DB?: ID1Database }).DB;
+  if (globalDb !== undefined) return globalDb;
+
+  return null;
+};
+
+const getKVBinding = (bindingName = 'CACHE'): KVNamespace | null => {
+  const env = getWorkersEnv();
+  if (env === null) return null;
+
+  const kv = env[bindingName] as KVNamespace | undefined;
+  return kv ?? null;
+};
+
+export const Cloudflare = Object.freeze({
+  getWorkersEnv,
+  getD1Binding,
+  getKVBinding,
+});

package/src/templates/project/basic/config/env.ts.tpl

@@ -71,7 +71,7 @@ export const Env = Object.freeze({
   DB_CONNECTION: get('DB_CONNECTION', 'sqlite'),
   DB_HOST: get('DB_HOST', 'localhost'),
   DB_PORT: getInt('DB_PORT', 5432),
-  DB_DATABASE: get('DB_DATABASE', '@zintrust/core'),
+  DB_DATABASE: get('DB_DATABASE', 'zintrust'),
   DB_USERNAME: get('DB_USERNAME', 'postgres'),
   DB_PASSWORD: get('DB_PASSWORD', ''),
   DB_READ_HOSTS: get('DB_READ_HOSTS', ''),
@@ -114,10 +114,16 @@ export const Env = Object.freeze({
   ENVIRONMENT: get('ENVIRONMENT', 'development'),
   REQUEST_TIMEOUT: getInt('REQUEST_TIMEOUT', 30000),
   MAX_BODY_SIZE: getInt('MAX_BODY_SIZE', 10485760),
+  SHUTDOWN_TIMEOUT: getInt('SHUTDOWN_TIMEOUT', 10000),
 
   // Logging
   LOG_LEVEL: get('LOG_LEVEL', getDefaultLogLevel()) as 'debug' | 'info' | 'warn' | 'error',
+  LOG_FORMAT: get('LOG_FORMAT', 'text'),
   DISABLE_LOGGING: getBool('DISABLE_LOGGING', false),
+  LOG_HTTP_REQUEST: getBool('LOG_HTTP_REQUEST', false),
+  LOG_TO_FILE: getBool('LOG_TO_FILE', false),
+  LOG_ROTATION_SIZE: getInt('LOG_ROTATION_SIZE', 10485760),
+  LOG_ROTATION_DAYS: getInt('LOG_ROTATION_DAYS', 7),
 
   // Paths (safely constructed for Node.js environments)
   NODE_BIN_DIR: (() => {

package/src/templates/project/basic/config/index.ts.tpl

@@ -7,6 +7,7 @@ import { appConfig } from '@config/app';
 import { cacheConfig } from '@config/cache';
 import { databaseConfig } from '@config/database';
 import { microservicesConfig } from '@config/microservices';
+import { middlewareConfig } from '@config/middleware';
 import { queueConfig } from '@config/queue';
 import { securityConfig } from '@config/security';
 import { storageConfig } from '@config/storage';
@@ -15,6 +16,7 @@ export { appConfig, type AppConfig } from '@config/app';
 export { cacheConfig, type CacheConfig } from '@config/cache';
 export { databaseConfig, type DatabaseConfig } from '@config/database';
 export { microservicesConfig, type MicroservicesConfig } from '@config/microservices';
+export { middlewareConfig, type MiddlewareConfig } from '@config/middleware';
 export { queueConfig, type QueueConfig } from '@config/queue';
 export { securityConfig } from '@config/security';
 export { storageConfig, type StorageConfig } from '@config/storage';
@@ -28,6 +30,7 @@ export const config = Object.freeze({
   database: databaseConfig,
   storage: storageConfig,
   security: securityConfig,
+  middleware: middlewareConfig,
   microservices: microservicesConfig,
   cache: cacheConfig,
   queue: queueConfig,