@morojs/moro 1.0.0 → 1.0.1

package/src/core/config/schema.ts

@@ -1,99 +1,85 @@
 // Core Configuration Schema for Moro Framework
-import { z } from "zod";
+import { z } from 'zod';
 
 // Server Configuration Schema
 const ServerConfigSchema = z.object({
   port: z.coerce
     .number()
-    .min(1, "Port must be at least 1")
-    .max(65535, "Port must be at most 65535")
+    .min(1, 'Port must be at least 1')
+    .max(65535, 'Port must be at most 65535')
     .default(3001)
-    .describe("Server port to listen on"),
+    .describe('Server port to listen on'),
 
-  host: z.string().default("localhost").describe("Server host to bind to"),
+  host: z.string().default('localhost').describe('Server host to bind to'),
 
   environment: z
-    .enum(["development", "staging", "production"])
-    .default("development")
-    .describe("Application environment"),
+    .enum(['development', 'staging', 'production'])
+    .default('development')
+    .describe('Application environment'),
 
-  maxConnections: z.coerce
-    .number()
-    .min(1)
-    .default(1000)
-    .describe("Maximum concurrent connections"),
+  maxConnections: z.coerce.number().min(1).default(1000).describe('Maximum concurrent connections'),
 
-  timeout: z.coerce
-    .number()
-    .min(1000)
-    .default(30000)
-    .describe("Request timeout in milliseconds"),
+  timeout: z.coerce.number().min(1000).default(30000).describe('Request timeout in milliseconds'),
 });
 
 // Service Discovery Configuration Schema
 const ServiceDiscoveryConfigSchema = z.object({
-  enabled: z.coerce
-    .boolean()
-    .default(false)
-    .describe("Enable service discovery"),
+  enabled: z.coerce.boolean().default(false).describe('Enable service discovery'),
 
   type: z
-    .enum(["memory", "consul", "kubernetes"])
-    .default("memory")
-    .describe("Service discovery backend type"),
+    .enum(['memory', 'consul', 'kubernetes'])
+    .default('memory')
+    .describe('Service discovery backend type'),
 
   consulUrl: z
     .string()
-    .url("Must be a valid URL")
-    .default("http://localhost:8500")
-    .describe("Consul server URL"),
+    .url('Must be a valid URL')
+    .default('http://localhost:8500')
+    .describe('Consul server URL'),
 
   kubernetesNamespace: z
     .string()
-    .default("default")
-    .describe("Kubernetes namespace for service discovery"),
+    .default('default')
+    .describe('Kubernetes namespace for service discovery'),
 
   healthCheckInterval: z.coerce
     .number()
     .min(1000)
     .default(30000)
-    .describe("Health check interval in milliseconds"),
+    .describe('Health check interval in milliseconds'),
 
   retryAttempts: z.coerce
     .number()
     .min(0)
     .default(3)
-    .describe("Number of retry attempts for failed health checks"),
+    .describe('Number of retry attempts for failed health checks'),
 });
 
 // Database Configuration Schema
 const DatabaseConfigSchema = z.object({
-  url: z.string().optional().describe("Primary database connection URL"),
+  url: z.string().optional().describe('Primary database connection URL'),
 
   redis: z.object({
-    url: z
-      .string()
-      .default("redis://localhost:6379")
-      .describe("Redis connection URL"),
+    url: z.string().default('redis://localhost:6379').describe('Redis connection URL'),
 
     maxRetries: z.coerce
       .number()
       .min(0)
       .default(3)
-      .describe("Maximum Redis connection retry attempts"),
+      .describe('Maximum Redis connection retry attempts'),
 
     retryDelay: z.coerce
       .number()
       .min(100)
       .default(1000)
-      .describe("Redis retry delay in milliseconds"),
+      .describe('Redis retry delay in milliseconds'),
 
-    keyPrefix: z.string().default("moro:").describe("Redis key prefix"),
+    keyPrefix: z.string().default('moro:').describe('Redis key prefix'),
   }),
 
   mysql: z
     .object({
-      host: z.string().default("localhost"),
+      host: z.string().default('localhost'),
       port: z.coerce.number().min(1).max(65535).default(3306),
       database: z.string().optional(),
       username: z.string().optional(),
@@ -108,109 +94,70 @@ const DatabaseConfigSchema = z.object({
 // Module Defaults Configuration Schema
 const ModuleDefaultsConfigSchema = z.object({
   cache: z.object({
-    enabled: z.coerce
-      .boolean()
-      .default(true)
-      .describe("Enable caching by default"),
+    enabled: z.coerce.boolean().default(true).describe('Enable caching by default'),
 
-    defaultTtl: z.coerce
-      .number()
-      .min(0)
-      .default(300)
-      .describe("Default cache TTL in seconds"),
+    defaultTtl: z.coerce.number().min(0).default(300).describe('Default cache TTL in seconds'),
 
-    maxSize: z.coerce
-      .number()
-      .min(1)
-      .default(1000)
-      .describe("Maximum cache entries"),
+    maxSize: z.coerce.number().min(1).default(1000).describe('Maximum cache entries'),
 
-    strategy: z
-      .enum(["lru", "lfu", "fifo"])
-      .default("lru")
-      .describe("Cache eviction strategy"),
+    strategy: z.enum(['lru', 'lfu', 'fifo']).default('lru').describe('Cache eviction strategy'),
   }),
 
   rateLimit: z.object({
-    enabled: z.coerce
-      .boolean()
-      .default(true)
-      .describe("Enable rate limiting by default"),
+    enabled: z.coerce.boolean().default(true).describe('Enable rate limiting by default'),
 
-    defaultRequests: z.coerce
-      .number()
-      .min(1)
-      .default(100)
-      .describe("Default requests per window"),
+    defaultRequests: z.coerce.number().min(1).default(100).describe('Default requests per window'),
 
     defaultWindow: z.coerce
       .number()
       .min(1000)
       .default(60000)
-      .describe("Default rate limit window in milliseconds"),
+      .describe('Default rate limit window in milliseconds'),
 
     skipSuccessfulRequests: z.coerce
       .boolean()
       .default(false)
-      .describe("Skip successful requests in rate limit counting"),
+      .describe('Skip successful requests in rate limit counting'),
 
     skipFailedRequests: z.coerce
       .boolean()
       .default(false)
-      .describe("Skip failed requests in rate limit counting"),
+      .describe('Skip failed requests in rate limit counting'),
   }),
 
   validation: z.object({
-    enabled: z.coerce
-      .boolean()
-      .default(true)
-      .describe("Enable validation by default"),
+    enabled: z.coerce.boolean().default(true).describe('Enable validation by default'),
 
     stripUnknown: z.coerce
       .boolean()
       .default(true)
-      .describe("Strip unknown properties from validated data"),
+      .describe('Strip unknown properties from validated data'),
 
-    abortEarly: z.coerce
-      .boolean()
-      .default(false)
-      .describe("Stop validation on first error"),
+    abortEarly: z.coerce.boolean().default(false).describe('Stop validation on first error'),
   }),
 });
 
 // Logging Configuration Schema
 const LoggingConfigSchema = z.object({
   level: z
-    .enum(["debug", "info", "warn", "error", "fatal"])
-    .default("info")
-    .describe("Minimum log level"),
-
-  format: z
-    .enum(["pretty", "json", "compact"])
-    .default("pretty")
-    .describe("Log output format"),
-
-  enableColors: z.coerce
-    .boolean()
-    .default(true)
-    .describe("Enable colored log output"),
-
-  enableTimestamp: z.coerce
-    .boolean()
-    .default(true)
-    .describe("Include timestamp in logs"),
-
-  enableContext: z.coerce
-    .boolean()
-    .default(true)
-    .describe("Include context information in logs"),
+    .enum(['debug', 'info', 'warn', 'error', 'fatal'])
+    .default('info')
+    .describe('Minimum log level'),
+
+  format: z.enum(['pretty', 'json', 'compact']).default('pretty').describe('Log output format'),
+
+  enableColors: z.coerce.boolean().default(true).describe('Enable colored log output'),
+
+  enableTimestamp: z.coerce.boolean().default(true).describe('Include timestamp in logs'),
+
+  enableContext: z.coerce.boolean().default(true).describe('Include context information in logs'),
 
   outputs: z.object({
     console: z.coerce.boolean().default(true),
     file: z.object({
       enabled: z.coerce.boolean().default(false),
-      path: z.string().default("./logs/moro.log"),
-      maxSize: z.string().default("10MB"),
+      path: z.string().default('./logs/moro.log'),
+      maxSize: z.string().default('10MB'),
       maxFiles: z.coerce.number().default(5),
     }),
     webhook: z.object({
@@ -225,15 +172,9 @@ const LoggingConfigSchema = z.object({
 const SecurityConfigSchema = z.object({
   cors: z.object({
     enabled: z.coerce.boolean().default(true),
-    origin: z
-      .union([z.string(), z.array(z.string()), z.boolean()])
-      .default("*"),
-    methods: z
-      .array(z.string())
-      .default(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]),
-    allowedHeaders: z
-      .array(z.string())
-      .default(["Content-Type", "Authorization"]),
+    origin: z.union([z.string(), z.array(z.string()), z.boolean()]).default('*'),
+    methods: z.array(z.string()).default(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS']),
+    allowedHeaders: z.array(z.string()).default(['Content-Type', 'Authorization']),
     credentials: z.coerce.boolean().default(false),
   }),
 
@@ -261,7 +202,7 @@ const ExternalServicesConfigSchema = z.object({
       secretKey: z.string().optional(),
       publishableKey: z.string().optional(),
       webhookSecret: z.string().optional(),
-      apiVersion: z.string().default("2023-10-16"),
+      apiVersion: z.string().default('2023-10-16'),
     })
     .optional(),
 
@@ -270,7 +211,7 @@ const ExternalServicesConfigSchema = z.object({
       clientId: z.string().optional(),
       clientSecret: z.string().optional(),
       webhookId: z.string().optional(),
-      environment: z.enum(["sandbox", "production"]).default("sandbox"),
+      environment: z.enum(['sandbox', 'production']).default('sandbox'),
     })
     .optional(),
 
@@ -321,16 +262,12 @@ export const ConfigSchema = z.object({
 // Inferred TypeScript types
 export type AppConfig = z.infer<typeof ConfigSchema>;
 export type ServerConfig = z.infer<typeof ServerConfigSchema>;
-export type ServiceDiscoveryConfig = z.infer<
-  typeof ServiceDiscoveryConfigSchema
->;
+export type ServiceDiscoveryConfig = z.infer<typeof ServiceDiscoveryConfigSchema>;
 export type DatabaseConfig = z.infer<typeof DatabaseConfigSchema>;
 export type ModuleDefaultsConfig = z.infer<typeof ModuleDefaultsConfigSchema>;
 export type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
 export type SecurityConfig = z.infer<typeof SecurityConfigSchema>;
-export type ExternalServicesConfig = z.infer<
-  typeof ExternalServicesConfigSchema
->;
+export type ExternalServicesConfig = z.infer<typeof ExternalServicesConfigSchema>;
 export type PerformanceConfig = z.infer<typeof PerformanceConfigSchema>;
 
 // Export individual schemas for module-specific configuration

package/src/core/config/utils.ts

@@ -1,9 +1,9 @@
 // Configuration Utilities for Modules and Environment Handling
-import { z } from "zod";
-import { AppConfig } from "./schema";
-import { createFrameworkLogger } from "../logger";
+import { z } from 'zod';
+import { AppConfig } from './schema';
+import { createFrameworkLogger } from '../logger';
 
-const logger = createFrameworkLogger("ConfigUtils");
+const logger = createFrameworkLogger('ConfigUtils');
 
 // Global configuration store
 let appConfig: AppConfig | null = null;
@@ -13,7 +13,7 @@ let appConfig: AppConfig | null = null;
  */
 export function setConfig(config: AppConfig): void {
   appConfig = config;
-  logger.debug("Global configuration updated");
+  logger.debug('Global configuration updated');
 }
 
 /**
@@ -21,7 +21,7 @@ export function setConfig(config: AppConfig): void {
  */
 export function getConfig(): AppConfig {
   if (!appConfig) {
-    throw new Error("Configuration not initialized. Call loadConfig() first.");
+    throw new Error('Configuration not initialized. Call loadConfig() first.');
   }
   return appConfig;
 }
@@ -32,7 +32,7 @@ export function getConfig(): AppConfig {
 export function createModuleConfig<T>(
   schema: z.ZodSchema<T>,
   defaultConfig: Partial<T>,
-  envPrefix?: string,
+  envPrefix?: string
 ): T {
   const globalConfig = getConfig();
 
@@ -41,7 +41,7 @@ export function createModuleConfig<T>(
 
   if (envPrefix) {
     // Extract environment variables with the given prefix
-    Object.keys(process.env).forEach((key) => {
+    Object.keys(process.env).forEach(key => {
       if (key.startsWith(envPrefix)) {
         const configKey = key
           .substring(envPrefix.length)
@@ -62,10 +62,7 @@ export function createModuleConfig<T>(
   try {
     return schema.parse(mergedConfig);
   } catch (error) {
-    logger.error(
-      `Module configuration validation failed for prefix ${envPrefix}:`,
-      String(error),
-    );
+    logger.error(`Module configuration validation failed for prefix ${envPrefix}:`, String(error));
     throw error;
   }
 }
@@ -73,11 +70,7 @@ export function createModuleConfig<T>(
 /**
  * Get environment variable with type conversion
  */
-export function getEnvVar<T>(
-  key: string,
-  defaultValue: T,
-  converter?: (value: string) => T,
-): T {
+export function getEnvVar<T>(key: string, defaultValue: T, converter?: (value: string) => T): T {
   const value = process.env[key];
 
   if (value === undefined) {
@@ -88,20 +81,17 @@ export function getEnvVar<T>(
     try {
       return converter(value);
     } catch (error) {
-      logger.warn(
-        `Failed to convert environment variable ${key}:`,
-        String(error),
-      );
+      logger.warn(`Failed to convert environment variable ${key}:`, String(error));
       return defaultValue;
     }
   }
 
   // Default type conversions
-  if (typeof defaultValue === "boolean") {
-    return (value.toLowerCase() === "true") as T;
+  if (typeof defaultValue === 'boolean') {
+    return (value.toLowerCase() === 'true') as T;
   }
 
-  if (typeof defaultValue === "number") {
+  if (typeof defaultValue === 'number') {
     const num = Number(value);
     return (isNaN(num) ? defaultValue : num) as T;
   }
@@ -112,10 +102,7 @@ export function getEnvVar<T>(
 /**
  * Parse comma-separated environment variable as array
  */
-export function getEnvArray(
-  key: string,
-  defaultValue: string[] = [],
-): string[] {
+export function getEnvArray(key: string, defaultValue: string[] = []): string[] {
   const value = process.env[key];
 
   if (!value) {
@@ -123,8 +110,8 @@ export function getEnvArray(
   }
 
   return value
-    .split(",")
-    .map((item) => item.trim())
+    .split(',')
+    .map(item => item.trim())
     .filter(Boolean);
 }
 
@@ -141,10 +128,7 @@ export function getEnvJson<T>(key: string, defaultValue: T): T {
   try {
     return JSON.parse(value);
   } catch (error) {
-    logger.warn(
-      `Failed to parse JSON environment variable ${key}:`,
-      String(error),
-    );
+    logger.warn(`Failed to parse JSON environment variable ${key}:`, String(error));
     return defaultValue;
   }
 }
@@ -155,16 +139,14 @@ export function getEnvJson<T>(key: string, defaultValue: T): T {
 export function requireEnvVars(...keys: string[]): void {
   const missing: string[] = [];
 
-  keys.forEach((key) => {
+  keys.forEach(key => {
     if (!process.env[key]) {
       missing.push(key);
     }
   });
 
   if (missing.length > 0) {
-    throw new Error(
-      `Missing required environment variables: ${missing.join(", ")}`,
-    );
+    throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
   }
 }
 
@@ -181,7 +163,7 @@ export function envVar(prefix: string, name: string): string {
 export function getConfigValue(path: string): any {
   const config = getConfig();
 
-  return path.split(".").reduce((obj, key) => {
+  return path.split('.').reduce((obj, key) => {
     return obj && obj[key] !== undefined ? obj[key] : undefined;
   }, config as any);
 }
@@ -191,9 +173,9 @@ export function getConfigValue(path: string): any {
  */
 export function isDevelopment(): boolean {
   try {
-    return getConfig().server.environment === "development";
+    return getConfig().server.environment === 'development';
   } catch {
-    return process.env.NODE_ENV === "development";
+    return process.env.NODE_ENV === 'development';
   }
 }
 
@@ -202,9 +184,9 @@ export function isDevelopment(): boolean {
  */
 export function isProduction(): boolean {
   try {
-    return getConfig().server.environment === "production";
+    return getConfig().server.environment === 'production';
   } catch {
-    return process.env.NODE_ENV === "production";
+    return process.env.NODE_ENV === 'production';
   }
 }
 
@@ -213,8 +195,8 @@ export function isProduction(): boolean {
  */
 export function isStaging(): boolean {
   try {
-    return getConfig().server.environment === "staging";
+    return getConfig().server.environment === 'staging';
   } catch {
-    return process.env.NODE_ENV === "staging";
+    return process.env.NODE_ENV === 'staging';
   }
 }