@objectstack/core 4.0.4 → 4.0.5

package/src/logger.ts

@@ -1,355 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { LoggerConfig, LogLevel } from '@objectstack/spec/system';
-import type { Logger } from '@objectstack/spec/contracts';
-import { isNode } from './utils/env.js';
-
-/**
- * Universal Logger Implementation
- * 
- * A configurable logger that works in both browser and Node.js environments.
- * - Node.js: Uses Pino for high-performance structured logging
- * - Browser: Simple console-based implementation
- * 
- * Features:
- * - Structured logging with multiple formats (json, text, pretty)
- * - Log level filtering
- * - Sensitive data redaction
- * - File logging with rotation (Node.js only via Pino)
- * - Browser console integration
- * - Distributed tracing support (traceId, spanId)
- */
-export class ObjectLogger implements Logger {
-    private config: Required<Omit<LoggerConfig, 'file' | 'rotation' | 'name'>> & { file?: string; rotation?: { maxSize: string; maxFiles: number }; name?: string };
-    private isNode: boolean;
-    private pinoLogger?: any; // Pino logger instance for Node.js
-    private pinoInstance?: any; // Base Pino instance for creating child loggers
-    private require?: any; // CommonJS require function for Node.js
-
-    constructor(config: Partial<LoggerConfig> = {}) {
-        // Detect runtime environment
-        this.isNode = isNode;
-
-        // Set defaults
-        this.config = {
-            name: config.name,
-            level: config.level ?? 'info',
-            format: config.format ?? (this.isNode ? 'json' : 'pretty'),
-            redact: config.redact ?? ['password', 'token', 'secret', 'key'],
-            sourceLocation: config.sourceLocation ?? false,
-            file: config.file,
-            rotation: config.rotation ?? {
-                maxSize: '10m',
-                maxFiles: 5
-            }
-        };
-
-        // Initialize Pino logger for Node.js
-        if (this.isNode) {
-            this.initPinoLogger();
-        }
-    }
-
-    /**
-     * Initialize Pino logger for Node.js
-     */
-    private async initPinoLogger() {
-        if (!this.isNode) return;
-
-        try {
-            // Create require function dynamically for Node.js (avoids bundling issues in browser)
-            // @ts-ignore - dynamic import of Node.js module
-            const { createRequire } = await import('module');
-            this.require = createRequire(import.meta.url);
-            
-            // Synchronous import for Pino using createRequire (works in ESM)
-            const pino = this.require('pino');
-            
-            // Build Pino options
-            const pinoOptions: any = {
-                level: this.config.level,
-                redact: {
-                    paths: this.config.redact,
-                    censor: '***REDACTED***'
-                }
-            };
-
-            // Add name if provided
-            if (this.config.name) {
-                pinoOptions.name = this.config.name;
-            }
-
-            // Transport configuration for pretty printing or file output
-            const targets: any[] = [];
-
-            // Console transport
-            if (this.config.format === 'pretty') {
-                // Check if pino-pretty is available
-                let hasPretty = false;
-                try {
-                    this.require.resolve('pino-pretty');
-                    hasPretty = true;
-                } catch (e) {
-                    // ignore
-                }
-
-                if (hasPretty) {
-                    targets.push({
-                        target: 'pino-pretty',
-                        options: {
-                            colorize: true,
-                            translateTime: 'SYS:standard',
-                            ignore: 'pid,hostname'
-                        },
-                        level: this.config.level
-                    });
-                } else {
-                     console.warn('[Logger] pino-pretty not found. Install it for pretty logging: pnpm add -D pino-pretty');
-                     // Fallback to text/simple
-                     targets.push({
-                        target: 'pino/file',
-                        options: { destination: 1 },
-                        level: this.config.level
-                    });
-                }
-            } else if (this.config.format === 'json') {
-                // JSON to stdout
-                targets.push({
-                    target: 'pino/file',
-                    options: { destination: 1 }, // stdout
-                    level: this.config.level
-                });
-            } else {
-                // text format (simple)
-                targets.push({
-                    target: 'pino/file',
-                    options: { destination: 1 },
-                    level: this.config.level
-                });
-            }
-
-            // File transport (if configured)
-            if (this.config.file) {
-                targets.push({
-                    target: 'pino/file',
-                    options: {
-                        destination: this.config.file,
-                        mkdir: true
-                    },
-                    level: this.config.level
-                });
-            }
-
-            // Create transport
-            if (targets.length > 0) {
-                pinoOptions.transport = targets.length === 1 ? targets[0] : { targets };
-            }
-
-            // Create Pino logger
-            this.pinoInstance = pino(pinoOptions);
-            this.pinoLogger = this.pinoInstance;
-
-        } catch (error) {
-            // Fallback to console if Pino is not available
-            console.warn('[Logger] Pino not available, falling back to console:', error);
-            this.pinoLogger = null;
-        }
-    }
-
-    /**
-     * Redact sensitive keys from context object (for browser)
-     */
-    private redactSensitive(obj: any): any {
-        if (!obj || typeof obj !== 'object') return obj;
-
-        const redacted = Array.isArray(obj) ? [...obj] : { ...obj };
-
-        for (const key in redacted) {
-            const lowerKey = key.toLowerCase();
-            const shouldRedact = this.config.redact.some((pattern: string) => 
-                lowerKey.includes(pattern.toLowerCase())
-            );
-
-            if (shouldRedact) {
-                redacted[key] = '***REDACTED***';
-            } else if (typeof redacted[key] === 'object' && redacted[key] !== null) {
-                redacted[key] = this.redactSensitive(redacted[key]);
-            }
-        }
-
-        return redacted;
-    }
-
-    /**
-     * Format log entry for browser
-     */
-    private formatBrowserLog(level: LogLevel, message: string, context?: Record<string, any>): string {
-        if (this.config.format === 'json') {
-            return JSON.stringify({
-                timestamp: new Date().toISOString(),
-                level,
-                message,
-                ...context
-            });
-        }
-
-        if (this.config.format === 'text') {
-            const parts = [new Date().toISOString(), level.toUpperCase(), message];
-            if (context && Object.keys(context).length > 0) {
-                parts.push(JSON.stringify(context));
-            }
-            return parts.join(' | ');
-        }
-
-        // Pretty format
-        const levelColors: Record<LogLevel, string> = {
-            debug: '\x1b[36m',   // Cyan
-            info: '\x1b[32m',    // Green
-            warn: '\x1b[33m',    // Yellow
-            error: '\x1b[31m',   // Red
-            fatal: '\x1b[35m',   // Magenta
-            silent: ''
-        };
-        const reset = '\x1b[0m';
-        const color = levelColors[level] || '';
-
-        let output = `${color}[${level.toUpperCase()}]${reset} ${message}`;
-        
-        if (context && Object.keys(context).length > 0) {
-            output += ` ${JSON.stringify(context, null, 2)}`;
-        }
-
-        return output;
-    }
-
-    /**
-     * Log using browser console
-     */
-    private logBrowser(level: LogLevel, message: string, context?: Record<string, any>, error?: Error) {
-        const redactedContext = context ? this.redactSensitive(context) : undefined;
-        const mergedContext = error ? { ...redactedContext, error: { message: error.message, stack: error.stack } } : redactedContext;
-        
-        const formatted = this.formatBrowserLog(level, message, mergedContext);
-        
-        const consoleMethod = level === 'debug' ? 'debug' :
-                            level === 'info' ? 'log' :
-                            level === 'warn' ? 'warn' :
-                            level === 'error' || level === 'fatal' ? 'error' :
-                            'log';
-        
-        console[consoleMethod](formatted);
-    }
-
-    /**
-     * Public logging methods
-     */
-    debug(message: string, meta?: Record<string, any>): void {
-        if (this.isNode && this.pinoLogger) {
-            this.pinoLogger.debug(meta || {}, message);
-        } else {
-            this.logBrowser('debug', message, meta);
-        }
-    }
-
-    info(message: string, meta?: Record<string, any>): void {
-        if (this.isNode && this.pinoLogger) {
-            this.pinoLogger.info(meta || {}, message);
-        } else {
-            this.logBrowser('info', message, meta);
-        }
-    }
-
-    warn(message: string, meta?: Record<string, any>): void {
-        if (this.isNode && this.pinoLogger) {
-            this.pinoLogger.warn(meta || {}, message);
-        } else {
-            this.logBrowser('warn', message, meta);
-        }
-    }
-
-    error(message: string, errorOrMeta?: Error | Record<string, any>, meta?: Record<string, any>): void {
-        let error: Error | undefined;
-        let context: Record<string, any> = {};
-
-        if (errorOrMeta instanceof Error) {
-            error = errorOrMeta;
-            context = meta || {};
-        } else {
-             context = errorOrMeta || {};
-        }
-
-        if (this.isNode && this.pinoLogger) {
-            const errorContext = error ? { err: error, ...context } : context;
-            this.pinoLogger.error(errorContext, message);
-        } else {
-            this.logBrowser('error', message, context, error);
-        }
-    }
-
-    fatal(message: string, errorOrMeta?: Error | Record<string, any>, meta?: Record<string, any>): void {
-        let error: Error | undefined;
-        let context: Record<string, any> = {};
-
-        if (errorOrMeta instanceof Error) {
-            error = errorOrMeta;
-            context = meta || {};
-        } else {
-             context = errorOrMeta || {};
-        }
-
-        if (this.isNode && this.pinoLogger) {
-            const errorContext = error ? { err: error, ...context } : context;
-            this.pinoLogger.fatal(errorContext, message);
-        } else {
-            this.logBrowser('fatal', message, context, error);
-        }
-    }
-
-    /**
-     * Create a child logger with additional context
-     * Note: Child loggers share the parent's Pino instance
-     */
-    child(context: Record<string, any>): ObjectLogger {
-        const childLogger = new ObjectLogger(this.config);
-        
-        // For Node.js with Pino, create a Pino child logger
-        if (this.isNode && this.pinoInstance) {
-            childLogger.pinoLogger = this.pinoInstance.child(context);
-            childLogger.pinoInstance = this.pinoInstance;
-        }
-
-        return childLogger;
-    }
-
-    /**
-     * Set trace context for distributed tracing
-     */
-    withTrace(traceId: string, spanId?: string): ObjectLogger {
-        return this.child({ traceId, spanId });
-    }
-
-    /**
-     * Cleanup resources
-     */
-    async destroy(): Promise<void> {
-        if (this.pinoLogger && this.pinoLogger.flush) {
-            await new Promise<void>((resolve) => {
-                this.pinoLogger.flush(() => resolve());
-            });
-        }
-    }
-
-    /**
-     * Compatibility method for console.log usage
-     */
-    log(message: string, ...args: any[]): void {
-        this.info(message, args.length > 0 ? { args } : undefined);
-    }
-}
-
-/**
- * Create a logger instance
- */
-export function createLogger(config?: Partial<LoggerConfig>): ObjectLogger {
-    return new ObjectLogger(config);
-}

package/src/namespace-resolver.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { NamespaceResolver } from './namespace-resolver.js';
-import { createLogger } from './logger.js';
-
-describe('NamespaceResolver', () => {
-  let resolver: NamespaceResolver;
-
-  beforeEach(() => {
-    const logger = createLogger({ level: 'silent' });
-    resolver = new NamespaceResolver(logger);
-  });
-
-  describe('register', () => {
-    it('should register namespaces for a package', () => {
-      resolver.register('pkg-a', ['objects.task', 'views.task_list']);
-
-      const registry = resolver.getRegistry();
-      expect(registry.size).toBe(2);
-      expect(registry.get('objects.task')?.packageId).toBe('pkg-a');
-      expect(registry.get('views.task_list')?.packageId).toBe('pkg-a');
-    });
-
-    it('should overwrite namespace when same package re-registers', () => {
-      resolver.register('pkg-a', ['objects.task']);
-      resolver.register('pkg-a', ['objects.task']);
-
-      expect(resolver.getRegistry().size).toBe(1);
-      expect(resolver.getRegistry().get('objects.task')?.packageId).toBe('pkg-a');
-    });
-  });
-
-  describe('unregister', () => {
-    it('should remove all namespaces for a package', () => {
-      resolver.register('pkg-a', ['objects.task', 'views.task_list']);
-      resolver.register('pkg-b', ['objects.project']);
-
-      const removed = resolver.unregister('pkg-a');
-      expect(removed).toEqual(['objects.task', 'views.task_list']);
-      expect(resolver.getRegistry().size).toBe(1);
-      expect(resolver.getRegistry().has('objects.project')).toBe(true);
-    });
-
-    it('should return empty array for unknown package', () => {
-      const removed = resolver.unregister('unknown');
-      expect(removed).toEqual([]);
-    });
-  });
-
-  describe('checkAvailability', () => {
-    it('should report no conflicts for unused namespaces', () => {
-      const result = resolver.checkAvailability('pkg-a', ['objects.task']);
-      expect(result.available).toBe(true);
-      expect(result.conflicts).toHaveLength(0);
-    });
-
-    it('should detect conflict with another package', () => {
-      resolver.register('pkg-a', ['objects.task']);
-
-      const result = resolver.checkAvailability('pkg-b', ['objects.task']);
-      expect(result.available).toBe(false);
-      expect(result.conflicts).toHaveLength(1);
-      expect(result.conflicts[0].namespace).toBe('objects.task');
-      expect(result.conflicts[0].existingPackageId).toBe('pkg-a');
-      expect(result.conflicts[0].incomingPackageId).toBe('pkg-b');
-    });
-
-    it('should not conflict with own namespaces', () => {
-      resolver.register('pkg-a', ['objects.task']);
-
-      const result = resolver.checkAvailability('pkg-a', ['objects.task']);
-      expect(result.available).toBe(true);
-    });
-
-    it('should provide suggestions for conflicts', () => {
-      resolver.register('pkg-a', ['objects.task']);
-
-      const result = resolver.checkAvailability('@myorg/plugin-crm', ['objects.task']);
-      expect(result.available).toBe(false);
-      expect(result.suggestions['objects.task']).toBeDefined();
-      expect(result.suggestions['objects.task']).toContain('crm');
-    });
-  });
-
-  describe('extractNamespaces', () => {
-    it('should extract namespaces from object-style metadata', () => {
-      const config = {
-        objects: { task: {}, project: {} },
-        views: { task_list: {} },
-      };
-
-      const ns = resolver.extractNamespaces(config);
-      expect(ns).toContain('objects.task');
-      expect(ns).toContain('objects.project');
-      expect(ns).toContain('views.task_list');
-      expect(ns).toHaveLength(3);
-    });
-
-    it('should extract namespaces from array-style metadata', () => {
-      const config = {
-        objects: [{ name: 'task' }, { name: 'project' }],
-        flows: [{ name: 'approval_flow' }],
-      };
-
-      const ns = resolver.extractNamespaces(config);
-      expect(ns).toContain('objects.task');
-      expect(ns).toContain('objects.project');
-      expect(ns).toContain('flows.approval_flow');
-      expect(ns).toHaveLength(3);
-    });
-
-    it('should return empty array for empty config', () => {
-      const ns = resolver.extractNamespaces({});
-      expect(ns).toEqual([]);
-    });
-  });
-
-  describe('getPackageNamespaces', () => {
-    it('should return namespaces for a specific package', () => {
-      resolver.register('pkg-a', ['objects.task', 'views.task_list']);
-      resolver.register('pkg-b', ['objects.project']);
-
-      expect(resolver.getPackageNamespaces('pkg-a')).toEqual(['objects.task', 'views.task_list']);
-      expect(resolver.getPackageNamespaces('pkg-b')).toEqual(['objects.project']);
-    });
-
-    it('should return empty for unknown package', () => {
-      expect(resolver.getPackageNamespaces('unknown')).toEqual([]);
-    });
-  });
-});

package/src/namespace-resolver.ts

@@ -1,188 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type { ObjectLogger } from './logger.js';
-
-/**
- * Namespace entry representing an object/view/flow etc. registered by a package.
- */
-export interface NamespaceEntry {
-  /** The namespace path (e.g. "objects.project_task", "views.task_list") */
-  namespace: string;
-  /** The package that owns this namespace */
-  packageId: string;
-  /** When this entry was registered */
-  registeredAt: string;
-}
-
-/**
- * Result of a namespace conflict check.
- */
-export interface NamespaceConflict {
-  /** The conflicting namespace path */
-  namespace: string;
-  /** The package that currently owns this namespace */
-  existingPackageId: string;
-  /** The package attempting to register the same namespace */
-  incomingPackageId: string;
-  /** A suggested alternative name to avoid the conflict */
-  suggestion?: string;
-}
-
-/**
- * Result of namespace availability check.
- */
-export interface NamespaceCheckResult {
-  /** Whether all requested namespaces are available */
-  available: boolean;
-  /** List of conflicts detected */
-  conflicts: NamespaceConflict[];
-  /** Suggested alternatives for each conflict */
-  suggestions: Record<string, string>;
-}
-
-/**
- * Namespace Resolver
- *
- * Manages namespace registration for installed packages and detects collisions
- * during install-time. Each metadata item (object, view, flow, page, etc.)
- * produces a namespace like `objects.<name>` or `views.<name>`.
- *
- * When a new package declares objects, views, or other metadata that would
- * collide with an existing package's metadata, this resolver reports the
- * conflicts and suggests prefixed alternatives.
- */
-export class NamespaceResolver {
-  private logger: ObjectLogger;
-  private registry: Map<string, NamespaceEntry> = new Map();
-
-  constructor(logger: ObjectLogger) {
-    this.logger = logger.child({ component: 'NamespaceResolver' });
-  }
-
-  /**
-   * Register namespaces owned by a package.
-   */
-  register(packageId: string, namespaces: string[]): void {
-    const now = new Date().toISOString();
-    for (const ns of namespaces) {
-      if (this.registry.has(ns)) {
-        const existing = this.registry.get(ns)!;
-        if (existing.packageId !== packageId) {
-          this.logger.warn('Overwriting namespace entry', { namespace: ns, existing: existing.packageId, incoming: packageId });
-        }
-      }
-      this.registry.set(ns, { namespace: ns, packageId, registeredAt: now });
-      this.logger.debug('Namespace registered', { namespace: ns, packageId });
-    }
-  }
-
-  /**
-   * Unregister all namespaces belonging to a package.
-   */
-  unregister(packageId: string): string[] {
-    const removed: string[] = [];
-    for (const [ns, entry] of this.registry) {
-      if (entry.packageId === packageId) {
-        this.registry.delete(ns);
-        removed.push(ns);
-      }
-    }
-    this.logger.debug('Namespaces unregistered', { packageId, count: removed.length });
-    return removed;
-  }
-
-  /**
-   * Check whether a set of namespaces is available for a given package.
-   */
-  checkAvailability(packageId: string, namespaces: string[]): NamespaceCheckResult {
-    const conflicts: NamespaceConflict[] = [];
-    const suggestions: Record<string, string> = {};
-
-    for (const ns of namespaces) {
-      const existing = this.registry.get(ns);
-      if (existing && existing.packageId !== packageId) {
-        const suggestion = this.suggestAlternative(ns, packageId);
-        conflicts.push({
-          namespace: ns,
-          existingPackageId: existing.packageId,
-          incomingPackageId: packageId,
-          suggestion,
-        });
-        suggestions[ns] = suggestion;
-      }
-    }
-
-    return {
-      available: conflicts.length === 0,
-      conflicts,
-      suggestions,
-    };
-  }
-
-  /**
-   * Extract namespace strings from a package's metadata definition.
-   */
-  extractNamespaces(config: Record<string, unknown>): string[] {
-    const namespaces: string[] = [];
-    const categories = [
-      'objects', 'views', 'pages', 'flows', 'workflows',
-      'apps', 'dashboards', 'reports', 'actions', 'agents',
-    ];
-
-    for (const category of categories) {
-      const items = config[category];
-      if (Array.isArray(items)) {
-        for (const item of items) {
-          const name = (item as Record<string, unknown>)?.name;
-          if (typeof name === 'string') {
-            namespaces.push(`${category}.${name}`);
-          }
-        }
-      } else if (items && typeof items === 'object') {
-        for (const key of Object.keys(items as object)) {
-          namespaces.push(`${category}.${key}`);
-        }
-      }
-    }
-
-    return namespaces;
-  }
-
-  /**
-   * Get all registered entries.
-   */
-  getRegistry(): ReadonlyMap<string, NamespaceEntry> {
-    return this.registry;
-  }
-
-  /**
-   * Get all namespaces belonging to a specific package.
-   */
-  getPackageNamespaces(packageId: string): string[] {
-    const namespaces: string[] = [];
-    for (const [ns, entry] of this.registry) {
-      if (entry.packageId === packageId) {
-        namespaces.push(ns);
-      }
-    }
-    return namespaces;
-  }
-
-  /**
-   * Generate a prefixed alternative namespace to avoid conflicts.
-   */
-  private suggestAlternative(ns: string, packageId: string): string {
-    // Extract the short package name for prefixing
-    const shortName = packageId
-      .replace(/^@[^/]+\//, '')
-      .replace(/^plugin-/, '')
-      .replace(/-/g, '_');
-
-    const parts = ns.split('.');
-    if (parts.length >= 2) {
-      // e.g. "objects.task" → "objects.crm_task"
-      return `${parts[0]}.${shortName}_${parts.slice(1).join('.')}`;
-    }
-    return `${shortName}_${ns}`;
-  }
-}