@plyaz/types 1.27.13 → 1.27.14

package/dist/core/init/types.d.ts

@@ -5,28 +5,15 @@
  * Services must implement these interfaces to be auto-initialized.
  */
 import type { ApiClientOptions } from '../../api';
-import type { FeatureFlagValue, FeatureFlagPollingConfig, CacheStrategyType } from '../../features';
+import type { FeatureFlagValue, FeatureFlagPollingConfig } from '../../features';
 import type { PackageErrorLike, MessageCatalog } from '../../errors';
 import type { GlobalErrorHandlerConfig, ErrorHandlerLogger } from '../../errors/middleware';
 import type { RootStoreSlice } from '../../store';
 import type { CoreAppEnvironment, CoreAppContext, CoreRuntimeEnvironment, CoreServiceRuntime } from '../modules';
-import type { CoreDbServiceConfig } from '../services';
+import type { CoreDbServiceConfig, CoreCacheConfig, CoreStorageConfig, CoreNotificationConfig } from '../services';
 import type { CoreInjectedServices } from '../domain';
-import type { StorageServiceConfig } from '../../storage';
-import type { NotificationServiceConfig } from '../../notifications';
 import type { MonitoringObservabilityAdapter, MonitoringAdapterWithPriority } from '../../observability';
-/**
- * Storage service configuration for Core initialization.
- * Uses the StorageServiceConfig from @plyaz/storage.
- * Backend-only - not available in browser/frontend runtimes.
- */
-export type CoreStorageConfig = StorageServiceConfig;
-/**
- * Notification service configuration for Core initialization.
- * Uses the NotificationServiceConfig from @plyaz/notifications.
- * Backend-only - not available in browser/frontend runtimes.
- */
-export type CoreNotificationConfig = NotificationServiceConfig;
+export type { CoreCacheConfig, CoreStorageConfig, CoreNotificationConfig } from '../services';
 /**
  * Base interface that all domain service instances must implement.
  * This allows the registry to manage services generically.
@@ -676,36 +663,6 @@ export interface CoreErrorHandlerInitConfig extends Omit<GlobalErrorHandlerConfi
         replaceBuiltIn?: boolean;
     };
 }
-/**
- * Cache initialization configuration
- */
-export interface CoreCacheConfig {
-    /** Cache strategy to use */
-    strategy: CacheStrategyType;
-    /** Whether caching is enabled (default: true) */
-    isEnabled: boolean;
-    /** Default TTL in seconds (default: 300 - 5 minutes) */
-    ttl?: number;
-    /** Key prefix for all cache entries (default: 'app') */
-    prefix?: string;
-    /** Redis-specific configuration (required when strategy is 'redis') */
-    redis?: {
-        /** Redis connection URL (e.g., redis://localhost:6379) */
-        url?: string;
-        /** Redis host (alternative to url) */
-        host?: string;
-        /** Redis port (default: 6379) */
-        port?: number;
-        /** Redis password */
-        password?: string;
-        /** Redis database number (default: 0) */
-        db?: number;
-        /** Connection timeout in milliseconds */
-        connectTimeout?: number;
-        /** Key prefix for Redis keys */
-        keyPrefix?: string;
-    };
-}
 /**
  * Observability initialization configuration
  */

package/dist/core/services/types.d.ts

@@ -5,6 +5,27 @@
 import type { DrizzleConfig, SupabaseConfig, SqlConfig, SoftDeleteConfig, DBCacheConfig, AuditConfig, DBEncryptionConfig } from '../../db';
 import type { ReactNode } from 'react';
 import type { ApiClientOptions } from '../../api/client';
+import type { StorageServiceConfig } from '../../storage';
+import type { NotificationServiceConfig } from '../../notifications';
+import type { CacheStrategyType } from '../../features';
+import type { BackendErrorStore, BackendErrorStoreConfig, HttpErrorHandlerConfig } from '../../errors/middleware';
+export interface CoreCacheConfig {
+    strategy: CacheStrategyType;
+    isEnabled: boolean;
+    ttl?: number;
+    prefix?: string;
+    redis?: {
+        url?: string;
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+        connectTimeout?: number;
+        keyPrefix?: string;
+    };
+}
+export type CoreStorageConfig = StorageServiceConfig;
+export type CoreNotificationConfig = NotificationServiceConfig;
 /**
 
 /**
@@ -518,11 +539,9 @@ export interface CoreDbServiceConfig {
  */
 export interface CoreDbServiceInstance {
     /** Get the underlying database instance */
-    getDatabase(): CoreDatabaseInstance | undefined;
-    /** Execute a raw SQL query */
-    query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
-    /** Begin a transaction */
-    transaction<T>(fn: (tx: unknown) => Promise<T>): Promise<T>;
+    getDatabase(adapterName?: string): CoreDatabaseInstance | undefined;
+    /** Close all database connections */
+    close(): Promise<void>;
 }
 /** Core's database instance interface (from @plyaz/db) */
 export interface CoreDatabaseInstance {
@@ -569,60 +588,42 @@ export interface CoreNotificationServiceInstance {
     /** Close/cleanup the notification service */
     close(): Promise<void>;
 }
-/**
- * DbService class interface (static methods)
- * Describes the DbService class, not an instance
- */
-export interface CoreDbServiceClass {
-    initialize(config: CoreDbServiceConfig): Promise<CoreDbServiceInstance>;
+export interface CoreDbServiceStatic {
+    initialize(config?: CoreDbServiceConfig): Promise<CoreDbServiceInstance>;
     getInstance(): CoreDbServiceInstance;
-    createInstance?(config: CoreDbServiceConfig): Promise<CoreDbServiceInstance>;
-    reset?(): void;
+    createInstance?(config?: CoreDbServiceConfig): Promise<CoreDbServiceInstance>;
+    reset?(): Promise<void>;
 }
-/**
- * CacheService class interface (static methods)
- * Describes the CacheService class, not an instance
- * Note: config uses unknown to avoid circular imports with init/types.ts
- */
-export interface CoreCacheServiceClass {
-    initialize(config: unknown): Promise<void>;
+export interface CoreCacheServiceStatic<TConfig = CoreCacheConfig> {
+    initialize(config: TConfig): Promise<void>;
     getInstance(): CoreCacheServiceInstance;
     reset?(): void;
 }
-/**
- * StorageService class interface (static methods)
- * Describes the StorageService class, not an instance
- * Note: config uses unknown to avoid circular imports with init/types.ts
- */
-export interface CoreStorageServiceClass {
-    initialize(config: unknown): Promise<void>;
+export interface CoreStorageServiceStatic<TConfig = CoreStorageConfig> {
+    initialize(config: TConfig): Promise<CoreStorageServiceInstance>;
     getInstance(): CoreStorageServiceInstance;
-    createInstance?(config: unknown): Promise<CoreStorageServiceInstance>;
+    createInstance?(config: TConfig): Promise<CoreStorageServiceInstance>;
     reset?(): Promise<void>;
 }
-/**
- * NotificationService class interface (static methods)
- * Describes the NotificationService class, not an instance
- * Note: config uses unknown to avoid circular imports with init/types.ts
- */
-export interface CoreNotificationServiceClass {
-    initialize(config: unknown): Promise<void>;
+export interface CoreNotificationServiceStatic<TConfig = CoreNotificationConfig> {
+    initialize(config: TConfig): Promise<CoreNotificationServiceInstance>;
     getInstance(): CoreNotificationServiceInstance;
-    createInstance?(config: unknown): Promise<CoreNotificationServiceInstance>;
+    createInstance?(config: TConfig): Promise<CoreNotificationServiceInstance>;
     reset?(): Promise<void>;
 }
 /**
- * ServerErrorMiddleware module interface
- * Describes the exports from @plyaz/errors/middleware/backend
+ * Minimal interface compatible with Next.js NextRequest
+ * Used to type withErrorHandler without importing 'next/server'
  */
-export interface CoreServerErrorMiddlewareModule {
-    createErrorStore(config: {
-        packageName: string;
-        serviceName?: string;
-    }): unknown;
-    createHttpErrorHandler(config: unknown): unknown;
-    createNestJsExceptionFilter(config: unknown): unknown;
-    withErrorHandler<T extends (...args: unknown[]) => unknown>(handler: T, config?: unknown): T;
-    createNextApiErrorHandler(config: unknown): unknown;
-    handleNodeError(error: unknown, req: unknown, res: unknown, config?: unknown): void;
+export interface NextRequestLike extends Request {
+    nextUrl: URL;
+}
+export interface CoreServerErrorMiddlewareStatic {
+    createErrorStore(config?: BackendErrorStoreConfig): BackendErrorStore;
+    createHttpErrorHandler(config?: HttpErrorHandlerConfig): unknown;
+    createNestJsExceptionFilter(config?: Record<string, unknown>): unknown;
+    withErrorHandler: <TReq extends NextRequestLike>(handler: (req: TReq, context?: unknown) => Promise<Response>, config?: HttpErrorHandlerConfig) => (req: TReq, context?: unknown) => Promise<Response>;
+    createNextApiErrorHandler(config?: HttpErrorHandlerConfig): unknown;
+    handleNodeError(error: unknown, req: unknown, res: unknown, config?: HttpErrorHandlerConfig): void;
 }
+export type { BackendErrorStore, BackendErrorStoreConfig, HttpErrorHandlerConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plyaz/types",
-  "version": "1.27.13",
+  "version": "1.27.14",
   "author": "Redeemer Pace",
   "license": "ISC",
   "description": "Provides shared TypeScript types and schema utilities for validation and parsing in the @playz ecosystem.",