@plyaz/core 1.2.0 → 1.2.1

package/dist/init/CoreInitializer.d.ts

@@ -0,0 +1,582 @@
+/**
+ * CoreInitializer - Unified initialization for @plyaz/core
+ *
+ * Provides a single entry point to initialize all core services with
+ * environment-aware configuration. Works across all JavaScript runtimes.
+ *
+ * @example Backend with full config
+ * ```typescript
+ * import { Core } from '@plyaz/core';
+ *
+ * await Core.initialize({
+ *   envPath: '.env',
+ *   db: { adapter: 'drizzle' },
+ *   api: {
+ *     env: 'production',
+ *     baseURL: 'https://api.example.com',
+ *   },
+ * });
+ *
+ * // Access services
+ * const db = Core.db;
+ * const api = Core.api;
+ * ```
+ *
+ * @example Frontend (Nuxt/Next.js)
+ * ```typescript
+ * import { Core } from '@plyaz/core';
+ *
+ * await Core.initialize({
+ *   skipDb: true,
+ *   api: { baseURL: 'https://api.example.com' },
+ * });
+ *
+ * const api = Core.api;
+ * ```
+ *
+ * @example NestJS with DI
+ * ```typescript
+ * // app.module.ts
+ * import { CoreModule } from '@plyaz/core/adapters';
+ * import { FeatureFlagModule } from '@plyaz/core/backend/featureFlags';
+ *
+ * @Module({
+ *   imports: [
+ *     CoreModule.forRoot({ envPath: '.env', db: { adapter: 'drizzle' } }),
+ *     FeatureFlagModule.forRoot({ provider: 'database' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+import { DbService, type CoreDbServiceConfig, DEFAULT_ENCRYPTION_FIELDS } from '../services/DbService';
+import { ApiClientService } from '../services/ApiClientService';
+import { CacheService } from '../services/CacheService';
+import { StorageService, type CoreStorageConfig } from '../services/StorageService';
+import { NotificationService, type CoreNotificationConfig } from '../services/NotificationService';
+import { CoreEventManager } from '../events/CoreEventManager';
+import type { CoreRuntimeEnvironment, CoreRuntimeContext, CoreEnvVars, CoreAppContext, CoreApiInitOptions, CoreServiceRuntime, CoreInitOptions as BaseCoreInitOptions, CoreServicesResultBase, CoreServiceEntry, CoreDomainServiceInstance, CoreFeatureFlagInitConfig, CoreErrorHandlerInitConfig, CoreCacheConfig, CoreObservabilityConfig } from '@plyaz/types/core';
+import type { ObservabilityAdapter } from '@plyaz/types/observability';
+import type { FeatureFlagStoreSlice } from '@plyaz/types/features';
+import type { ErrorStoreActions } from '@plyaz/types/errors';
+import { type StoreKey } from '@plyaz/store';
+import type { RootStoreSlice } from '@plyaz/types/store';
+import type { StoreApi } from 'zustand/vanilla';
+/**
+ * Core initialization options with specific types for this package
+ */
+export interface CoreInitOptions extends Omit<BaseCoreInitOptions<Partial<CoreDbServiceConfig>, CoreApiInitOptions, CoreCacheConfig, CoreStorageConfig, CoreNotificationConfig>, 'observability' | 'skipObservability'> {
+    /** Observability configuration */
+    observability?: CoreObservabilityConfig;
+    /** Skip observability initialization */
+    skipObservability?: boolean;
+    /**
+     * Global error handler configuration.
+     * Auto-initializes by default to catch all uncaught errors.
+     * Set `enabled: false` to disable if you want to use your own error handling.
+     *
+     * @example
+     * ```typescript
+     * await Core.initialize({
+     *   errorHandler: {
+     *     enabled: true,
+     *     logToConsole: true,
+     *     maxErrors: 200,
+     *     filter: (error) => error instanceof MyError,
+     *   },
+     * });
+     * ```
+     */
+    errorHandler?: CoreErrorHandlerInitConfig;
+    /** Feature flags configuration */
+    featureFlags?: CoreFeatureFlagInitConfig;
+    /**
+     * Domain services to auto-initialize (frontend pattern).
+     * Uses ServiceRegistry for automatic initialization.
+     *
+     * @example
+     * ```typescript
+     * await Core.initialize({
+     *   services: [
+     *     { service: FeatureFlagDomainService, config: { enabled: true } },
+     *     { service: ExampleDomainService, config: { enabled: true, useRealApi: true } },
+     *   ],
+     * });
+     *
+     * // Access via ServiceRegistry
+     * const flags = ServiceRegistry.get<FeatureFlagDomainService>('featureFlags');
+     * ```
+     */
+    services?: CoreServiceEntry[];
+}
+/**
+ * Core initialization result with specific types for this package
+ */
+export type CoreServicesResult = CoreServicesResultBase<DbService, typeof ApiClientService, CacheService, ObservabilityAdapter, StorageService, NotificationService>;
+/**
+ * Default service configurations for auto-initialization
+ * These services are always initialized unless explicitly disabled
+ */
+declare const CORE_DOMAIN_SERVICES: CoreServiceEntry[];
+export declare class Core {
+    private static initialized;
+    private static _coreServices;
+    /**
+     * Logger for Core initialization (created lazily)
+     */
+    private static _logger;
+    /**
+     * Get or create the Core logger
+     */
+    private static get logger();
+    /**
+     * Log a message during initialization.
+     * Uses PackageLogger, respects verbose flag.
+     */
+    private static log;
+    /**
+     * Log a debug message during initialization.
+     */
+    private static logDebug;
+    /**
+     * Observability configuration
+     */
+    private static _observabilityConfig;
+    /**
+     * Global error handler instance
+     */
+    private static _errorHandler;
+    /**
+     * Error handler configuration
+     */
+    private static _errorConfig;
+    /**
+     * HTTP error handler/middleware based on runtime.
+     * Auto-created during initialization.
+     */
+    private static _httpErrorHandler;
+    /**
+     * Event listener cleanup functions
+     */
+    private static _eventCleanupFns;
+    /**
+     * Feature flag configuration
+     */
+    private static _flagConfig;
+    /**
+     * Root store instance (contains errors, feature flags, and all other slices)
+     * Initialized during Core.initialize() - frontend uses React hook store, backend uses vanilla store
+     * All store access should go through Core.rootStore - no separate stores needed
+     */
+    private static _rootStore;
+    /**
+     * Setup environment and context
+     */
+    private static setupEnvironment;
+    /**
+     * Initialize a service with error handling
+     */
+    private static initService;
+    /** Initialize error handler if enabled */
+    private static initErrorHandlerIfEnabled;
+    /** Initialize API client if not skipped */
+    private static initApiIfEnabled;
+    /** Initialize cache service if not skipped */
+    private static initCacheIfEnabled;
+    /** Initialize observability if not skipped */
+    private static initObservabilityIfEnabled;
+    /** Initialize storage service if not skipped (backend-only) */
+    private static initStorageIfEnabled;
+    /** Initialize notifications service if not skipped (backend-only) */
+    private static initNotificationsIfEnabled;
+    /**
+     * Initialize domain services
+     *
+     * Always initializes CORE_DOMAIN_SERVICES (like BackendExampleService),
+     * then merges with any user-provided services.
+     * User-provided service configs override core defaults.
+     */
+    private static initDomainServicesIfConfigured;
+    /**
+     * Initialize all core services
+     */
+    static initialize(options?: CoreInitOptions): Promise<CoreServicesResult>;
+    /**
+     * Domain services for business logic
+     * @example Core.services.ExampleService.create(data)
+     */
+    static get services(): typeof CORE_DOMAIN_SERVICES;
+    /**
+     * All stores - unified access to ALL slices from single root store
+     * All stores (global + domain) are slices of ONE Zustand store instance.
+     *
+     * **Auto-generated from STORE_KEYS** - No manual registration needed!
+     *
+     * **Benefits:**
+     * - ✅ Access without hooks (store.getState())
+     * - ✅ Cross-slice subscriptions work automatically
+     * - ✅ Single source of truth
+     * - ✅ Automatically scales with new stores
+     *
+     * @example
+     * const errorStore = Core.stores.error;        // Global slice
+     * const flagsStore = Core.stores.featureFlags; // Global slice
+     * const exampleStore = Core.stores.example;    // Domain slice
+     */
+    static get stores(): Record<StoreKey, RootStoreSlice | undefined>;
+    /**
+     * Get a specific store slice by key (for ServiceRegistry injection).
+     * Returns the actual slice from the namespaced root store.
+     *
+     * @param key - Store key (type-safe: 'example' | 'errors' | 'featureFlags')
+     * @returns Specific store slice or undefined
+     *
+     * @example
+     * ```typescript
+     * const exampleSlice = Core.getDomainStore('example');  // ✅ Returns ExampleFrontendStoreSlice
+     * const errorSlice = Core.getDomainStore('errors');     // ✅ Returns ErrorStoreSlice
+     * const invalid = Core.getDomainStore('invalid');       // ❌ TypeScript error!
+     * ```
+     */
+    static getDomainStore<K extends keyof RootStoreSlice>(key: K): RootStoreSlice[K] | undefined;
+    static getDomainStore<T = RootStoreSlice>(): T | undefined;
+    /**
+     * Event manager for subscribing to domain events
+     * @example Core.events.on('example:created', handler)
+     */
+    static get events(): typeof CoreEventManager;
+    /**
+     * Get database service instance
+     * @throws Error if not initialized
+     */
+    static get db(): DbService;
+    /**
+     * Get API client service
+     */
+    static get api(): typeof ApiClientService;
+    /**
+     * Get cache service instance
+     * @throws Error if not initialized
+     */
+    static get cache(): CacheService;
+    /**
+     * Get observability adapter instance
+     * @throws Error if not initialized
+     *
+     * @example
+     * ```typescript
+     * // Record a metric
+     * await Core.observability.recordMetric({
+     *   type: 'counter',
+     *   name: 'api.requests',
+     *   value: 1,
+     *   tags: { endpoint: '/users' },
+     * });
+     *
+     * // Start a span
+     * const span = Core.observability.startSpan({ name: 'processOrder' });
+     * try {
+     *   // ... do work
+     *   span.setStatus('ok');
+     * } catch (e) {
+     *   span.recordException(e);
+     *   span.setStatus('error');
+     * } finally {
+     *   span.end();
+     * }
+     * ```
+     */
+    static get observability(): ObservabilityAdapter;
+    /**
+     * Check if observability is initialized
+     */
+    static get isObservabilityInitialized(): boolean;
+    /**
+     * Get observability configuration
+     */
+    static get observabilityConfig(): CoreObservabilityConfig;
+    /**
+     * Get storage service instance (backend-only)
+     * @throws Error if not initialized
+     *
+     * @example
+     * ```typescript
+     * const storage = Core.storage.getStorage();
+     * await storage.uploadFile({ file, filename: 'doc.pdf' });
+     * ```
+     */
+    static get storage(): StorageService;
+    /**
+     * Check if storage is initialized
+     */
+    static get isStorageInitialized(): boolean;
+    /**
+     * Get notifications service instance (backend-only)
+     * @throws Error if not initialized
+     *
+     * @example
+     * ```typescript
+     * const notifications = Core.notifications.getNotifications();
+     * await notifications.sendEmail({ to: 'user@example.com', templateId: 'welcome' });
+     * ```
+     */
+    static get notifications(): NotificationService;
+    /**
+     * Check if notifications is initialized
+     */
+    static get isNotificationsInitialized(): boolean;
+    /**
+     * Get root store (contains all slices: errors, feature flags, etc.)
+     * Use this to access the full store state and all slice actions globally.
+     *
+     * @example
+     * ```typescript
+     * // Access error actions
+     * const state = Core.rootStore.getState();
+     * state.addError({ ... });
+     *
+     * // Access flags
+     * console.log(state.flags);
+     *
+     * // Subscribe to store changes
+     * Core.rootStore.subscribe((state) => {
+     *   console.log('Errors:', state.errors);
+     *   console.log('Flags:', state.flags);
+     * });
+     * ```
+     */
+    static get rootStore(): StoreApi<RootStoreSlice>;
+    /**
+     * Get global error store actions.
+     * Provides access to the error store for querying and managing errors.
+     *
+     * @example
+     * ```typescript
+     * // Get all errors
+     * const allErrors = useErrorStore.getState().errors;
+     *
+     * // Clear all errors
+     * Core.errors.clearErrors();
+     *
+     * // Dismiss an error
+     * Core.errors.dismissError(errorId);
+     * ```
+     */
+    static get errors(): ErrorStoreActions;
+    /**
+     * Get feature flags store
+     * Provides synchronous access to feature flag values from the store.
+     *
+     * @example
+     * ```typescript
+     * // Check if a flag is enabled
+     * const isEnabled = Core.flags.isEnabled('NEW_FEATURE');
+     *
+     * // Get a flag value
+     * const provider = Core.flags.getValue<string>('PAYMENT_PROVIDER');
+     *
+     * // Refresh flags from source
+     * await Core.flags.refresh();
+     * ```
+     */
+    static get flags(): FeatureFlagStoreSlice;
+    /**
+     * Check if error handler is initialized
+     */
+    static get isErrorHandlerInitialized(): boolean;
+    /**
+     * Get the HTTP error handler/middleware based on runtime.
+     * Returns different types based on detected runtime:
+     *
+     * - **Express**: Error handler middleware function
+     *   ```typescript
+     *   app.use(Core.httpErrorHandler);
+     *   ```
+     *
+     * - **NestJS**: Exception filter class
+     *   ```typescript
+     *   app.useGlobalFilters(new (Core.httpErrorHandler)());
+     *   ```
+     *
+     * - **Next.js**: Object with App Router and Pages Router handlers
+     *   ```typescript
+     *   // App Router
+     *   export const GET = Core.httpErrorHandler.withErrorHandler(handler);
+     *   // Pages Router
+     *   export default Core.httpErrorHandler.createNextApiErrorHandler()(handler);
+     *   ```
+     *
+     * - **Node.js/Bun/Deno**: Object with handleError and createMiddleware
+     *   ```typescript
+     *   Core.httpErrorHandler.handleError(error, req, res);
+     *   ```
+     *
+     * - **Browser**: null (no HTTP handler needed)
+     *
+     * @returns The HTTP error handler for the current runtime
+     */
+    static get httpErrorHandler(): unknown;
+    /**
+     * Check if feature flags are initialized
+     */
+    static get isFlagsInitialized(): boolean;
+    /**
+     * Get error handler configuration
+     */
+    static get errorConfig(): CoreErrorHandlerInitConfig;
+    /**
+     * Get feature flag configuration
+     */
+    static get flagConfig(): CoreFeatureFlagInitConfig;
+    /**
+     * Get loaded environment variables
+     */
+    static get env(): CoreEnvVars;
+    /**
+     * Get detected runtime environment
+     */
+    static get runtime(): CoreRuntimeEnvironment;
+    /**
+     * Get current app context
+     */
+    static get appContext(): CoreAppContext;
+    /**
+     * Check if Core is initialized
+     */
+    static get isInitialized(): boolean;
+    /**
+     * Check if running on a backend runtime
+     */
+    static get isBackend(): boolean;
+    /**
+     * Check if running on a frontend runtime
+     */
+    static get isFrontend(): boolean;
+    /**
+     * Get runtime context (backend, frontend, or universal)
+     * Universal means the runtime can be either (SSR frameworks like Next.js, Nuxt, Edge)
+     */
+    static getRuntimeContext(): CoreRuntimeContext;
+    /**
+     * Assert that the current runtime matches the expected runtime(s)
+     * Throws an error if the runtime doesn't match
+     *
+     * @param expected - Expected runtime(s) to check against
+     * @param serviceName - Name of the service for error message
+     * @throws CorePackageError if runtime doesn't match
+     *
+     * @example
+     * ```typescript
+     * // Assert backend-only
+     * Core.assertRuntime('backend', 'DatabaseService');
+     *
+     * // Assert multiple runtimes
+     * Core.assertRuntime(['backend', 'universal'], 'CacheService');
+     * ```
+     */
+    static assertRuntime(expected: CoreServiceRuntime | readonly CoreServiceRuntime[], serviceName: string): void;
+    /**
+     * Check if a service runtime is compatible with current runtime
+     * Returns true/false instead of throwing
+     *
+     * @param expected - Expected runtime(s) to check against
+     */
+    static isRuntimeCompatible(expected: CoreServiceRuntime | readonly CoreServiceRuntime[]): boolean;
+    /**
+     * Get a registered domain service by key.
+     * Convenience method that wraps ServiceRegistry.get().
+     *
+     * @param key - Service key (e.g., 'featureFlags', 'example')
+     * @returns The service instance
+     *
+     * @example
+     * ```typescript
+     * const flags = Core.getService<FeatureFlagDomainService>('featureFlags');
+     * const isEnabled = await flags.isEnabled('my-flag');
+     * ```
+     */
+    static getService<T extends CoreDomainServiceInstance = CoreDomainServiceInstance>(key: string): T;
+    /**
+     * Get a registered domain service by key with async initialization if needed.
+     * Convenience method that wraps ServiceRegistry.getAsync().
+     *
+     * @param key - Service key
+     * @returns Promise resolving to the service instance
+     */
+    static getServiceAsync<T extends CoreDomainServiceInstance = CoreDomainServiceInstance>(key: string): Promise<T>;
+    /**
+     * Check if a domain service is registered.
+     */
+    static hasService(key: string): boolean;
+    /**
+     * Reset Core (useful for testing)
+     */
+    static reset(): Promise<void>;
+    /**
+     * Determines whether to skip DbService initialization.
+     *
+     * DbService is backend-only and should never be initialized on frontend runtimes.
+     * This method:
+     * - Returns true (skip) if skipDb was explicitly set to true
+     * - Returns true (skip) if running on frontend, with a warning
+     * - Warns if someone explicitly tried to init DbService on frontend (skipDb: false)
+     *
+     * @param skipDb - User-provided skipDb option
+     * @param verbose - Enable verbose logging
+     * @returns true if DbService should be skipped
+     */
+    private static shouldSkipDbService;
+    /**
+     * Initialize database service
+     * Config validation is handled by DbService
+     */
+    private static initializeDb;
+    /**
+     * Initialize API client service
+     * Config validation is handled by ApiClientService
+     */
+    private static initializeApi;
+    /**
+     * Initialize cache service
+     * Config validation is handled by CacheService
+     */
+    private static initializeCache;
+    /**
+     * Initialize observability service based on config.
+     * Always includes LoggerAdapter as failover for console output.
+     */
+    private static initializeObservability;
+    /**
+     * Initialize global error handler
+     */
+    /** Create and initialize root store (includes error store + all other slices) */
+    private static initializeRootStore;
+    /** Get error store actions from root store */
+    private static getErrorStoreActions;
+    /** Build global error handler config */
+    private static buildErrorHandlerConfig;
+    private static initializeErrorHandler;
+    /**
+     * Create HTTP error handler based on detected runtime.
+     * Stores the handler in Core._httpErrorHandler for access via Core.httpErrorHandler
+     */
+    private static createHttpErrorHandler;
+    /**
+     * Subscribe to CoreEventManager error events
+     * Forwards system, entity, API, validation, database, and auth errors to the global error handler.
+     *
+     * Note: Database errors (DATABASE.ERROR) are only subscribed on backend runtimes since
+     * DbService is backend-only (skipDb: true on frontend).
+     */
+    private static subscribeToErrorEvents;
+    /** Handle fetch flags error and return empty flags */
+    private static handleFetchFlagsError;
+    /** Create fetch flags function */
+    private static createFetchFlagsFn;
+    /**
+     * Initialize feature flags slice within root store
+     */
+    private static initializeFeatureFlags;
+}
+export { DbService, ApiClientService, CacheService, StorageService, NotificationService, DEFAULT_ENCRYPTION_FIELDS, };
+//# sourceMappingURL=CoreInitializer.d.ts.map

package/dist/init/CoreInitializer.d.ts.map

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