@adaas/a-utils 0.1.15 → 0.1.16

package/examples/{channel-examples.ts → A-Channel-examples.ts}

@@ -254,7 +254,7 @@ class DatabaseProcessor extends A_Component {
     
     @A_Feature.Extend({ scope: [DatabaseChannel] })
     async [A_ChannelFeatures.onConnect]() {
-        const channel = A_Context.scope(this).resolve(DatabaseChannel);
+        const channel = A_Context.scope(this).resolve(DatabaseChannel)!;
         
         // Initialize connection pool
         for (let i = 0; i < 5; i++) {
@@ -271,7 +271,7 @@ class DatabaseProcessor extends A_Component {
     async [A_ChannelFeatures.onBeforeRequest](
         @A_Inject(A_ChannelRequest) context: A_ChannelRequest<DatabaseQuery>
     ) {
-        const channel = A_Context.scope(this).resolve(DatabaseChannel);
+        const channel = A_Context.scope(this).resolve(DatabaseChannel)!;
         const { operation, table } = context.params;
         
         console.log(`Executing ${operation} on table ${table}`);

package/examples/{command-examples.ts → A-Command-examples.ts}

@@ -6,14 +6,14 @@
  */
 
 import { A_Command } from '../src/lib/A-Command/A-Command.entity';
-import { A_CONSTANTS_A_Command_Features } from '../src/lib/A-Command/A-Command.constants';
+import { A_CommandFeatures } from '../src/lib/A-Command/A-Command.constants';
 import { A_Memory } from '../src/lib/A-Memory/A-Memory.context';
-import { A_Component, A_Context, A_Feature, A_Inject, A_Error } from '@adaas/a-concept';
+import { A_Component, A_Context, A_Feature, A_Inject, A_Error, A_Dependency } from '@adaas/a-concept';
 
 // Example 1: Basic Command Usage
 async function basicCommandExample() {
     console.log('\n=== Basic Command Example ===');
-    
+
     const command = new A_Command({
         action: 'greet',
         name: 'World'
@@ -22,8 +22,8 @@ async function basicCommandExample() {
     A_Context.root.register(command);
 
     // Add event listeners
-    command.on('init', () => console.log('Command initializing...'));
-    command.on('complete', () => console.log('Command completed!'));
+    command.on(A_CommandFeatures.onInit, () => console.log('Command initializing...'));
+    command.on(A_CommandFeatures.onComplete, () => console.log('Command completed!'));
 
     await command.execute();
 
@@ -45,38 +45,38 @@ interface UserCreateResult {
     profileCreated: boolean;
 }
 
-class CreateUserCommand extends A_Command<UserCreateParams, UserCreateResult> {}
+class CreateUserCommand extends A_Command<UserCreateParams, UserCreateResult> { }
 
 class UserCreationService extends A_Component {
-    
+
     @A_Feature.Extend({ scope: [CreateUserCommand] })
-    async [A_CONSTANTS_A_Command_Features.EXECUTE](
+    async [A_CommandFeatures.onExecute](
         @A_Inject(A_Memory) memory: A_Memory<UserCreateResult>
     ) {
-        const command = A_Context.scope(this).resolve(CreateUserCommand);
+        const command = A_Context.scope(this).resolve(CreateUserCommand)!;
         const { name, email, role } = command.params;
-        
+
         console.log(`Creating user: ${name} (${email}) with role: ${role}`);
-        
+
         // Simulate user creation
         const userId = `user_${Date.now()}`;
         const createdAt = new Date().toISOString();
-        
+
         // Store results in memory
         await memory.set('userId', userId);
         await memory.set('createdAt', createdAt);
         await memory.set('profileCreated', true);
-        
+
         console.log(`User created with ID: ${userId}`);
     }
 }
 
 async function typedCommandExample() {
     console.log('\n=== Typed Command with Custom Logic Example ===');
-    
+
     A_Context.reset();
     A_Context.root.register(UserCreationService);
-    
+
     const command = new CreateUserCommand({
         name: 'John Doe',
         email: 'john@example.com',
@@ -92,10 +92,10 @@ async function typedCommandExample() {
 // Example 3: Command Serialization and Persistence
 async function serializationExample() {
     console.log('\n=== Command Serialization Example ===');
-    
+
     A_Context.reset();
     A_Context.root.register(UserCreationService);
-    
+
     // Create and execute original command
     const originalCommand = new CreateUserCommand({
         name: 'Jane Smith',
@@ -116,7 +116,7 @@ async function serializationExample() {
 
     // Restore command from serialized data
     const restoredCommand = new CreateUserCommand(parsedData);
-    
+
     console.log('Command restored from serialization:');
     console.log(`- Status: ${restoredCommand.status}`);
     console.log(`- Duration: ${restoredCommand.duration}ms`);
@@ -125,16 +125,16 @@ async function serializationExample() {
 }
 
 // Example 4: Error Handling
-class FailingCommand extends A_Command<{ shouldFail: boolean }, { success: boolean }> {}
+class FailingCommand extends A_Command<{ shouldFail: boolean }, { success: boolean }> { }
 
 class FailingService extends A_Component {
-    
+
     @A_Feature.Extend({ scope: [FailingCommand] })
-    async [A_CONSTANTS_A_Command_Features.EXECUTE](
+    async [A_CommandFeatures.onExecute](
         @A_Inject(A_Memory) memory: A_Memory<{ success: boolean }>
     ) {
-        const command = A_Context.scope(this).resolve(FailingCommand);
-        
+        const command = A_Context.scope(this).resolve(FailingCommand)!;
+
         if (command.params.shouldFail) {
             // Add error to memory
             await memory.error(new A_Error({
@@ -142,33 +142,33 @@ class FailingService extends A_Component {
                 message: 'This command was designed to fail',
                 code: 'INTENTIONAL_FAIL'
             }));
-            
+
             throw new Error('Command failed as requested');
         }
-        
+
         await memory.set('success', true);
     }
 }
 
 async function errorHandlingExample() {
     console.log('\n=== Error Handling Example ===');
-    
+
     A_Context.reset();
     A_Context.root.register(FailingService);
-    
+
     // Test successful command
     const successCommand = new FailingCommand({ shouldFail: false });
     A_Context.root.register(successCommand);
     await successCommand.execute();
-    
+
     console.log(`Success command - Status: ${successCommand.status}`);
     console.log(`Success command - Result:`, successCommand.result);
-    
+
     // Test failing command
     const failCommand = new FailingCommand({ shouldFail: true });
     A_Context.root.register(failCommand);
     await failCommand.execute();
-    
+
     console.log(`Fail command - Status: ${failCommand.status}`);
     console.log(`Fail command - Is Failed: ${failCommand.isFailed}`);
     console.log(`Fail command - Errors:`, Array.from(failCommand.errors?.values() || []));
@@ -181,30 +181,32 @@ class FileProcessCommand extends A_Command<
     { filePath: string; operation: string },
     { outputPath: string; size: number },
     FileProcessEvents
-> {}
+> { }
 
 class FileProcessor extends A_Component {
-    
+
     @A_Feature.Extend({ scope: [FileProcessCommand] })
-    async [A_CONSTANTS_A_Command_Features.EXECUTE](
-        @A_Inject(A_Memory) memory: A_Memory<{ outputPath: string; size: number }>
+    async [A_CommandFeatures.onExecute](
+        @A_Inject(A_Memory) memory: A_Memory<{ outputPath: string; size: number }>,
+
+        @A_Dependency.Required()
+        @A_Inject(FileProcessCommand) command: FileProcessCommand
     ) {
-        const command = A_Context.scope(this).resolve(FileProcessCommand);
         const { filePath, operation } = command.params;
-        
+
         // Emit custom events during processing
         command.emit('validation-started');
         console.log(`Validating file: ${filePath}`);
         await new Promise(resolve => setTimeout(resolve, 100));
-        
+
         command.emit('processing');
         console.log(`Processing file with operation: ${operation}`);
         await new Promise(resolve => setTimeout(resolve, 200));
-        
+
         command.emit('cleanup');
         console.log('Cleaning up temporary files');
         await new Promise(resolve => setTimeout(resolve, 50));
-        
+
         await memory.set('outputPath', `processed_${filePath}`);
         await memory.set('size', 1024);
     }
@@ -212,10 +214,10 @@ class FileProcessor extends A_Component {
 
 async function customEventsExample() {
     console.log('\n=== Custom Events Example ===');
-    
+
     A_Context.reset();
     A_Context.root.register(FileProcessor);
-    
+
     const command = new FileProcessCommand({
         filePath: 'document.pdf',
         operation: 'compress'
@@ -225,9 +227,9 @@ async function customEventsExample() {
     command.on('validation-started', () => console.log('📋 Validation phase started'));
     command.on('processing', () => console.log('⚙️  Processing phase started'));
     command.on('cleanup', () => console.log('🧹 Cleanup phase started'));
-    
+
     // Subscribe to lifecycle events
-    command.on('complete', () => console.log('✅ File processing completed'));
+    command.on('onComplete', () => console.log('✅ File processing completed'));
 
     A_Context.root.register(command);
     await command.execute();
@@ -238,14 +240,14 @@ async function customEventsExample() {
 // Run all examples
 async function runAllExamples() {
     console.log('🚀 Running A-Command Examples\n');
-    
+
     try {
         await basicCommandExample();
         await typedCommandExample();
         await serializationExample();
         await errorHandlingExample();
         await customEventsExample();
-        
+
         console.log('\n✅ All examples completed successfully!');
     } catch (error) {
         console.error('\n❌ Example failed:', error);

package/examples/A-Logger-examples.ts

@@ -0,0 +1,308 @@
+/**
+ * A-Logger Component Examples
+ * 
+ * This file demonstrates various usage patterns and features of the A_Logger component.
+ * These examples show the logging capabilities without complex dependency injection.
+ */
+
+import { A_Scope, A_Error } from "@adaas/a-concept";
+import { A_Logger } from "../src/lib/A-Logger/A-Logger.component";
+
+// =============================================
+// Basic Logging Examples
+// =============================================
+
+/**
+ * Example 1: Basic Logger Usage
+ */
+function basicLogging() {
+    console.log('\n=== Example 1: Basic Logger Usage ===\n');
+
+    const scope = new A_Scope({ name: 'API-Service' });
+    const logger = new A_Logger(scope);
+
+    // Different log types
+    logger.log('Logger initialized successfully');
+    logger.log('green', 'This is a success message');
+    logger.log('blue', 'This is an info message');
+    logger.warning('This is a warning message');
+    logger.error('This is an error message');
+}
+
+/**
+ * Example 2: Scope Length Alignment Demonstration
+ */
+function scopeLengthDemo() {
+    console.log('\n=== Example 2: Scope Length Alignment ===\n');
+
+    const scopes = [
+        { name: 'DB' },
+        { name: 'Authentication' },
+        { name: 'WebSocketManager' },
+        { name: 'A' },
+        { name: 'VeryLongServiceNameExample' }
+    ];
+
+    scopes.forEach(scopeConfig => {
+        const scope = new A_Scope(scopeConfig);
+        const logger = new A_Logger(scope);
+        logger.log('green', `Message from ${scopeConfig.name}`);
+        logger.warning('Warning message to show alignment');
+    });
+}
+
+/**
+ * Example 3: Object and Data Logging
+ */
+function objectLogging() {
+    console.log('\n=== Example 3: Object and Data Logging ===\n');
+
+    const scope = new A_Scope({ name: 'DataLogger' });
+    const logger = new A_Logger(scope);
+
+    // Simple object
+    const userObject = {
+        id: 1,
+        name: 'John Doe',
+        email: 'john@example.com',
+        preferences: {
+            theme: 'dark',
+            notifications: true
+        }
+    };
+    logger.log('blue', 'User object:', userObject);
+
+    // Array logging
+    const dataArray = [
+        { id: 1, name: 'Item 1' },
+        { id: 2, name: 'Item 2' },
+        { id: 3, name: 'Item 3' }
+    ];
+    logger.log('magenta', 'Data array:', dataArray);
+
+    // Multi-argument logging
+    logger.log('green',
+        'Processing complete:',
+        'Records processed:', 150,
+        'Errors:', 2,
+        'Success rate:', '98.7%'
+    );
+}
+
+/**
+ * Example 4: Error Logging
+ */
+function errorLogging() {
+    console.log('\n=== Example 4: Error Logging ===\n');
+
+    const scope = new A_Scope({ name: 'ErrorHandler' });
+    const logger = new A_Logger(scope);
+
+    // Standard JavaScript Error
+    try {
+        throw new Error('Database connection timeout');
+    } catch (error) {
+        logger.error('Database error occurred:', error);
+    }
+
+    // Simple A_Error
+    const validationError = new A_Error('User input validation failed');
+    logger.error('Validation error:', validationError);
+
+    // Error with context
+    const operationContext = {
+        userId: 'user-12345',
+        operation: 'profile-update',
+        timestamp: new Date().toISOString(),
+        requestId: 'req-abc123'
+    };
+
+    try {
+        throw new Error('Profile update failed: Invalid user permissions');
+    } catch (error) {
+        logger.error(
+            'Operation failed with context:',
+            error,
+            'Context:', operationContext,
+            'Additional info:', 'User may need admin privileges'
+        );
+    }
+}
+
+/**
+ * Example 5: Different Colors and Formatting
+ */
+function colorDemo() {
+    console.log('\n=== Example 5: Color Demonstration ===\n');
+
+    const scope = new A_Scope({ name: 'ColorDemo' });
+    const logger = new A_Logger(scope);
+
+    // All available colors
+    const colors = ['green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'] as const;
+
+    colors.forEach(color => {
+        logger.log(color, `This is a ${color} colored message`);
+    });
+}
+
+/**
+ * Example 6: Performance Logging Simulation
+ */
+async function performanceLogging() {
+    console.log('\n=== Example 6: Performance Logging ===\n');
+
+    const scope = new A_Scope({ name: 'PerformanceMonitor' });
+    const logger = new A_Logger(scope);
+
+    const operations = ['Database Query', 'API Call', 'File Processing', 'Data Validation'];
+
+    for (const operation of operations) {
+        const startTime = Date.now();
+
+        // Simulate work with random delay
+        await new Promise(resolve => setTimeout(resolve, Math.random() * 200 + 50));
+
+        const duration = Date.now() - startTime;
+        const status = duration < 100 ? 'green' : duration < 150 ? 'yellow' : 'red';
+
+        logger.log(status, `${operation} completed:`, {
+            operation,
+            duration: `${duration}ms`,
+            status: duration < 100 ? 'fast' : duration < 150 ? 'normal' : 'slow',
+            timestamp: new Date().toISOString()
+        });
+    }
+}
+
+/**
+ * Example 7: Real-world Service Logging
+ */
+async function serviceLogging() {
+    console.log('\n=== Example 7: Service Logging Simulation ===\n');
+
+    // Create different service loggers
+    const services = {
+        api: new A_Logger(new A_Scope({ name: 'API-Gateway' })),
+        auth: new A_Logger(new A_Scope({ name: 'Auth' })),
+        db: new A_Logger(new A_Scope({ name: 'DatabasePool' })),
+        cache: new A_Logger(new A_Scope({ name: 'Redis-Cache' }))
+    };
+
+    // Simulate user registration flow
+    const userId = 'user-' + Math.random().toString(36).substr(2, 9);
+
+    services.api.log('green', 'Registration request received:', {
+        endpoint: '/api/auth/register',
+        userId,
+        timestamp: new Date().toISOString()
+    });
+
+    services.auth.log('blue', 'Validating user credentials...');
+    await new Promise(resolve => setTimeout(resolve, 50));
+    services.auth.log('green', 'Credentials validated successfully');
+
+    services.db.log('blue', 'Creating user record...');
+    await new Promise(resolve => setTimeout(resolve, 100));
+    services.db.log('green', 'User record created:', { userId, table: 'users' });
+
+    services.cache.log('blue', 'Caching user session...');
+    await new Promise(resolve => setTimeout(resolve, 30));
+    services.cache.log('green', 'Session cached:', { userId, ttl: 3600 });
+
+    services.api.log('green', 'Registration completed successfully:', {
+        userId,
+        totalTime: '180ms',
+        status: 'success'
+    });
+}
+
+/**
+ * Example 8: Complex Object Logging
+ */
+function complexObjectLogging() {
+    console.log('\n=== Example 8: Complex Object Logging ===\n');
+
+    const scope = new A_Scope({ name: 'ComplexLogger' });
+    const logger = new A_Logger(scope);
+
+    const complexObject = {
+        request: {
+            method: 'POST',
+            url: '/api/users',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+                'User-Agent': 'Mozilla/5.0 (compatible; ADAAS-Client/1.0)'
+            },
+            body: {
+                name: 'Jane Smith',
+                email: 'jane@example.com',
+                metadata: {
+                    source: 'web-form',
+                    campaign: 'summer-2024'
+                }
+            }
+        },
+        response: {
+            status: 201,
+            data: {
+                id: 'user-12345',
+                created: '2024-10-29T10:30:00Z'
+            }
+        },
+        timing: {
+            start: 1698574200000,
+            end: 1698574200250,
+            duration: 250
+        }
+    };
+
+    logger.log('blue', 'API Request Complete:', complexObject);
+}
+
+// =============================================
+// Main Execution
+// =============================================
+
+/**
+ * Run all examples
+ */
+async function runAllExamples() {
+    console.log('🚀 A-Logger Component Examples');
+    console.log('==============================\n');
+
+    try {
+        basicLogging();
+        scopeLengthDemo();
+        objectLogging();
+        errorLogging();
+        colorDemo();
+        await performanceLogging();
+        await serviceLogging();
+        complexObjectLogging();
+
+        console.log('\n✅ All examples completed successfully!');
+
+    } catch (error) {
+        console.error('\n❌ Example execution failed:', error);
+    }
+}
+
+// Export functions for individual testing
+export {
+    basicLogging,
+    scopeLengthDemo,
+    objectLogging,
+    errorLogging,
+    colorDemo,
+    performanceLogging,
+    serviceLogging,
+    complexObjectLogging,
+    runAllExamples
+};
+
+// Run examples if this file is executed directly
+if (require.main === module) {
+    runAllExamples();
+}

package/examples/config.ts

@@ -26,7 +26,7 @@ import { A_Polyfill } from "@adaas/a-utils/lib/A-Polyfill/A-Polyfill.component";
     await concept.start();
 
 
-    const config = service1.scope.resolve<A_Config<['ADAAS_SSO_LOCATION']>>(A_Config);
+    const config = service1.scope.resolve<A_Config<['ADAAS_SSO_LOCATION']>>(A_Config)!;
 
     console.log('config: ', config.get('ADAAS_SSO_LOCATION'))
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-utils",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "A-Utils is a set of utilities that are used across the ADAAS ecosystem. This package is designed to be a collection of utilities that are used across the ADAAS ecosystem.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -27,7 +27,8 @@
     "test": "jest ",
     "start": "nodemon ./tests/log.ts",
     "examples:config": "nodemon ./examples/config.ts",
-    "publish": "npm run test && npm run build && git add . && git commit -m \"new version created :: $(cat package.json | grep version | head -1  | awk -F: '{ print $2 }'  | sed 's/[\",]//g')\" && npm version patch && npm publish --access public",
+    "examples:logger": "nodemon ./examples/A-Logger-examples.ts",
+    "release": "npm run test && npm run build && git add . && git commit -m \"new version created :: $(cat package.json | grep version | head -1  | awk -F: '{ print $2 }'  | sed 's/[\",]//g')\" && npm version patch && npm publish --access public",
     "preversion": "echo test",
     "version": "echo git add .",
     "postversion": "git push --no-verify && git push --tags --no-verify && echo \"\n======Version Pushed Successfully=====\n\" ",
@@ -68,7 +69,7 @@
   },
   "homepage": "https://github.com/ADAAS-org/adaas-a-utils#readme",
   "dependencies": {
-    "@adaas/a-concept": "^0.1.24"
+    "@adaas/a-concept": "^0.1.28"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",

package/src/lib/A-Command/A-Command.constants.ts

@@ -1,35 +1,71 @@
-export enum A_TYPES__CommandMetaKey {
-    EXTENSIONS = 'a-command-extensions',
-    FEATURES = 'a-command-features',
-    ABSTRACTIONS = 'a-command-abstractions',
-}
-
+/**
+ * A-Command Statuses
+ */
 export enum A_CONSTANTS__A_Command_Status {
+    /**
+     * Command has been created but not yet initialized
+     */
     CREATED = 'CREATED',
+    /** 
+     * Command is initializing
+     */
     INITIALIZATION = 'INITIALIZATION',
+    /**
+     * Command has been initialized
+     */
     INITIALIZED = 'INITIALIZED',
+    /**
+     * Command is compiling
+     */
     COMPILATION = 'COMPILATION',
+    /**
+     * Command is compiled
+     */
     COMPILED = 'COMPILED',
+    /**
+     * Command is executing
+     */
     IN_PROGRESS = 'IN_PROGRESS',
+    /**
+     * Command has completed successfully
+     */
     COMPLETED = 'COMPLETED',
+    /**
+     * Command has failed
+     */
     FAILED = 'FAILED',
 }
 
 /**
  * A-Command Lifecycle Features
  */
-export enum A_CONSTANTS_A_Command_Features {
-    INIT = 'init',
-    COMPLIED = 'complied',
-    EXECUTE = 'execute',
-    COMPLETE = 'complete',
-    FAIL = 'fail',
+export enum A_CommandFeatures {
+    /**
+     * Allows to extend initialization logic and behavior
+     */
+    onInit = 'onInit',
+    /**
+     * Allows to extend compilation logic and behavior
+     */
+    onCompile = 'onCompile',
+    /**
+     * Allows to extend execution logic and behavior
+     */
+    onExecute = 'onExecute',
+    /**
+     * Allows to extend completion logic and behavior
+     */
+    onComplete = 'onComplete',
+    /**
+     * 
+     */
+    onFail = 'onFail',
 }
 
 
 
 
-export type A_CONSTANTS__A_Command_Event = 'init' | 'compile' | 'execute' | 'complete' | 'fail';
+export type A_CONSTANTS__A_Command_Event = keyof typeof A_CommandFeatures;