@zintrust/core 0.1.18 → 0.1.19

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

@@ -1,387 +1,11 @@
 /**
  * Logger utility - Central logging configuration
- * Sealed namespace pattern - all exports through Logger namespace
- * Replaces console.* calls throughout the codebase
+ *
+ * Starter projects should use the framework's core Logger.
+ * This keeps templates free of relative imports and ensures logging
+ * behaves consistently across runtimes.
  */
-import { appConfig } from './app';
-import { Env } from './env';
 
-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;
-}
-
-const isDevelopment = (): boolean => appConfig.isDevelopment();
-const isProduction = (): boolean => appConfig.isProduction();
-
-const getLogFormat = (): string => Env.get('LOG_FORMAT', 'text');
-const isJsonFormat = (value: unknown): value is 'json' => value === 'json';
-
-const SENSITIVE_FIELDS = new Set<string>([
-  'password',
-  'token',
-  'authorization',
-  'secret',
-  'apikey',
-  'api_key',
-  'jwt',
-  'bearer',
-]);
-
-const redactSensitiveData = (data: unknown): unknown => {
-  const seen = new WeakSet<object>();
-
-  const walk = (value: unknown): unknown => {
-    if (Array.isArray(value)) {
-      if (seen.has(value)) return '[Circular]';
-      seen.add(value);
-      return value.map((v) => walk(v));
-    }
-
-    if (typeof value === 'object' && value !== null) {
-      const asObj = value as Record<string, unknown>;
-      if (seen.has(asObj)) return '[Circular]';
-      seen.add(asObj);
-
-      const out: Record<string, unknown> = {};
-      for (const [key, inner] of Object.entries(asObj)) {
-        if (SENSITIVE_FIELDS.has(key.toLowerCase())) {
-          out[key] = '[REDACTED]';
-        } else {
-          out[key] = walk(inner);
-        }
-      }
-      return out;
-    }
-
-    return value;
-  };
-
-  return walk(data);
-};
-
-const safeStringify = (obj: unknown, indent: boolean = false): string => {
-  const seen = new WeakSet<object>();
-  return JSON.stringify(
-    obj,
-    (_key: string, value: unknown) => {
-      if (typeof value === 'object' && value !== null) {
-        const asObj = value;
-        if (seen.has(asObj)) return '[Circular]';
-        seen.add(asObj);
-      }
-      return value;
-    },
-    indent ? 2 : 0
-  );
-};
-
-type FileWriterModule = { FileLogWriter: { write: (line: string) => void } };
-
-let fileWriterPromise: Promise<FileWriterModule> | undefined;
-let fileWriter: FileWriterModule['FileLogWriter'] | undefined;
-
-const getFileWriter = (): void => {
-  if (fileWriter !== undefined) return;
-  if (fileWriterPromise !== undefined) return;
-  fileWriterPromise = import('./FileLogWriter')
-    .then((mod) => {
-      fileWriter = mod.FileLogWriter;
-      return mod;
-    })
-    .catch(() => {
-      fileWriterPromise = undefined;
-      return { FileLogWriter: { write: (_line: string) => undefined } };
-    });
-};
-
-const shouldLogToFile = (): boolean => {
-  // Prefer dynamic lookup so late-bound env (tests, some runtimes) is respected.
-  const channel = Env.get('LOG_CHANNEL', '').trim().toLowerCase();
-  const channelWantsFile = channel === 'file' || channel === 'all';
-  if (!Env.getBool('LOG_TO_FILE', false) && !channelWantsFile) return false;
-  if (typeof process === 'undefined') return false;
-  return true;
-};
-
-const buildFileLine = (params: {
-  formatted: string;
-  data?: unknown;
-  errorMessage?: string;
-}): string => {
-  if (isJsonFormat(getLogFormat())) return params.formatted;
-
-  let line = params.formatted;
-  if (typeof params.errorMessage === 'string' && params.errorMessage.length > 0) {
-    line = `${line} ${params.errorMessage}`;
-  } else if (params.data !== undefined && params.data !== '') {
-    line = `${line} ${safeStringify(redactSensitiveData(params.data))}`;
-  }
-  return line;
-};
-
-const writeToFile = (line: string): void => {
-  if (!shouldLogToFile()) return;
-
-  if (fileWriter !== undefined) {
-    fileWriter.write(line);
-    return;
-  }
-
-  getFileWriter();
-  fileWriterPromise?.then((mod) => mod.FileLogWriter.write(line));
-};
-
-const formatLogMessage = (params: {
-  level: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
-  message: string;
-  data?: unknown;
-  category?: string;
-  errorMessage?: string;
-}): string => {
-  if (isJsonFormat(getLogFormat())) {
-    return safeStringify({
-      timestamp: new Date().toISOString(),
-      level: params.level,
-      message: params.message,
-      category: params.category,
-      data: redactSensitiveData(params.data),
-      error: params.errorMessage,
-    });
-  }
-
-  // text format
-  return `[${params.level.toUpperCase()}] ${params.message}`;
-};
-
-/**
- * Helper to extract error message from unknown error type
- */
-const getErrorMessage = (error?: unknown): string => {
-  if (error === undefined) {
-    return '';
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-
-  if (typeof error === 'string') return error;
-  if (typeof error === 'number' || typeof error === 'bigint') return error.toString();
-  if (typeof error === 'boolean') return error ? 'true' : 'false';
-  if (typeof error === 'symbol') return error.toString();
-  if (typeof error === 'function') return '[Function]';
-
-  try {
-    return safeStringify(error);
-  } catch {
-    return '[Unserializable error]';
-  }
-};
-
-type CloudLogEvent = {
-  timestamp: string;
-  level: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
-  message: string;
-  category?: string;
-  data?: unknown;
-  error?: string;
-};
-
-const emitCloudLogs = (event: CloudLogEvent): void => {
-  // Lazy-load to avoid cycles and avoid cost when disabled.
-  void (async (): Promise<void> => {
-    try {
-      if (event.level === 'error' || event.level === 'fatal') {
-        const mod = await import('./logging/KvLogger');
-        void mod.KvLogger.enqueue(event);
-      }
-    } catch {
-      // best-effort
-    }
-
-    try {
-      if (event.level === 'warn' || event.level === 'error' || event.level === 'fatal') {
-        const mod = await import('./logging/SlackLogger');
-        void mod.SlackLogger.enqueue(event);
-      }
-    } catch {
-      // best-effort
-    }
-
-    try {
-      const mod = await import('./logging/HttpLogger');
-      void mod.HttpLogger.enqueue(event);
-    } catch {
-      // best-effort
-    }
-  })();
-};
-
-// Private helper functions
-const logDebug = (message: string, data?: unknown, category?: string): void => {
-  String(category);
-  if (isDevelopment()) {
-    const timestamp = new Date().toISOString();
-    const out = formatLogMessage({ level: 'debug', message, data, category });
-    writeToFile(buildFileLine({ formatted: out, data }));
-    if (isJsonFormat(getLogFormat())) {
-      console.debug(out); // eslint-disable-line no-console
-      return;
-    }
-    console.debug(out, data ?? ''); // eslint-disable-line no-console
-
-    emitCloudLogs({
-      timestamp,
-      level: 'debug',
-      message,
-      category,
-      data: redactSensitiveData(data),
-    });
-  }
-};
-
-const logInfo = (message: string, data?: unknown, category?: string): void => {
-  String(category);
-  const timestamp = new Date().toISOString();
-  const out = formatLogMessage({ level: 'info', message, data, category });
-  writeToFile(buildFileLine({ formatted: out, data }));
-  if (isJsonFormat(getLogFormat())) {
-    console.log(out); // eslint-disable-line no-console
-  } else {
-    console.log(out, data ?? ''); // eslint-disable-line no-console
-  }
-
-  emitCloudLogs({
-    timestamp,
-    level: 'info',
-    message,
-    category,
-    data: redactSensitiveData(data),
-  });
-};
-
-const logWarn = (message: string, data?: unknown, category?: string): void => {
-  String(category);
-  const timestamp = new Date().toISOString();
-  const out = formatLogMessage({ level: 'warn', message, data, category });
-  writeToFile(buildFileLine({ formatted: out, data }));
-  if (isJsonFormat(getLogFormat())) {
-    console.warn(out); // eslint-disable-line no-console
-  } else {
-    console.warn(out, data ?? ''); // eslint-disable-line no-console
-  }
-
-  emitCloudLogs({
-    timestamp,
-    level: 'warn',
-    message,
-    category,
-    data: redactSensitiveData(data),
-  });
-};
-
-const logError = (message: string, error?: unknown, category?: string): void => {
-  const errorMessage = getErrorMessage(error);
-  String(category);
-  const timestamp = new Date().toISOString();
-  const out = formatLogMessage({
-    level: 'error',
-    message,
-    category,
-    errorMessage,
-  });
-  writeToFile(buildFileLine({ formatted: out, errorMessage }));
-  if (isJsonFormat(getLogFormat())) {
-    console.error(out); // eslint-disable-line no-console
-  } else {
-    console.error(out, errorMessage); // eslint-disable-line no-console
-  }
-
-  emitCloudLogs({
-    timestamp,
-    level: 'error',
-    message,
-    category,
-    error: errorMessage,
-  });
-};
-
-const logFatal = (message: string, error?: unknown, category?: string): void => {
-  const errorMessage = getErrorMessage(error);
-  String(category);
-  const timestamp = new Date().toISOString();
-  const out = formatLogMessage({
-    level: 'fatal',
-    message,
-    category,
-    errorMessage,
-  });
-  writeToFile(buildFileLine({ formatted: out, errorMessage }));
-  if (isJsonFormat(getLogFormat())) {
-    console.error(out); // eslint-disable-line no-console
-  } else {
-    console.error(out, errorMessage); // eslint-disable-line no-console
-  }
-
-  emitCloudLogs({
-    timestamp,
-    level: 'fatal',
-    message,
-    category,
-    error: errorMessage,
-  });
-
-  if (isProduction() && typeof process !== 'undefined') {
-    process.exit(1);
-  }
-};
-
-const createLoggerScope = (scope: string): ILogger => {
-  return {
-    debug(message: string, data?: unknown): void {
-      logDebug(`[${scope}] ${message}`, data, scope);
-    },
-    info(message: string, data?: unknown): void {
-      logInfo(`[${scope}] ${message}`, data, scope);
-    },
-    warn(message: string, data?: unknown): void {
-      logWarn(`[${scope}] ${message}`, data, scope);
-    },
-    error(message: string, error?: unknown): void {
-      logError(`[${scope}] ${message}`, error, scope);
-    },
-    fatal(message: string, error?: unknown): void {
-      logFatal(`[${scope}] ${message}`, error, scope);
-    },
-  };
-};
-
-// Expose log cleanup API and sealed namespace with all logger functionality
-export const cleanLogsOnce = async (): Promise<string[]> => {
-  if (!shouldLogToFile()) return [];
-
-  try {
-    const mod = await import('./FileLogWriter');
-    const deleted = mod.cleanOnce();
-    logInfo('Log cleanup executed', { deletedCount: deleted.length });
-    return deleted;
-  } catch (err: unknown) {
-    logError('Log cleanup failed', err as Error);
-    return [];
-  }
-};
-
-export const Logger = Object.freeze({
-  debug: logDebug,
-  info: logInfo,
-  warn: logWarn,
-  error: logError,
-  fatal: logFatal,
-  cleanLogsOnce,
-  scope: createLoggerScope,
-});
+export { Logger } from '@zintrust/core';
 
 export default Logger;

package/src/templates/project/basic/config/logging/HttpLogger.ts.tpl

@@ -10,7 +10,7 @@
  */
 
 import { delay } from '@zintrust/core';
-import { Env } from '../env';
+import { Env } from '@zintrust/core';
 import { ErrorFactory } from '@zintrust/core';
 import { HttpClient } from '@zintrust/core';
 

package/src/templates/project/basic/config/logging/KvLogger.ts.tpl

@@ -8,8 +8,8 @@
  *  - KV_LOG_RETENTION_DAYS (default: 30)
  */
 
-import { Cloudflare } from '../cloudflare';
-import { Env } from '../env';
+import { Cloudflare } from '@zintrust/core';
+import { Env } from '@zintrust/core';
 
 export type KvLogEvent = {
   timestamp: string;

package/src/templates/project/basic/config/logging/SlackLogger.ts.tpl

@@ -9,7 +9,7 @@
  *  - SLACK_LOG_BATCH_WINDOW_MS (default: 5000)
  */
 
-import { Env } from '../env';
+import { Env } from '@zintrust/core';
 import { ErrorFactory } from '@zintrust/core';
 import { HttpClient } from '@zintrust/core';
 

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

@@ -4,9 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from './env';
-import type { MailConfigInput, MailDriverConfig } from './type';
-import { ErrorFactory } from '@zintrust/core';
+import type { MailConfigInput, MailDriverConfig } from '@zintrust/core';
+import { ErrorFactory, Env } from '@zintrust/core';
 
 const isMailDriverConfig = (value: unknown): value is MailDriverConfig => {
   if (typeof value !== 'object' || value === null) return false;

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

@@ -4,7 +4,7 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from './env';
+import { Env } from '@zintrust/core';
 
 const microservicesConfigObj = {
   /**

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

@@ -1,4 +1,4 @@
-import { MiddlewareConfigType } from './type';
+import type { MiddlewareConfigType } from '@zintrust/core';
 import { CsrfMiddleware } from '@zintrust/core';
 import { ErrorHandlerMiddleware } from '@zintrust/core';
 import { LoggingMiddleware } from '@zintrust/core';
@@ -6,18 +6,45 @@ import type { Middleware } from '@zintrust/core';
 import { RateLimiter } from '@zintrust/core';
 import { SecurityMiddleware } from '@zintrust/core';
 
-const shared = Object.freeze({
-  log: LoggingMiddleware.create(),
-  error: ErrorHandlerMiddleware.create(),
-  security: SecurityMiddleware.create(),
-  rateLimit: RateLimiter.create(),
-  csrf: CsrfMiddleware.create(),
-} satisfies Record<string, Middleware>);
+function createSharedMiddlewares() {
+  return Object.freeze({
+    log: LoggingMiddleware.create(),
+    error: ErrorHandlerMiddleware.create(),
+    security: SecurityMiddleware.create(),
+    rateLimit: RateLimiter.create(),
+    csrf: CsrfMiddleware.create(),
+  });
+}
 
-const middlewareConfigObj: MiddlewareConfigType = {
-  global: [shared.log, shared.error, shared.security, shared.rateLimit, shared.csrf],
-  route: shared,
-};
+export function createMiddlewareConfig(): MiddlewareConfigType {
+  const shared = createSharedMiddlewares();
+
+  const middlewareConfigObj: MiddlewareConfigType = {
+    global: [shared.log, shared.error, shared.security, shared.rateLimit, shared.csrf],
+    route: shared,
+  };
+
+  return Object.freeze(middlewareConfigObj);
+}
+
+let cached: MiddlewareConfigType | null = null;
+
+function ensureMiddlewareConfig(): MiddlewareConfigType {
+  if (cached) return cached;
+  cached = createMiddlewareConfig();
+  return cached;
+}
+
+export const middlewareConfig: MiddlewareConfigType = new Proxy({} as MiddlewareConfigType, {
+  get(_target, prop: keyof MiddlewareConfigType) {
+    return ensureMiddlewareConfig()[prop];
+  },
+  ownKeys() {
+    return Reflect.ownKeys(ensureMiddlewareConfig());
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    return Object.getOwnPropertyDescriptor(ensureMiddlewareConfig(), prop);
+  },
+});
 
-export const middlewareConfig = Object.freeze(middlewareConfigObj);
 export default middlewareConfig;

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

@@ -5,19 +5,18 @@
  * Driver selection must be dynamic (tests may mutate process.env).
  */
 
-import { Env } from './env';
 import type {
   KnownNotificationDriverConfig,
   NotificationConfigInput,
   NotificationDrivers,
   NotificationProviders,
-} from './type';
-import { ErrorFactory } from '@zintrust/core';
+} from '@zintrust/core';
+import { ErrorFactory ,Env} from '@zintrust/core';
 
 const normalizeName = (value: string): string => value.trim().toLowerCase();
 
 const hasOwn = (obj: Record<string, unknown>, key: string): boolean => {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+  return Object.hasOwn(obj, key);
 };
 
 const getDefaultChannel = (drivers: NotificationDrivers): string => {

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

@@ -4,9 +4,9 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from './env';
+import { Env } from '@zintrust/core';
 
-import type { QueueConfigWithDrivers, QueueDriverName, QueueDriversConfig } from './type';
+import type { QueueConfigWithDrivers, QueueDriverName, QueueDriversConfig } from '@zintrust/core';
 
 const getQueueDriver = (config: QueueConfigWithDrivers): QueueDriversConfig[QueueDriverName] => {
   const driverName = config.default;

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

@@ -16,9 +16,9 @@
  * security domains (e.g., different keys for different microservices).
  */
 
-import { appConfig } from './app';
-import { Env } from './env';
-import { Logger } from './logger';
+import { appConfig } from '@zintrust/core';
+import { Env } from '@zintrust/core';
+import { Logger } from '@zintrust/core';
 import { ErrorFactory } from '@zintrust/core';
 
 /**

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

@@ -4,7 +4,7 @@
  * Startup-only controls (evaluated during Application.boot()).
  */
 
-import { Env } from './env';
+import { Env } from '@zintrust/core';
 
 export type StartupConfig = {
   healthChecksEnabled: boolean;

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

@@ -4,12 +4,11 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from './env';
-import type { StorageConfigRuntime, StorageDriverConfig, StorageDrivers } from './type';
-import { ErrorFactory } from '@zintrust/core';
+import type { StorageConfigRuntime, StorageDriverConfig, StorageDrivers } from '@zintrust/core';
+import { ErrorFactory , Env} from '@zintrust/core';
 
 const hasOwn = <T extends object>(obj: T, key: PropertyKey): key is keyof T => {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+  return Object.hasOwn(obj, key);
 };
 
 const getStorageDriver = (config: StorageConfigRuntime, name?: string): StorageDriverConfig => {

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

@@ -1,4 +1,4 @@
-import { Env } from './env';
+import { Env } from '@zintrust/core';
 import type { Middleware as MiddlewareFn } from '@zintrust/core';
 
 export type Environment =
@@ -323,10 +323,20 @@ export type MysqlConnectionConfig = {
   };
 };
 
+export type D1ConnectionConfig = {
+  driver: 'd1';
+};
+
+export type D1RemoteConnectionConfig = {
+  driver: 'd1-remote';
+};
+
 export type DatabaseConnectionConfig =
   | SqliteConnectionConfig
   | PostgresqlConnectionConfig
-  | MysqlConnectionConfig;
+  | MysqlConnectionConfig
+  | D1ConnectionConfig
+  | D1RemoteConnectionConfig;
 
 /**
  * Named database connection configs.

package/src/templates/project/basic/package.json.tpl

@@ -11,7 +11,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@zintrust/core": "^0.1.4"
+    "@zintrust/core": "^{{coreVersion}}"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",

package/src/templates/project/basic/routes/api.ts.tpl

@@ -5,10 +5,10 @@
 
 import { Env, type IRouter, Router } from '@zintrust/core';
 
-import { UserController } from '../app/Controllers/UserController';
-import { registerBroadcastRoutes } from './broadcast';
-import { registerHealthRoutes } from './health';
-import { registerStorageRoutes } from './storage';
+import { UserController } from '@app/Controllers/UserController';
+import { registerBroadcastRoutes } from '@routes/broadcast';
+import { registerHealthRoutes } from '@routes/health';
+import { registerStorageRoutes } from '@routes/storage';
 
 export function registerRoutes(router: IRouter): void {
   const userController = UserController.create();

package/src/templates/project/basic/routes/health.ts.tpl

@@ -3,12 +3,7 @@
  * Provides health, liveness, and readiness endpoints.
  */
 
-import { appConfig } from '../config/app';
-import { Env } from '../config/env';
-import { Logger } from '../config/logger';
-import { RuntimeHealthProbes } from '@zintrust/core';
-import { useDatabase } from '@zintrust/core';
-import { QueryBuilder } from '@zintrust/core';
+import { useDatabase, appConfig, Env , Logger, RuntimeHealthProbes, QueryBuilder} from '@zintrust/core';
 import { type IRouter, Router } from '@zintrust/core';
 
 export function registerHealthRoutes(router: IRouter): void {