@jammysunshine/astrology-shared 1.0.1

package/examples/serviceExamples.js

@@ -0,0 +1,359 @@
+/**
+ * Example inputs for different astrology service types
+ * Demonstrating scalability for 100+ services with different requirements
+ */
+
+const { generateRequestId } = require('../schemas');
+
+/**
+ * NUMEROLOGY SERVICE EXAMPLE
+ * Requires: personalData (name, birth date)
+ */
+const NUMEROLOGY_INPUT_EXAMPLE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'web',
+    version: '1.0.0',
+    sessionId: 'web_numerology_123',
+    deviceId: 'chrome_desktop_91.0.4472.124'
+  },
+
+  // Service-specific data for numerology
+  personalData: {
+    fullName: 'John Smith',
+    birthDate: '15/01/1990',
+    preferredNumberSystem: 'pythagorean'
+  },
+
+  parameters: {
+    includeLifePath: true,
+    includeExpression: true,
+    includeSoulUrge: true,
+    includePersonality: true,
+    language: 'en'
+  }
+};
+
+/**
+ * PALMISTRY SERVICE EXAMPLE
+ * Requires: palmData (hand type, fingerprints, mounts)
+ */
+const PALMISTRY_INPUT_EXAMPLE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'ios',
+    version: '2.1.0',
+    sessionId: 'ios_palmistry_456',
+    deviceId: 'iPhone14,2'
+  },
+
+  // Service-specific data for palmistry
+  palmData: {
+    handType: 'earth',
+    fingerprints: [
+      {
+        finger: 'thumb',
+        type: 'whorl',
+        hand: 'right'
+      },
+      {
+        finger: 'index',
+        type: 'loop',
+        hand: 'right'
+      }
+    ],
+    mounts: {
+      venus: 'high',
+      mars: 'medium',
+      jupiter: 'high',
+      saturn: 'flat',
+      mercury: 'medium',
+      moon: 'high'
+    }
+  },
+
+  parameters: {
+    includeDetailedAnalysis: true,
+    includeHealthIndicators: true,
+    language: 'en'
+  }
+};
+
+/**
+ * CHINESE ASTROLOGY SERVICE EXAMPLE
+ * Requires: birthData with Chinese calendar options
+ */
+const CHINESE_ASTROLOGY_INPUT_EXAMPLE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'android',
+    version: '1.5.0',
+    sessionId: 'android_chinese_789',
+    deviceId: 'SM-G998B'
+  },
+
+  // Enhanced birth data for Chinese astrology
+  birthData: {
+    date: '15/01/1990',
+    time: '14:30',
+    place: 'Beijing, China',
+    chineseCalendar: true,
+    includeBaZi: true,
+    includeFengShui: true
+  },
+
+  parameters: {
+    calendarType: 'lunar',
+    includeAnimalSign: true,
+    includeElement: true,
+    includeYinYang: true,
+    language: 'zh'
+  }
+};
+
+/**
+ * KABBALISTIC ASTROLOGY SERVICE EXAMPLE
+ * Requires: kabbalisticData (Hebrew name, birth data)
+ */
+const KABBALISTIC_INPUT_EXAMPLE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'web',
+    version: '1.0.0',
+    sessionId: 'web_kabbalah_101',
+    deviceId: 'firefox_desktop_89.0'
+  },
+
+  // Service-specific data for Kabbalistic astrology
+  kabbalisticData: {
+    hebrewName: 'יוחנן', // Hebrew characters only
+    birthData: {
+      date: '15/01/1990',
+      time: '14:30',
+      place: 'Jerusalem, Israel'
+    },
+    includeGematria: true,
+    includeTreeOfLife: true,
+    includeSephiroth: true
+  },
+
+  parameters: {
+    gematriaMethod: 'standard',
+    includePaths: true,
+    includeArchetypes: true,
+    language: 'he'
+  }
+};
+
+/**
+ * TAROT SERVICE EXAMPLE
+ * Requires: tarotQuery (question, spread type)
+ */
+const TAROT_INPUT_EXAMPLE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'pwa',
+    version: '1.2.0',
+    sessionId: 'pwa_tarot_202',
+    deviceId: 'chrome_mobile_91.0.4472.124'
+  },
+
+  // Service-specific data for tarot
+  tarotQuery: {
+    question: 'What should I focus on in my career this year?',
+    spreadType: 'celtic_cross',
+    includeAstrologicalCorrelation: true
+  },
+
+  parameters: {
+    deckType: 'rider_waite',
+    includeReversed: true,
+    includeInterpretation: true,
+    language: 'en'
+  }
+};
+
+/**
+ * I-CHING SERVICE EXAMPLE
+ * Requires: ichingQuery (question, casting method)
+ */
+const ICHING_INPUT_EXAMPLE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'api',
+    version: '1.0.0',
+    sessionId: 'api_iching_303',
+    deviceId: 'server_node_v16'
+  },
+
+  // Service-specific data for I-Ching
+  ichingQuery: {
+    question: 'Should I start my own business?',
+    castingMethod: 'coins',
+    includeAstrologicalCorrelation: false
+  },
+
+  parameters: {
+    includeChangingLines: true,
+    includeRelatingHexagram: true,
+    includeJudgment: true,
+    includeImage: true,
+    language: 'en'
+  }
+};
+
+/**
+ * RUNE CASTING SERVICE EXAMPLE
+ * Requires: runeQuery (question, spread type)
+ */
+const RUNE_CASTING_INPUT_EXAMPLE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'whatsapp',
+    version: '2.21.22.16',
+    sessionId: 'wa_runes_404',
+    deviceId: 'iPhone12,2'
+  },
+
+  // Service-specific data for rune casting
+  runeQuery: {
+    question: 'What is my spiritual path?',
+    spreadType: 'celtic_cross',
+    includeAstrologicalCorrelation: true
+  },
+
+  parameters: {
+    runeSet: 'elder_futhark',
+    includeReversed: true,
+    includeInterpretation: true,
+    language: 'en'
+  }
+};
+
+/**
+ * FUTURE SERVICE TEMPLATE
+ * Template for adding new service types
+ */
+const FUTURE_SERVICE_TEMPLATE = {
+  requestId: generateRequestId(),
+  timestamp: new Date().toISOString(),
+
+  client: {
+    type: 'api',
+    version: '1.0.0'
+  },
+
+  // Replace with service-specific data structure
+  // serviceSpecificData: { ... },
+
+  parameters: {
+    // Service-specific parameters
+    language: 'en'
+  }
+};
+
+/**
+ * SERVICE REGISTRATION EXAMPLES
+ * How to register new services in the system
+ */
+
+// Example: Registering a new Ayurveda service
+const AYURVEDA_SERVICE_REGISTRATION = {
+  serviceName: 'AyurvedaService',
+  category: 'ayurveda',
+  customSchema: {
+    required: ['ayurvedaData'],
+    properties: {
+      ayurvedaData: {
+        type: 'object',
+        required: ['doshaProfile', 'birthData'],
+        properties: {
+          doshaProfile: {
+            type: 'object',
+            properties: {
+              vata: { type: 'number', minimum: 0, maximum: 100 },
+              pitta: { type: 'number', minimum: 0, maximum: 100 },
+              kapha: { type: 'number', minimum: 0, maximum: 100 }
+            }
+          },
+          birthData: {} // Reference to standard birth data
+        }
+      }
+    }
+  }
+};
+
+// Example: Registering a new Crystal Healing service
+const CRYSTAL_HEALING_REGISTRATION = {
+  serviceName: 'CrystalHealingService',
+  category: 'crystal_healing',
+  customSchema: {
+    required: ['crystalData'],
+    properties: {
+      crystalData: {
+        type: 'object',
+        required: ['selectedCrystals', 'intention'],
+        properties: {
+          selectedCrystals: {
+            type: 'array',
+            items: {
+              type: 'string',
+              enum: ['amethyst', 'rose_quartz', 'citrine', 'moonstone', 'obsidian']
+            }
+          },
+          intention: {
+            type: 'string',
+            minLength: 10,
+            maxLength: 200
+          }
+        }
+      }
+    }
+  }
+};
+
+module.exports = {
+  // Service-specific examples
+  NUMEROLOGY_INPUT_EXAMPLE,
+  PALMISTRY_INPUT_EXAMPLE,
+  CHINESE_ASTROLOGY_INPUT_EXAMPLE,
+  KABBALISTIC_INPUT_EXAMPLE,
+  TAROT_INPUT_EXAMPLE,
+  ICHING_INPUT_EXAMPLE,
+  RUNE_CASTING_INPUT_EXAMPLE,
+
+  // Templates
+  FUTURE_SERVICE_TEMPLATE,
+
+  // Registration examples
+  AYURVEDA_SERVICE_REGISTRATION,
+  CRYSTAL_HEALING_REGISTRATION,
+
+  // Helper to get example by service type
+  getExampleByServiceType: (serviceType) => {
+    const examples = {
+      numerology: NUMEROLOGY_INPUT_EXAMPLE,
+      palmistry: PALMISTRY_INPUT_EXAMPLE,
+      chinese: CHINESE_ASTROLOGY_INPUT_EXAMPLE,
+      kabbalistic: KABBALISTIC_INPUT_EXAMPLE,
+      tarot: TAROT_INPUT_EXAMPLE,
+      iching: ICHING_INPUT_EXAMPLE,
+      runes: RUNE_CASTING_INPUT_EXAMPLE
+    };
+    return examples[serviceType] || FUTURE_SERVICE_TEMPLATE;
+  }
+};

package/index.js

@@ -0,0 +1,75 @@
+/**
+ * Shared utilities for astrology applications
+ * Works in both Node.js (backend) and browser (frontend) environments
+ */
+
+// Logger
+const { getLogger, createNamedLogger } = require('./logger');
+
+// Validation
+const {
+  validateBirthData,
+  // Other specific validation functions from './validation' that might use Joi,
+  // these need to be refactored later to use the AJV system if desired.
+  validateDateFormat,
+  validateTimeFormat,
+  validateBirthPlace,
+  validateClientContext,
+  validatePreferences,
+  createValidationError
+} = require('./validation');
+
+// Core AJV Schema Management API from schemas/index.js
+const {
+  loadSchema,
+  getVersionMetadata,
+  validateInput, // Generic validate function for any schema by name
+  validateOutput, // Generic validate function for any schema by name
+  registerSchema, // Renamed from registerServiceSchema in schemas/index.js
+  getRegistry,
+  clearCache,
+} = require('./schemas'); // This is schemas/index.js
+
+// Schema system using new JSON Schema architecture (imported above)
+
+// Export everything
+module.exports = {
+  // Logger
+  getLogger,
+  createNamedLogger,
+
+  // Validation (still contains Joi-based functions, to be refactored)
+  validateBirthData,
+  validateDateFormat,
+  validateTimeFormat,
+  validateBirthPlace,
+  validateClientContext,
+  validatePreferences,
+  createValidationError,
+
+  // Core AJV Schema Management API
+  loadSchema,
+  getVersionMetadata,
+  validateInput,
+  validateOutput,
+  registerSchema,
+  getRegistry,
+  clearCache,
+
+  // Schema System API (New JSON Schema Architecture)
+  loadSchema,
+  validateInput,
+  validateOutput,
+  registerSchema,
+  getRegistry,
+
+  // Legacy compatibility (deprecated - use new schema system)
+  astrologyInputSchema: () => loadSchema('astrology/birth-chart/service'),
+  astrologyOutputSchema: () => loadSchema('astrology/birth-chart/service'),
+  getServiceInputSchema: validateInput,
+  validateServiceInput: validateInput,
+
+  // Version info
+  version: '1.0.0',
+  name: '@astrology/shared'
+};

package/interfaces/IDataAccessService.js

@@ -0,0 +1,70 @@
+/**
+ * IDataAccessService Interface
+ * Abstract interface for all data persistence operations
+ * Provides unified access to Redis caching and MongoDB persistence
+ */
+
+class IDataAccessService {
+   /**
+    * Store a calculation result
+    * @param {string} unifiedUserId - Unified user identifier
+    * @param {string} calculationType - Type of calculation (birth-chart, dasha, etc.)
+    * @param {Object} data - Calculation result data
+    * @param {Object} metadata - Additional metadata for the calculation
+    * @returns {Promise<Object>} Storage result with operation details
+    */
+   async storeCalculation(unifiedUserId, calculationType, data, metadata) {
+     throw new Error('storeCalculation method must be implemented by concrete class');
+   }
+
+  /**
+   * Retrieve a calculation result
+   * @param {string} unifiedUserId - Unified user identifier
+   * @param {string} calculationType - Type of calculation
+   * @param {string} calculationId - Unique calculation identifier
+   * @returns {Promise<Object>} Retrieved calculation data with metadata
+   */
+  async retrieveCalculation(unifiedUserId, calculationType, calculationId) {
+    throw new Error('retrieveCalculation method must be implemented by concrete class');
+  }
+
+  /**
+   * Store user preferences
+   * @param {string} unifiedUserId - Unified user identifier
+   * @param {Object} preferences - User preference data
+   * @returns {Promise<Object>} Storage result
+   */
+  async storeUserPreferences(unifiedUserId, preferences) {
+    throw new Error('storeUserPreferences method must be implemented by concrete class');
+  }
+
+  /**
+   * Get user preferences
+   * @param {string} unifiedUserId - Unified user identifier
+   * @returns {Promise<Object>} User preferences data
+   */
+  async getUserPreferences(unifiedUserId) {
+    throw new Error('getUserPreferences method must be implemented by concrete class');
+  }
+
+  /**
+   * Log an analytics event
+   * @param {string} unifiedUserId - Unified user identifier
+   * @param {string} event - Event type/name
+   * @param {Object} data - Event data
+   * @returns {Promise<Object>} Logging result
+   */
+  async logAnalyticsEvent(unifiedUserId, event, data) {
+    throw new Error('logAnalyticsEvent method must be implemented by concrete class');
+  }
+
+  /**
+   * Health check for the data access service
+   * @returns {Promise<Object>} Health status
+   */
+  async healthCheck() {
+    throw new Error('healthCheck method must be implemented by concrete class');
+  }
+}
+
+module.exports = IDataAccessService;

package/interfaces/IUserContextService.js

@@ -0,0 +1,58 @@
+/**
+ * IUserContextService Interface
+ * Abstract interface for all user identity and session operations
+ * Provides unified access to user context across platforms
+ */
+
+class IUserContextService {
+  /**
+   * Resolve unified user ID from platform-specific user ID
+   * @param {string} platform - Platform identifier (whatsapp, web, ios, android)
+   * @param {string} platformUserId - Platform-specific user identifier
+   * @returns {Promise<string>} Unified user identifier
+   */
+  async resolveUserId(platform, platformUserId) {
+    throw new Error('resolveUserId method must be implemented by concrete class');
+  }
+
+  /**
+   * Get session state for a user
+   * @param {string} unifiedUserId - Unified user identifier
+   * @param {string} sessionId - Session identifier
+   * @returns {Promise<Object>} Session state data
+   */
+  async getSessionState(unifiedUserId, sessionId) {
+    throw new Error('getSessionState method must be implemented by concrete class');
+  }
+
+  /**
+   * Update session state for a user
+   * @param {string} unifiedUserId - Unified user identifier
+   * @param {string} sessionId - Session identifier
+   * @param {Object} partialState - Partial state update
+   * @returns {Promise<Object>} Update result
+   */
+  async updateSessionState(unifiedUserId, sessionId, partialState) {
+    throw new Error('updateSessionState method must be implemented by concrete class');
+  }
+
+  /**
+   * Get user profile data
+   * @param {string} unifiedUserId - Unified user identifier
+   * @param {Object} [projection=null] - Optional field projection
+   * @returns {Promise<Object>} User profile data
+   */
+  async getUserProfile(unifiedUserId, projection = null) {
+    throw new Error('getUserProfile method must be implemented by concrete class');
+  }
+
+  /**
+   * Health check for the user context service
+   * @returns {Promise<Object>} Health status
+   */
+  async healthCheck() {
+    throw new Error('healthCheck method must be implemented by concrete class');
+  }
+}
+
+module.exports = IUserContextService;