@jammysunshine/astrology-shared 1.0.1

package/logger/index.js

@@ -0,0 +1,417 @@
+/**
+ * Universal Logger - Works in both Node.js (backend) and browser (frontend) environments
+ * Uses winston/pino in backend when available, console in frontend or as fallback
+ */
+
+let loggerInstance = null;
+
+/**
+ * Detect environment and create appropriate logger
+ */
+function createLogger() {
+  // Check if we're in Node.js environment
+  const isNode = typeof window === 'undefined' && typeof process !== 'undefined';
+
+  if (isNode) {
+    // Backend: Try to use winston or pino, fallback to console
+    try {
+      // Try winston first (look in various locations)
+      let winston;
+      try {
+        winston = require('winston');
+      } catch (e) {
+        // Try relative to backend directory
+        try {
+          winston = require('../backend/node_modules/winston');
+        } catch (e2) {
+          // Try from current working directory
+          try {
+            const path = require('path');
+            const backendPath = path.join(process.cwd(), 'packages', 'backend', 'node_modules', 'winston');
+            winston = require(backendPath);
+          } catch (e3) {
+            // Winston not available, try pino
+            throw new Error('Winston not found');
+          }
+        }
+      }
+      return createWinstonLogger(winston);
+    } catch (winstonError) {
+      try {
+        // Try pino
+        const pino = require('pino');
+        return createPinoLogger(pino);
+      } catch (pinoError) {
+        // Fallback to console if neither is available
+        return createConsoleLogger();
+      }
+    }
+  } else {
+    // Frontend: Use console-based logger
+    return createConsoleLogger();
+  }
+}
+
+/**
+ * Generates a timestamp string in the local timezone.
+ * Format: YYYY-MM-DD-HH-mm-ss
+ */
+function getLocalTimestamp() {
+  const d = new Date();
+  const pad = (num) => num.toString().padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}-${pad(d.getHours())}-${pad(d.getMinutes())}-${pad(d.getSeconds())}`;
+}
+
+/**
+ * Create winston-based logger for backend
+ */
+function createWinstonLogger(winston) {
+  try {
+    const transports = [
+      // Console transport should always be available for debugging
+      new winston.transports.Console({
+        level: process.env.LOG_LEVEL || 'debug', // Use the same level as file logs for consistency
+        format: winston.format.combine(
+          winston.format.colorize(),
+          winston.format.simple()
+        )
+      })
+    ];
+
+    // Add Better Stack HTTP transport if token is provided
+    if (process.env.BETTERSTACK_SOURCE_TOKEN) {
+      try {
+        // Use HTTP transport instead of Logtail WebSocket
+        const https = require('https');
+        const http = require('http');
+
+        class BetterStackHttpTransport extends winston.Transport {
+          constructor(opts) {
+            super(opts);
+            this.endpoint = opts.endpoint || 'https://s1638078.eu-nbg-2.betterstackdata.com';
+            this.token = opts.token;
+          }
+
+          log(info, callback) {
+            const payload = {
+              dt: new Date().toISOString(),
+              message: info.message,
+              level: info.level,
+              ...info
+            };
+
+            const data = JSON.stringify(payload);
+            const url = new URL(this.endpoint);
+
+            const options = {
+              hostname: url.hostname,
+              port: url.port || (url.protocol === 'https:' ? 443 : 80),
+              path: url.pathname,
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.token}`,
+                'Content-Length': Buffer.byteLength(data)
+              },
+              timeout: parseInt(process.env.LOGGER_HTTP_TIMEOUT || '5000')
+            };
+
+            let called = false;
+            const done = () => {
+              if (!called) {
+                called = true;
+                callback();
+              }
+            };
+
+            const req = (url.protocol === 'https:' ? https : http).request(options, (res) => {
+              // Consume response data to prevent memory leaks and handle 'end'
+              res.on('data', () => {});
+              res.on('end', () => done());
+            });
+
+            req.on('error', (err) => {
+              // Silent fail for logging transport, but ensure callback is called
+              done();
+            });
+
+            req.on('timeout', () => {
+              req.destroy();
+              done();
+            });
+
+            req.write(data);
+            req.end();
+          }
+        }
+
+        transports.push(new BetterStackHttpTransport({
+          token: process.env.BETTERSTACK_SOURCE_TOKEN.trim(),
+          level: process.env.LOG_LEVEL || 'info'
+        }));
+        console.log('✅ Better Stack (HTTP) logging transport enabled');
+      } catch (error) {
+        console.log('❌ Better Stack HTTP transport failed:', error.message);
+      }
+    }
+
+    // Always add file transport in all environments (not just production)
+    // Note: Console transport is separate and will continue to work alongside file transports
+    // Remove the environment check to ensure logging works in all environments
+    try {
+      const path = require('path');
+      const logDir = process.env.LOGS_DIR || path.join(process.cwd(), 'logs');
+
+      // Ensure log directory exists
+      const fs = require('fs');
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+
+      /**
+       * Cleans up old log files, keeping only the most recent 'keepCount' files
+       * for both 'error-' and 'server-' prefixed logs.
+       */
+      function cleanOldLogFiles(directory, keepCount = 4) {
+        fs.readdir(directory, (err, files) => {
+          if (err) {
+            console.error('Error reading log directory:', err);
+            return;
+          }
+
+          const errorLogs = [];
+          const serverLogs = [];
+
+          files.forEach(file => {
+            const filePath = path.join(directory, file);
+            // Regex to match 'error-YYYY-MM-DD-HH-mm-ss.log' or 'server-YYYY-MM-DD-HH-mm-ss.log'
+            const errorMatch = file.match(/^error-(\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2})\.log$/);
+            const serverMatch = file.match(/^server-(\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2})\.log$/);
+
+            if (errorMatch) {
+              errorLogs.push({ file, timestamp: errorMatch[1], path: filePath });
+            } else if (serverMatch) {
+              serverLogs.push({ file, timestamp: serverMatch[1], path: filePath });
+            }
+          });
+
+          // Sort logs by timestamp (oldest first)
+          errorLogs.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+          serverLogs.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+
+          // Delete oldest error logs
+          for (let i = 0; i < errorLogs.length - keepCount; i++) {
+            fs.unlink(errorLogs[i].path, (err) => {
+              if (err) console.error('Error deleting old error log file:', errorLogs[i].file, err);
+            });
+          }
+
+          // Delete oldest server logs
+          for (let i = 0; i < serverLogs.length - keepCount; i++) {
+            fs.unlink(serverLogs[i].path, (err) => {
+              if (err) console.error('Error deleting old server log file:', serverLogs[i].file, err);
+            });
+          }
+        });
+      }
+
+      // Call the cleanup function on startup
+      cleanOldLogFiles(logDir);
+
+      // Generate a unique timestamp for each run to ensure different log files per execution
+      const runTimestamp = getLocalTimestamp();
+
+      const errorFile = path.join(logDir, `error-${runTimestamp}.log`);
+      const serverFile = path.join(logDir, `server-${runTimestamp}.log`);
+
+      transports.push(new winston.transports.File({
+        filename: errorFile,
+        level: 'error',
+        format: winston.format.combine(
+          winston.format.timestamp(),
+          winston.format.errors({ stack: true }),
+          winston.format.json()
+        )
+      }));
+
+      transports.push(new winston.transports.File({
+        filename: serverFile,
+        level: process.env.LOG_LEVEL || 'info', // Changed default from 'debug' to 'info'
+        format: winston.format.combine(
+          winston.format.timestamp(),
+          winston.format.json()
+        )
+      }));
+    } catch (error) {
+      console.error('❌ Error creating file transports:', error.message);
+    }
+
+    const logger = winston.createLogger({
+      level: process.env.LOG_LEVEL || 'debug', // Changed from 'info' to 'debug' to ensure all logs are processed
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.errors({ stack: true }),
+        winston.format.json()
+      ),
+      defaultMeta: { service: 'astrology-shared' },
+      transports: transports
+    });
+
+    return {
+      debug: (message, meta = {}) => logger.debug(message, meta),
+      info: (message, meta = {}) => logger.info(message, meta),
+      warn: (message, meta = {}) => logger.warn(message, meta),
+      error: (message, meta = {}) => logger.error(message, meta),
+
+      // Additional methods for compatibility
+      log: (level, message, meta = {}) => logger.log(level, message, meta),
+      child: (meta) => logger.child(meta)
+    };
+  } catch (error) {
+    console.error('Failed to create winston logger, falling back to console:', error);
+    return createConsoleLogger();
+  }
+}
+
+/**
+ * Create pino-based logger for backend
+ */
+function createPinoLogger(pino) {
+  try {
+    const logger = pino({
+      level: process.env.LOG_LEVEL || 'info',
+      timestamp: pino.stdTimeFunctions.isoTime,
+      base: { service: 'astrology-shared' }
+    });
+
+    return {
+      debug: (message, meta = {}) => logger.debug(meta, message),
+      info: (message, meta = {}) => logger.info(meta, message),
+      warn: (message, meta = {}) => logger.warn(meta, message),
+      error: (message, meta = {}) => logger.error(meta, message),
+
+      // Additional methods for compatibility
+      log: (level, message, meta = {}) => logger[level](meta, message),
+      child: (meta) => logger.child(meta)
+    };
+  } catch (error) {
+    console.error('Failed to create pino logger, falling back to console:', error);
+    return createConsoleLogger();
+  }
+}
+
+/**
+ * Create console-based logger for frontend or fallback
+ */
+function createConsoleLogger() {
+  const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+  const configuredLogLevel = process.env.LOG_LEVEL?.toLowerCase() || 'info';
+  const configuredLogLevelIndex = LOG_LEVELS.indexOf(configuredLogLevel);
+
+  // If the configured level is not found, default to 'info'
+  const effectiveLogLevelIndex = configuredLogLevelIndex !== -1 ? configuredLogLevelIndex : LOG_LEVELS.indexOf('info');
+
+  const getTimestamp = () => new Date().toISOString();
+  const formatMessage = (level, message, meta = {}) => {
+    const timestamp = getTimestamp();
+    const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : '';
+    return `[${timestamp}] ${level.toUpperCase()}: ${message}${metaStr}`;
+  };
+
+  return {
+    debug: (message, meta = {}) => {
+      if (effectiveLogLevelIndex <= LOG_LEVELS.indexOf('debug')) {
+        // Using the built-in console.debug
+        console.debug(formatMessage('debug', message, meta));
+      }
+    },
+    info: (message, meta = {}) => {
+      if (effectiveLogLevelIndex <= LOG_LEVELS.indexOf('info')) {
+        // Using the built-in console.info
+        console.info(formatMessage('info', message, meta));
+      }
+    },
+    warn: (message, meta = {}) => {
+      if (effectiveLogLevelIndex <= LOG_LEVELS.indexOf('warn')) {
+        // Using the built-in console.warn
+        console.warn(formatMessage('warn', message, meta));
+      }
+    },
+    error: (message, meta = {}) => {
+      if (effectiveLogLevelIndex <= LOG_LEVELS.indexOf('error')) {
+        // Using the built-in console.error
+        console.error(formatMessage('error', message, meta));
+      }
+    },
+
+    // Additional methods for compatibility
+    log: (level, message, meta = {}) => {
+      const levelIndex = LOG_LEVELS.indexOf(level);
+      if (effectiveLogLevelIndex <= levelIndex) {
+        const method = level in console ? level : 'log';
+        console[method](formatMessage(level, message, meta));
+      }
+    },
+    child: (meta) => {
+      // Return a child logger with additional meta
+      const parentLogger = createConsoleLogger();
+      const childLogger = {
+        debug: (msg, additionalMeta = {}) => parentLogger.debug(msg, { ...meta, ...additionalMeta }),
+        info: (msg, additionalMeta = {}) => parentLogger.info(msg, { ...meta, ...additionalMeta }),
+        warn: (msg, additionalMeta = {}) => parentLogger.warn(msg, { ...meta, ...additionalMeta }),
+        error: (msg, additionalMeta = {}) => parentLogger.error(msg, { ...meta, ...additionalMeta }),
+        log: (level, msg, additionalMeta = {}) => parentLogger.log(level, msg, { ...meta, ...additionalMeta }),
+        child: (moreMeta) => parentLogger.child({ ...meta, ...moreMeta })
+      };
+      return childLogger;
+    }
+  };
+}
+
+/**
+ * Get the logger instance (singleton)
+ */
+function getLogger(serviceName = null) {
+  // For unified runner, always return a simple console logger to avoid test noise
+  if (process.argv.some(arg => arg.includes('unified.runner'))) {
+    return createConsoleLogger();
+  }
+
+  if (!loggerInstance) {
+    try {
+      loggerInstance = createLogger();
+    } catch (error) {
+      console.error('Failed to create logger:', error);
+      // Fallback to a minimal logger
+      loggerInstance = createConsoleLogger();
+    }
+  }
+
+  // Return child logger with service name if provided
+  if (serviceName) {
+    try {
+      return loggerInstance.child({ service: serviceName });
+    } catch (error) {
+      console.error(`Failed to create child logger for ${serviceName}:`, error);
+      return loggerInstance;
+    }
+  }
+
+  return loggerInstance;
+}
+
+/**
+ * Create a named logger for a specific service/component
+ */
+function createNamedLogger(name, additionalMeta = {}) {
+  const baseLogger = getLogger();
+  return baseLogger.child({ component: name, ...additionalMeta });
+}
+
+// Export the logger
+module.exports = {
+  getLogger,
+  createNamedLogger,
+  // For convenience, export the default logger
+  default: getLogger()
+};

package/logger/test_fix.js

@@ -0,0 +1,56 @@
+const winston = require('winston');
+const { EventEmitter } = require('events');
+
+class BetterStackHttpTransport extends winston.Transport {
+  constructor(opts) {
+    super(opts);
+  }
+
+  log(info, callback) {
+    // --- START OF FIXED LOGIC ---
+    let called = false;
+    const done = () => {
+      if (!called) {
+        called = true;
+        console.log('✅ Callback called safely (first time)');
+        callback();
+      } else {
+        console.log('⚠️  Safety Lock engaged: Prevented second callback execution!');
+      }
+    };
+
+    // 1. Mocking the request object
+    const mockReq = new EventEmitter();
+    mockReq.write = () => {};
+    mockReq.end = () => {};
+    mockReq.destroy = () => {};
+
+    // 2. Attach the error listener (Just like the real code)
+    mockReq.on('error', (err) => {
+      console.log('Event: error received');
+      done();
+    });
+
+    // 3. --- SIMULATE THE RACE CONDITION ---
+    
+    // Simulate Response event finishing
+    console.log('Action: Triggering Response finish...');
+    done(); 
+
+    // Simulate Error event firing immediately after
+    console.log('Action: Triggering Error event...');
+    mockReq.emit('error', new Error('Simulated socket error'));
+    
+    // --- END OF SIMULATION ---
+  }
+}
+
+// Execute the test
+console.log('--- Logger Defect Verification Test ---');
+const transport = new BetterStackHttpTransport();
+
+transport.log({ message: 'test' }, () => {
+    console.log('Status: Winston acknowledged the log.');
+});
+
+console.log('\nFinal Check: If you see "Safety Lock engaged" above, the fix is PROVEN.');

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@jammysunshine/astrology-shared",
+  "version": "1.0.1",
+  "description": "Shared utilities for astrology applications (backend and frontend)",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "astrology",
+    "validation",
+    "logging",
+    "shared"
+  ],
+  "author": "Astrology Team",
+  "license": "MIT",
+  "dependencies": {
+    "uuid": "^13.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "helmet": "^7.1.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "cors": {
+      "optional": true
+    },
+    "helmet": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "pino": "^10.1.0",
+    "winston": "^3.18.3"
+  }
+}

package/schemas/README.md

@@ -0,0 +1,97 @@
+# Schema Management System
+
+This directory contains the JSON Schema definitions for the astrology services API.
+
+## Directory Structure
+
+```
+packages/shared/schemas/
+├── v1/                          # Versioned namespace
+│   ├── core/                    # Core system schemas
+│   │   ├── input.json          # Base input schema for all services
+│   │   ├── output.json         # Base output schema for all services
+│   │   └── service.json        # Service template
+│   ├── domains/                # Domain-specific schemas
+│   │   └── astrology/
+│   │       ├── components/     # Astrology-specific components
+│   │       │   ├── planet.json
+│   │       │   ├── house.json
+│   │       │   ├── aspect.json
+│   │       │   └── dasha-period.json
+│   │       ├── services/       # Astrology services
+│   │       │   ├── birth-chart/
+│   │       │   │   ├── service.v1.json
+│   │       │   │   └── data.v1.json
+│   │       │   └── dasha/
+│   │       │       ├── service.v1.json
+│   │       │       └── data.v1.json
+│   │       └── inputs/         # Astrology input variants
+│   │           ├── vedic.v1.json
+│   │           └── compatibility.v1.json
+│   ├── services/               # Cross-domain services
+│   │   ├── ai/
+│   │   │   └── query.v1.json
+│   │   ├── database/
+│   │   │   └── query.v1.json
+│   │   ├── location/
+│   │   │   └── query.v1.json
+│   │   ├── logging/
+│   │   │   └── entry.v1.json
+│   │   ├── monitoring/
+│   │   │   └── query.v1.json
+│   │   └── cache/
+│   │       └── query.v1.json
+│   └── shared/                 # Cross-service components
+│       ├── metadata.v1.json
+│       ├── error.v1.json
+│       ├── performance.v1.json
+│       ├── client-context.v1.json
+│       └── preferences.v1.json
+├── registry/
+│   ├── services.json           # Service registry
+│   ├── components.json         # Component registry
+│   └── compatibility.json      # Migration/compatibility info
+├── legacy/                     # Deprecated schemas
+│   ├── astrologyInputSchema.js
+│   ├── astrologyOutputSchema.js
+│   └── serviceSchemas.js
+├── index.js                    # Main exports and validation
+└── README.md                   # This file
+```
+
+## Schema Loading
+
+Schemas are loaded using the registry system:
+
+```javascript
+const { loadSchema } = require('./index.js');
+
+// Load a service schema
+const birthChartSchema = loadSchema('astrology/birth-chart/service', 'v1');
+
+// Load a component schema
+const planetSchema = loadSchema('planet');
+```
+
+## Adding New Schemas
+
+### For Services:
+1. Create service directory: `v1/domains/{domain}/services/{service-name}/`
+2. Add `service.v1.json` and `data.v1.json`
+3. Update `registry/services.json`
+
+### For Components:
+1. Add component file to appropriate directory
+2. Update `registry/components.json`
+
+## Validation
+
+Schemas are validated using AJV with support for:
+- JSON Schema draft-07
+- Custom formats (uuid, date-time, etc.)
+- Recursive $ref resolution
+- Schema composition with allOf
+
+## Migration
+
+Legacy Zod-based schemas are preserved in the `legacy/` directory for reference during the migration period.