@zintrust/core 0.1.28 → 0.1.30

package/src/cli/config/ConfigManager.js

@@ -0,0 +1,175 @@
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ */
+import { ConfigPaths, DEFAULT_CONFIG, getConfigValue, setConfigValue, } from '../config/ConfigSchema.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { fsPromises as fs } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+/**
+ * Deep merge helper
+ */
+const deepMerge = (target, source) => {
+    const result = { ...target };
+    for (const key in source) {
+        if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key] ?? {}, source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+};
+/**
+ * Load configuration from file
+ */
+async function loadConfig(state) {
+    try {
+        const content = await fs.readFile(state.configPath, 'utf-8');
+        state.config = JSON.parse(content);
+        return state.config;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            Logger.debug(`Config file not found at ${state.configPath}, using defaults`);
+            state.config = structuredClone(DEFAULT_CONFIG);
+            return state.config;
+        }
+        ErrorFactory.createCliError(`Failed to load config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Save configuration to file
+ */
+async function saveConfig(state, newConfig) {
+    const toSave = newConfig ?? state.config;
+    if (!toSave) {
+        throw ErrorFactory.createConfigError('No configuration to save');
+    }
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(state.configPath);
+        if (dir !== '.') {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        // Write config with nice formatting
+        await fs.writeFile(state.configPath, JSON.stringify(toSave, null, 2));
+        state.config = toSave;
+        Logger.debug(`Config saved to ${state.configPath}`);
+    }
+    catch (err) {
+        ErrorFactory.createCliError(`Failed to save config: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * Get current configuration
+ */
+function getConfig(state) {
+    state.config ??= structuredClone(DEFAULT_CONFIG);
+    return state.config;
+}
+/**
+ * Check if config file exists
+ */
+async function configExists(configPath) {
+    try {
+        await fs.access(configPath);
+        return true;
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Config file access check failed', error);
+        return false;
+    }
+}
+/**
+ * Flatten object keys
+ */
+function flattenKeys(obj, prefix = '') {
+    const keys = [];
+    for (const key in obj) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        const value = obj[key];
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            keys.push(...flattenKeys(value, fullKey));
+        }
+        else {
+            keys.push(fullKey);
+        }
+    }
+    return keys;
+}
+/**
+ * Configuration Manager
+ * Handles reading, writing, and managing configuration files
+ * Sealed namespace for immutability
+ */
+export const ConfigManager = Object.freeze({
+    /**
+     * Create a new config manager instance
+     */
+    create(configPath = ConfigPaths.PROJECT_CONFIG) {
+        const state = {
+            config: null,
+            configPath,
+        };
+        return {
+            load: async () => loadConfig(state),
+            save: async (newConfig) => saveConfig(state, newConfig),
+            getConfig: () => getConfig(state),
+            get(key) {
+                return getConfigValue(getConfig(state), key);
+            },
+            set(key, value) {
+                setConfigValue(getConfig(state), key, value);
+            },
+            exists: async () => configExists(configPath),
+            async create(initialConfig) {
+                const newConfig = { ...DEFAULT_CONFIG, ...initialConfig };
+                await saveConfig(state, newConfig);
+            },
+            async reset() {
+                state.config = structuredClone(DEFAULT_CONFIG);
+                await saveConfig(state);
+            },
+            merge(partial) {
+                const currentConfig = getConfig(state);
+                state.config = deepMerge(currentConfig, partial);
+            },
+            export: () => JSON.stringify(getConfig(state), null, 2),
+            getAllKeys: () => flattenKeys(getConfig(state)),
+        };
+    },
+    /**
+     * Create global config directory if not exists
+     */
+    async ensureGlobalConfigDir() {
+        try {
+            await fs.mkdir(ConfigPaths.GLOBAL_DIR, { recursive: true });
+        }
+        catch (err) {
+            ErrorFactory.createCliError('Could not create global config dir', err);
+            Logger.debug(`Could not create global config dir: ${err.message}`);
+        }
+    },
+    /**
+     * Get or create global config manager
+     */
+    async getGlobalConfig() {
+        await this.ensureGlobalConfigDir();
+        const manager = this.create(ConfigPaths.GLOBAL_CONFIG);
+        await manager.load();
+        return manager;
+    },
+    /**
+     * Get or create project config manager
+     */
+    async getProjectConfig() {
+        const manager = this.create(ConfigPaths.PROJECT_CONFIG);
+        await manager.load();
+        return manager;
+    },
+});

package/src/cli/config/ConfigSchema.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Configuration Schema
+ * Defines the structure and types for ZinTrust configuration
+ */
+export interface DatabaseConfig {
+    connection: 'sqlite' | 'postgres' | 'mysql' | 'mariadb';
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    charset?: string;
+    collation?: string;
+    synchronize?: boolean;
+    logging?: boolean;
+}
+export interface ServerConfig {
+    port: number;
+    host: string;
+    environment: 'development' | 'production' | 'testing';
+    debug: boolean;
+    profiling: boolean;
+    tracing: boolean;
+}
+export interface AuthConfig {
+    enabled: boolean;
+    strategy: 'jwt' | 'session' | 'apikey';
+    jwtSecret?: string;
+    sessionSecret?: string;
+    expiresIn: string;
+}
+export interface MicroservicesConfig {
+    enabled: boolean;
+    port: number;
+    apiGatewayPort?: number;
+    discoveryType: 'filesystem' | 'consul' | 'kubernetes';
+    healthCheckInterval: number;
+}
+export interface FeatureConfig {
+    auth: boolean;
+    database: boolean;
+    cache: boolean;
+    queue: boolean;
+    storage: boolean;
+    email: boolean;
+    webhooks: boolean;
+    monitoring: boolean;
+}
+export interface ProjectConfig {
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    database: DatabaseConfig;
+    server: ServerConfig;
+    auth: AuthConfig;
+    microservices: MicroservicesConfig;
+    features: FeatureConfig;
+    [key: string]: unknown;
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONFIG: Readonly<{
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    database: {
+        connection: "sqlite";
+        charset: string;
+        collation: string;
+        synchronize: true;
+        logging: false;
+    };
+    server: {
+        port: number;
+        host: string;
+        environment: "development";
+        debug: false;
+        profiling: false;
+        tracing: false;
+    };
+    auth: {
+        enabled: false;
+        strategy: "jwt";
+        expiresIn: string;
+    };
+    microservices: {
+        enabled: false;
+        port: number;
+        discoveryType: "filesystem";
+        healthCheckInterval: number;
+    };
+    features: {
+        auth: false;
+        database: true;
+        cache: false;
+        queue: false;
+        storage: false;
+        email: false;
+        webhooks: false;
+        monitoring: false;
+    };
+}>;
+/**
+ * Configuration paths
+ * Sealed namespace for immutability
+ */
+export declare const ConfigPaths: Readonly<{
+    GLOBAL_DIR: string;
+    GLOBAL_CONFIG: `${string}/config.json`;
+    PROJECT_CONFIG: ".zintrust.json";
+    PROJECT_CONFIG_TS: "zintrust.config.ts";
+    ENV_FILE: ".env";
+    ENV_EXAMPLE: ".env.example";
+}>;
+/**
+ * Validation rule interface
+ */
+export interface ValidationRule {
+    type?: string;
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    min?: number;
+    max?: number;
+    enum?: string[];
+    description?: string;
+}
+/**
+ * Validation rules for each config section
+ * Sealed namespace for immutability
+ */
+export declare const CONFIG_RULES: Readonly<{
+    name: {
+        type: string;
+        required: boolean;
+        minLength: number;
+        maxLength: number;
+        pattern: RegExp;
+        description: string;
+    };
+    version: {
+        type: string;
+        required: boolean;
+        pattern: RegExp;
+        description: string;
+    };
+    'server.port': {
+        type: string;
+        required: boolean;
+        min: number;
+        max: number;
+        description: string;
+    };
+    'server.environment': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+    'database.connection': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+    'auth.strategy': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+    'microservices.discoveryType': {
+        type: string;
+        required: boolean;
+        enum: string[];
+        description: string;
+    };
+}>;
+/**
+ * Get default config for a specific key
+ */
+export declare function getDefaultValue(key: string): unknown;
+/**
+ * Set config value in object (deep set)
+ */
+export declare function setConfigValue(obj: Record<string, unknown>, path: string, value: unknown): void;
+/**
+ * Get config value from object (deep get)
+ */
+export declare function getConfigValue(obj: Record<string, unknown>, path: string): unknown;
+//# sourceMappingURL=ConfigSchema.d.ts.map

package/src/cli/config/ConfigSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigSchema.d.ts","sourceRoot":"","sources":["../../../../src/cli/config/ConfigSchema.ts"],"names":[],"mappings":"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"}

package/src/cli/config/ConfigSchema.js

@@ -0,0 +1,172 @@
+/**
+ * Configuration Schema
+ * Defines the structure and types for ZinTrust configuration
+ */
+import { Env } from '../../config/env.js';
+/**
+ * Default configuration values
+ */
+export const DEFAULT_CONFIG = Object.freeze({
+    name: 'zintrust-app',
+    version: '1.0.0',
+    description: 'A ZinTrust application',
+    author: 'Developer',
+    database: {
+        connection: 'sqlite',
+        charset: 'utf8',
+        collation: 'utf8_unicode_ci',
+        synchronize: true,
+        logging: false,
+    },
+    server: {
+        port: 7777,
+        host: '0.0.0.0',
+        environment: 'development',
+        debug: false,
+        profiling: false,
+        tracing: false,
+    },
+    auth: {
+        enabled: false,
+        strategy: 'jwt',
+        expiresIn: '7d',
+    },
+    microservices: {
+        enabled: false,
+        port: 3001,
+        discoveryType: 'filesystem',
+        healthCheckInterval: 30000,
+    },
+    features: {
+        auth: false,
+        database: true,
+        cache: false,
+        queue: false,
+        storage: false,
+        email: false,
+        webhooks: false,
+        monitoring: false,
+    },
+});
+/**
+ * Configuration paths
+ */
+const HOME_DIR = Env.HOME || Env.USERPROFILE || '';
+const GLOBAL_DIR = `${HOME_DIR}/.zintrust`;
+/**
+ * Configuration paths
+ * Sealed namespace for immutability
+ */
+export const ConfigPaths = Object.freeze({
+    GLOBAL_DIR,
+    GLOBAL_CONFIG: `${GLOBAL_DIR}/config.json`,
+    PROJECT_CONFIG: '.zintrust.json',
+    PROJECT_CONFIG_TS: 'zintrust.config.ts',
+    ENV_FILE: '.env',
+    ENV_EXAMPLE: '.env.example',
+});
+/**
+ * Validation rules for each config section
+ * Sealed namespace for immutability
+ */
+export const CONFIG_RULES = Object.freeze({
+    name: {
+        type: 'string',
+        required: true,
+        minLength: 3,
+        maxLength: 100,
+        pattern: /^[a-z\d\-_]+$/i,
+        description: 'Project name (alphanumeric, hyphens, underscores)',
+    },
+    version: {
+        type: 'string',
+        required: true,
+        // SemVer: MAJOR.MINOR.PATCH with optional -prerelease and +build metadata
+        // Avoids `.*` patterns (Sonar S5852: potential super-linear backtracking).
+        pattern: /^\d+\.\d+\.\d+(?:-[\dA-Za-z.-]+)?(?:\+[\dA-Za-z.-]+)?$/,
+        description: 'Semantic version (e.g. 1.0.0)',
+    },
+    'server.port': {
+        type: 'number',
+        required: true,
+        min: 1024,
+        max: 65535,
+        description: 'Server port (1024-65535)',
+    },
+    'server.environment': {
+        type: 'string',
+        required: true,
+        enum: ['development', 'production', 'testing'],
+        description: 'Deployment environment',
+    },
+    'database.connection': {
+        type: 'string',
+        required: true,
+        enum: ['sqlite', 'postgres', 'mysql', 'mariadb'],
+        description: 'Database type',
+    },
+    'auth.strategy': {
+        type: 'string',
+        required: true,
+        enum: ['jwt', 'session', 'apikey'],
+        description: 'Authentication strategy',
+    },
+    'microservices.discoveryType': {
+        type: 'string',
+        required: true,
+        enum: ['filesystem', 'consul', 'kubernetes'],
+        description: 'Service discovery method',
+    },
+});
+/**
+ * Get default config for a specific key
+ */
+export function getDefaultValue(key) {
+    const keys = key.split('.');
+    let value = DEFAULT_CONFIG;
+    for (const k of keys) {
+        if (typeof value === 'object' && value !== null && k in value) {
+            value = value[k];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+/**
+ * Set config value in object (deep set)
+ */
+export function setConfigValue(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        if (!(key in current)) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys.at(-1);
+    if (lastKey !== undefined) {
+        current[lastKey] = value;
+    }
+}
+/**
+ * Get config value from object (deep get)
+ */
+export function getConfigValue(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys) {
+        if (typeof current === 'object' &&
+            current !== null &&
+            key in current) {
+            current = current[key];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}

package/src/cli/config/ConfigValidator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Configuration Validator
+ * Validates configuration against schema and rules
+ */
+import type { ProjectConfig } from '../config/ConfigSchema';
+export interface ValidationError {
+    key: string;
+    value: unknown;
+    message: string;
+    rule: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/**
+ * Validate entire config against schema
+ */
+export declare function validateConfig(config: ProjectConfig): ValidationResult;
+/**
+ * Validate a single config value
+ */
+export declare function validateConfigValue(key: string, value: unknown): ValidationError | null;
+/**
+ * Format validation errors for display
+ */
+export declare function formatValidationErrors(result: ValidationResult): string;
+/**
+ * Get validation rule description
+ */
+export declare function getConfigDescription(key: string): string | undefined;
+/**
+ * ConfigValidator namespace - sealed for immutability
+ */
+export declare const ConfigValidator: Readonly<{
+    validate: typeof validateConfig;
+    validateValue: typeof validateConfigValue;
+    formatErrors: typeof formatValidationErrors;
+    getDescription: typeof getConfigDescription;
+}>;
+//# sourceMappingURL=ConfigValidator.d.ts.map

package/src/cli/config/ConfigValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigValidator.d.ts","sourceRoot":"","sources":["../../../../src/cli/config/ConfigValidator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,aAAa,EACE,MAAM,0BAA0B,CAAC;AAMlD,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAgBtE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAqCvF;AAoID;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAUvE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGpE;AAED;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;EAK1B,CAAC"}