@plyaz/core 1.2.0 → 1.3.0

package/README.md

@@ -1,230 +1,295 @@
 # @plyaz/core
 
-> Foundational full-stack package for the Plyaz ecosystem
+> Foundational full-stack framework for the Plyaz ecosystem
 
-The `@plyaz/core` package serves as the orchestration layer that combines functionality from specialized packages to provide core business logic, domain models, and SDK foundations.
+The `@plyaz/core` package serves as the orchestration layer that provides domain service infrastructure, automatic dependency injection, and unified service management across frontend and backend environments.
 
-📚 **Full Documentation**: 
-- [Core Package Overview](https://plyaz.atlassian.net/wiki/spaces/SD/pages/37257227/Core+Package)
-- [Feature Flag System](https://plyaz.atlassian.net/wiki/spaces/SD/pages/44859395)
-- [Cache System](https://plyaz.atlassian.net/wiki/spaces/SD/pages/44892180)
+## Key Features
 
-## 🎯 Key Objectives
+- **Domain Service Framework** - Base classes for backend and frontend services with automatic CRUD, validation, and lifecycle hooks
+- **Service Registry** - Centralized service management with automatic dependency injection
+- **Unified Infrastructure** - Single initialization for DB, API, Cache, Storage, Notifications, and Observability
+- **Multi-Runtime Support** - Node.js, Next.js, NestJS, Browser, Edge, Bun, Deno
+- **Event-Driven Architecture** - Typed events with CoreEventManager
+- **Feature Flags** - Rule-based evaluation with targeting and rollouts
+- **CLI Tooling** - Interactive feature generation with `plyaz-core`
 
-- **Business Logic Orchestration**: Centralize core business logic that coordinates between specialized packages
-- **Full-Stack Support**: Environment-aware conditional loading for frontend, backend, and B2B integrations
-- **SDK Foundations**: Standardized interfaces for B2B partnerships and external integrations
-- **Type Safety**: Maintain strict architectural boundaries across all environments
+## Quick Start
 
-## 🏗️ Architecture Philosophy
+### Backend Service
 
-`@plyaz/core` acts as the **orchestration layer** - while it primarily coordinates between specialized packages, it also implements core business logic, domain models, and foundational utilities that are central to the Plyaz ecosystem:
+```typescript
+import { Core, ServiceRegistry } from '@plyaz/core';
+
+// Initialize all services at once
+await Core.initialize({
+  db: {
+    adapter: 'sql',
+    sql: { connectionString: process.env.DATABASE_URL },
+  },
+  api: {
+    baseUrl: process.env.API_BASE_URL,
+  },
+  cache: {
+    provider: 'memory',
+    ttl: 300,
+  },
+});
+
+// Register domain services
+ServiceRegistry.register({
+  key: 'users',
+  serviceClass: UserDomainService,
+  config: { enabled: true },
+});
+
+// Get service instance with injected dependencies
+const userService = await ServiceRegistry.getAsync<UserDomainService>('users');
+const user = await userService.getById('user-123');
+```
+
+### Creating Domain Services
 
 ```typescript
-// Core orchestrates other packages
-import { getUser, createTransaction } from '@plyaz/api';
-import { executeSmartContract, getWalletBalance } from '@plyaz/web3';
-import { validateUser, checkPermissions } from '@plyaz/auth';
-import { trackBusinessMetric } from '@plyaz/monitoring';
-import { FEATURE_FLAGS } from '@plyaz/config';
-import { createLogger } from '@plyaz/logger';
+import { BaseBackendDomainService } from '@plyaz/core/backend';
+
+class UserDomainService extends BaseBackendDomainService<
+  UserConfig,
+  UserRepository,
+  User,
+  CreateUserDTO,
+  UpdateUserDTO
+> {
+  protected eventPrefix = 'user';
+
+  // Fluent queries via repository.query()
+  async findActiveAdmins() {
+    return this.repository.query()
+      .where('status', 'eq', 'active')
+      .andWhere('role', 'eq', 'admin')
+      .orderByDesc('createdAt')
+      .getMany();
+  }
+
+  // Lifecycle hooks
+  protected async afterCreate(entity: User) {
+    await this.sendWelcomeEmail(entity);
+  }
+}
 ```
 
-## 📁 Package Structure
+## Architecture
 
 ```
-@plyaz/core/
-├── src/
-│   ├── base/                  # Generic functionalities used across domain, engine, and other layers
-│   │   └── cache/             # Caching system for performance optimization
-│   ├── domain/                # Pure business domain logic
-│   │   ├── user/              # User entity models and business rules
-│   │   ├── asset/             # Digital asset models and economics
-│   │   ├── transaction/       # Transaction domain and validation
-│   │   └── community/         # Community governance and interaction
-│   │   └── featureFlags/      # Domain logic feature flag system
-│   ├── engine/                # Core computational engines
-│   │   ├── calculation/       # Mathematical computation algorithms
-│   │   ├── incentive/         # Reward and incentive systems
-│   │   ├── validation/        # Business rule validation engines
-│   │   └── insights/          # Data analysis and pattern recognition
-│   │   └── featureFlags/      # Engine feature flag system
-│   ├── frontend/              # Frontend-specific implementations
-│   │   └── featureFlags/      # Frontend hooks, providers of feature flag system
-│   ├── backend/               # Backend-specific implementations
-│   │   └── featureFlags/      # Backend service, module, controller, repository of feature flag system. Generally in NestJs, but should be compatible without NestJs.
-│   ├── sdk/                   # B2B SDK foundation
-│   └── contracts/             # External service contracts
+@plyaz/core
+├── init/                    # Core initialization & ServiceRegistry
+├── services/                # Infrastructure services
+│   ├── DbService           # Database (wraps @plyaz/db)
+│   ├── ApiClientService    # HTTP client (wraps @plyaz/api)
+│   ├── CacheService        # Caching (memory/redis)
+│   ├── StorageService      # File storage (Supabase/R2)
+│   ├── NotificationService # Email/SMS/Push (Infobip/SendGrid)
+│   └── ObservabilityService # Metrics, tracing, logging
+├── domain/                  # Base domain service classes
+│   ├── BaseDomainService
+│   ├── BaseBackendDomainService
+│   └── BaseFrontendDomainService
+├── events/                  # CoreEventManager
+├── models/                  # Repositories & data access
+└── adapters/               # NestJS, Next.js integrations
 ```
 
-## 🚀 Currently Implemented Features
-
-> **Note**: The @plyaz/core package currently has two main features implemented. Additional providers and backend integrations are in development.
-
-### ✅ Feature Flag System (Most Complete)
-- **Implemented Providers**: 
-  - ✅ Memory Provider - Fully functional with FEATURES constant
-  - ✅ File Provider - JSON/YAML support with hot reload capability
-  - ⏳ Redis Provider - Stub only (pending implementation)
-  - ⏳ API Provider - Stub only (pending implementation)
-  - ⏳ Database Provider - Stub only (pending implementation)
-- **Frontend Support**: React hooks and context providers (working)
-- **Backend Support**: NestJS module structure (partial - not fully integrated)
-- **Engine**: Complete rule-based evaluation with targeting and rollouts
-- **Testing**: Full override capabilities for test scenarios
-
-### ✅ Cache System (Partially Complete)
-- **Implemented Strategies**: 
-  - ✅ Memory Strategy - LRU eviction with TTL management
-  - ⏳ Redis Strategy - Stub only (pending implementation)
-- **Features**: Statistics tracking, automatic cleanup, TTL management
-- **Integration**: Currently used by feature flag system
-
-### 🚧 Pending Implementation
-- **Backend Integration**: Full NestJS module integration
-- **Additional Engines**: Calculation, Incentive, Validation, Insights
-- **SDK Layer**: B2B partner SDK foundation
-- **External Providers**: Redis, API, and Database connections
-
-### File Provider Configuration
-
-The file provider supports JSON and YAML formats with hot reload:
-
-```json
-// src/config/feature-provider.json
-{
-  "flags": [
-    {
-      "key": "FEATURE_NAME",
-      "value": true,
-      "isEnabled": true,
-      "environments": ["production", "staging"]
-    }
-  ],
-  "rules": [
-    {
-      "id": "rule-id",
-      "flagKey": "FEATURE_NAME",
-      "name": "Rule Description",
-      "conditions": [
-        {
-          "field": "userRole",
-          "operator": "equals",
-          "value": "premium"
-        }
-      ],
-      "value": true,
-      "priority": 100,
-      "isEnabled": true
-    }
-  ]
-}
+## Service Injection Flow
+
+```
+Core.initialize(config)
+    ↓
+ServiceRegistry.initialize()
+    ↓
+Build service configs (db, api, cache, storage, notifications)
+    ↓
+ServiceRegistry.register({ key, serviceClass, config })
+    ↓
+DomainService.create(config, { injected: { db, api, cache, storage, notifications } })
+    ↓
+Access via this.config.injected?.db / storage / notifications
 ```
 
-See `src/config/feature-provider.json.example` and `src/config/feature-provider.yaml.example` for complete examples.
+## Infrastructure Services
 
-## 🔧 Key Capabilities
+### DbService
 
-- **Environment Isolation**: Complete separation of frontend and backend code
-- **Type Safety**: Full TypeScript support with strict boundaries
-- **Domain-Driven Design**: Clear bounded contexts for business domains
-- **Extensible Architecture**: Provider pattern for easy extension
-- **Performance Optimized**: Built-in caching and efficient evaluation
-- **Testing Support**: Override capabilities and test utilities
+Database connection manager with adapter chain (soft delete, caching, audit, encryption):
 
-## 📚 Documentation
+```typescript
+import { DbService } from '@plyaz/core';
 
-For detailed architecture information, implementation guides, and examples:
+await DbService.initialize({
+  adapter: 'sql',
+  sql: { connectionString: process.env.DATABASE_URL },
+  softDelete: { enabled: true },
+  cache: { enabled: true, ttl: 300 },
+});
 
-**[📖 Full Documentation](https://plyaz.atlassian.net/wiki/spaces/SD/pages/37257227/Core+Package?atlOrigin=eyJpIjoiNmQxZmNhYTllYmZjNDU2Njk0YmRhYWI2M2JkNTA3NDMiLCJwIjoiYyJ9)**
+const db = DbService.getInstance().getDatabase();
+```
 
-### 📄 Confluence Documentation
+### CacheService (Backend-only)
 
-- **[Feature Flag System](https://plyaz.atlassian.net/wiki/spaces/SD/pages/44859395/Feature+Flag+System+plyaz+core?atlOrigin=eyJpIjoiNjEyMWY3N2ViZDUxNDIxZTgxNGRmZWMwNjQwMzhiOTQiLCJwIjoiYyJ9)** - Complete feature flag implementation guide
-- **[Engine Layer](https://plyaz.atlassian.net/wiki/spaces/SD/pages/44892169/Engine+Layer+plyaz+core?atlOrigin=eyJpIjoiYTI5M2JhOTA5M2Q4NDY1ZjkzZjM2Yzk5M2U5MTZlMzUiLCJwIjoiYyJ9)** - Core computational engines documentation
-- **[Cache System](https://plyaz.atlassian.net/wiki/spaces/SD/pages/44892180/Cache+System+plyaz+core?atlOrigin=eyJpIjoiNDU2MTU5MWU0NTQ1NDIyMzk0MzJkNjE3MDkyOWVkZDQiLCJwIjoiYyJ9)** - Caching strategies and implementation
+Server-side caching with Redis or in-memory providers:
 
-## 🔗 Related Packages
+```typescript
+import { CacheService } from '@plyaz/core';
+
+await CacheService.initialize({
+  strategy: 'redis',
+  ttl: 300,
+  redisConfig: {
+    url: process.env.REDIS_URL,
+    keyPrefix: 'app:',
+  },
+});
+
+const cache = CacheService.getInstance();
+await cache.set('user:123', userData, 600); // 10 minute TTL
+const cached = await cache.get('user:123');
+```
 
-| Package | Purpose | Core Usage |
-|---------|---------|------------|
-| `@plyaz/api` | HTTP/REST API calls | Business data operations |
-| `@plyaz/web3` | Blockchain interactions | Asset operations, smart contracts |
-| `@plyaz/auth` | Authentication & authorization | User validation, permissions |
-| `@plyaz/config` | Configuration & feature flags | Business rules, environment settings |
-| `@plyaz/monitoring` | Metrics & performance tracking | Business KPI tracking |
-| `@plyaz/logger` | Logging infrastructure | Business operation logging |
-| `@plyaz/events` | Event-driven communication | Business event coordination |
+### StorageService (Backend-only)
 
-## 🛡️ Security & Performance
+Multi-provider file storage with automatic routing:
 
-- **Authentication Integration**: Built-in security via `@plyaz/auth`
-- **Input Validation**: Comprehensive validation using `@plyaz/errors`
-- **Audit Logging**: Full audit trail via `@plyaz/logger`
-- **Intelligent Caching**: Business-aware caching strategies
-- **Tree Shaking**: Environment-specific code loading
+```typescript
+import { StorageService } from '@plyaz/core';
+
+const storage = StorageService.getInstance().getStorage();
+await storage.uploadFile({
+  file: buffer,
+  filename: 'document.pdf',
+  bucket: 'documents',
+});
+```
 
-## 🏗️ Development
+### NotificationService (Backend-only)
 
-```bash
-# Install dependencies
-pnpm install
+Multi-channel notifications with provider failover:
 
-# Development with watch mode
-pnpm dev
+```typescript
+import { NotificationService } from '@plyaz/core';
+
+const notifications = NotificationService.getInstance().getNotifications();
+await notifications.sendEmail({
+  to: 'user@example.com',
+  templateId: 'welcome',
+  templateData: { name: 'John' },
+});
+```
 
-# Build package
-pnpm build
+## QueryBuilder Integration
 
-# Testing
-pnpm test                # Run tests once
-pnpm test:watch         # Run tests in watch mode
-pnpm test:coverage      # Run tests with coverage
-pnpm test:ui            # Run tests with UI
+Fluent query API via `@plyaz/db` integrated with BaseRepository:
 
-# Code quality
-pnpm lint               # Lint code
-pnpm lint:fix           # Lint and fix issues
-pnpm format             # Format code
-pnpm format:check       # Check formatting
-pnpm type:check         # Type checking
-
-# Security
-pnpm security:check     # Run security audit
-pnpm audit:fix          # Fix security issues
-
-# Clean build artifacts
-pnpm clean
+```typescript
+// In domain service
+const users = await this.repository.query()
+  .where('status', 'eq', 'active')
+  .andWhere('tier', 'eq', 'premium')
+  .whereNotNull('verifiedAt')
+  .orderByDesc('createdAt')
+  .paginate(1, 25)
+  .getMany();
+
+// Raw SQL for complex queries
+const results = await this.repository.query()
+  .where('status', 'eq', 'active')
+  .whereRaw('"metadata"->\'score\' > $1', [80])
+  .getMany();
 ```
 
-### TypeScript Path Aliases
+## CLI
 
-The package uses TypeScript path aliases for cleaner imports:
+Generate features interactively:
 
-**Before:**
-```typescript
-import { CacheManager } from '../../base/cache';
-import { FeatureFlagEngine } from '../../../engine/featureFlags/engine';
+```bash
+# Interactive mode
+pnpm plyaz-core generate
+
+# Direct generation
+pnpm plyaz-core generate user --type backend
+
+# Options
+--type backend|frontend|universal
+--skip-validator
+--skip-mapper
+--dry-run
 ```
 
-**After:**
+## Feature Flags
+
 ```typescript
-import { CacheManager } from '@base/cache/index';
-import { FeatureFlagEngine } from '@engine/featureFlags/engine';
+import { useFeatureFlag } from '@plyaz/core/frontend';
+
+// React hook
+const isEnabled = useFeatureFlag('DARK_MODE');
+
+// Backend check
+const flags = await FeatureFlagService.getFlags();
+if (flags.PREMIUM_FEATURES) {
+  // Premium logic
+}
 ```
 
-**Available aliases:**
-- `@/*` → `src/*`
-- `@domain/*` → `src/domain/*`
-- `@engine/*` → `src/engine/*`
-- `@backend/*` → `src/backend/*`
-- `@frontend/*` → `src/frontend/*`
-- `@base/*` → `src/base/*` (generic functionalities for cross-layer use)
-- `@utils/*` → `src/utils/*`
-- `@tests/*` → `tests/*`
+## Documentation
+
+| Guide | Description |
+|-------|-------------|
+| [Quick Start](./docs/guides/01-QUICK-START.md) | Get started in 5 minutes |
+| [Architecture](./docs/guides/02-ARCHITECTURE.md) | System design overview |
+| [Initialization](./docs/guides/03-INITIALIZATION.md) | Configuration options |
+| [Services](./docs/guides/05-SERVICES.md) | Domain service patterns |
+| [Base Classes API](./docs/guides/09-BASE-CLASSES-API.md) | Full API reference |
+| [DbService Guide](./docs/DbService-Usage-Guide.md) | Database integration |
+| [CacheService Guide](./docs/CacheService-Usage-Guide.md) | Caching (Redis/in-memory) |
+| [StorageService Guide](./docs/StorageService-Usage-Guide.md) | File storage |
+| [NotificationService Guide](./docs/NotificationService-Usage-Guide.md) | Notifications |
+
+## Related Packages
+
+| Package | Purpose |
+|---------|---------|
+| `@plyaz/db` | Database adapters, repositories, QueryBuilder |
+| `@plyaz/api` | HTTP client, fetchers, request handling |
+| `@plyaz/storage` | File storage providers (Supabase, R2) |
+| `@plyaz/notifications` | Email/SMS/Push providers |
+| `@plyaz/types` | Shared TypeScript types |
+| `@plyaz/errors` | Error handling utilities |
+
+## Development
 
-**Important:** When importing from index files, always specify `/index` explicitly (e.g., `@base/cache/index` not `@base/cache`).
+```bash
+# Install dependencies
+pnpm install
+
+# Development
+pnpm dev           # Watch mode
+pnpm build         # Build package
+pnpm type:check    # Type checking
+
+# Testing
+pnpm test          # Run tests
+pnpm test:watch    # Watch mode
+pnpm test:coverage # With coverage
+
+# Code quality
+pnpm lint          # Lint code
+pnpm lint:fix      # Fix issues
+pnpm format        # Format code
+
+# NestJS server (if configured)
+pnpm nest:dev      # Development server
+pnpm nest:start    # Production server
+```
 
----
+## License
 
-**Note**: This package is part of the Plyaz monorepo architecture. See the [full documentation](https://plyaz.atlassian.net/wiki/spaces/SD/pages/37257227/Core+Package) for complete implementation details and architectural decisions.
+MIT

package/dist/adapters/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Framework Adapters
+ *
+ * Adapters for different HTTP frameworks and runtimes.
+ *
+ * Available:
+ * - createHandler: Next.js API route handler with service injection
+ * - CoreModule: NestJS DI integration
+ *
+ * Types are available from '@plyaz/types/core':
+ * - CoreNextJsHandlerContext, CoreNextJsHandler, etc.
+ * - CoreNestJsModuleOptions, CoreNestJsModuleAsyncOptions
+ */
+export { createHandler, nextHandler } from './nextjs';
+export { CoreModule, CORE_DB_SERVICE, CORE_ENV, CORE_OPTIONS } from './nestjs';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGtD,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC"}

package/dist/adapters/nestjs.d.ts

@@ -0,0 +1,79 @@
+/**
+ * NestJS Framework Adapter
+ *
+ * Provides CoreModule for NestJS dependency injection.
+ * Initializes core services (db, env) for use across NestJS modules.
+ */
+import type { DynamicModule } from '@nestjs/common';
+import type { CoreDbServiceConfig } from '../services/DbService';
+import type { CoreNestJsModuleOptions, CoreNestJsModuleAsyncOptions } from '@plyaz/types/core';
+/**
+ * Core module options for NestJS
+ * Extended with specific DbServiceConfig type
+ */
+interface CoreModuleOptions extends Omit<CoreNestJsModuleOptions, 'db'> {
+    /** Database configuration */
+    db?: CoreDbServiceConfig;
+}
+/**
+ * Async options for CoreModule
+ * Extended with specific CoreModuleOptions type
+ */
+interface CoreModuleAsyncOptions extends Omit<CoreNestJsModuleAsyncOptions, 'useFactory'> {
+    useFactory: (...args: unknown[]) => CoreModuleOptions | Promise<CoreModuleOptions>;
+}
+/**
+ * Injection tokens for Core services
+ */
+export declare const CORE_DB_SERVICE = "CORE_DB_SERVICE";
+export declare const CORE_ENV = "CORE_ENV";
+export declare const CORE_OPTIONS = "CORE_OPTIONS";
+/**
+ * CoreModule for NestJS
+ *
+ * Provides Core services (DbService, etc.) via NestJS dependency injection.
+ * Import additional modules (FeatureFlagModule, etc.) separately.
+ *
+ * @example
+ * ```typescript
+ * import { Module } from '@nestjs/common';
+ * import { CoreModule } from '@plyaz/core/adapters';
+ * import { FeatureFlagModule } from '@plyaz/core/backend/featureFlags';
+ *
+ * @Module({
+ *   imports: [
+ *     CoreModule.forRoot({ envPath: '.env' }),
+ *     FeatureFlagModule.forRoot({ provider: 'database' }), // Auto-receives DbService
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @example Async configuration
+ * ```typescript
+ * CoreModule.forRootAsync({
+ *   imports: [ConfigModule],
+ *   inject: [ConfigService],
+ *   useFactory: (config: ConfigService) => ({
+ *     db: {
+ *       adapter: 'drizzle',
+ *       drizzle: {
+ *         connectionString: config.get('DATABASE_URL'),
+ *       },
+ *     },
+ *   }),
+ * })
+ * ```
+ */
+export declare const CoreModule: {
+    /**
+     * Register CoreModule with static configuration
+     */
+    forRoot(options?: CoreModuleOptions): DynamicModule;
+    /**
+     * Register CoreModule with async configuration
+     */
+    forRootAsync(options: CoreModuleAsyncOptions): DynamicModule;
+};
+export {};
+//# sourceMappingURL=nestjs.d.ts.map

package/dist/adapters/nestjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestjs.d.ts","sourceRoot":"","sources":["../../src/adapters/nestjs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAG/F;;;GAGG;AACH,UAAU,iBAAkB,SAAQ,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC;IACrE,6BAA6B;IAC7B,EAAE,CAAC,EAAE,mBAAmB,CAAC;CAC1B;AAED;;;GAGG;AACH,UAAU,sBAAuB,SAAQ,IAAI,CAAC,4BAA4B,EAAE,YAAY,CAAC;IACvF,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACpF;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,oBAAoB,CAAC;AACjD,eAAO,MAAM,QAAQ,aAAa,CAAC;AACnC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;sBACc,iBAAiB,GAAQ,aAAa;IAsCvD;;OAEG;0BACmB,sBAAsB,GAAG,aAAa;CAyC7D,CAAC"}

package/dist/adapters/nextjs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Next.js Adapter
+ *
+ * Provides utilities for Next.js API routes with auto-initialization
+ * and service injection.
+ *
+ * @example
+ * ```typescript
+ * // app/api/users/route.ts
+ * import { createHandler } from '@plyaz/core/adapters';
+ *
+ * export const GET = createHandler(async ({ db, query }) => {
+ *   const users = await db.list('users');
+ *   return { users };
+ * });
+ *
+ * export const POST = createHandler(async ({ db, body }) => {
+ *   const user = await db.create('users', body);
+ *   return { user, status: 201 };
+ * });
+ * ```
+ */
+import type { CoreNextJsHandler, CoreNextJsHandlerOptions } from '@plyaz/types/core';
+export declare function createHandler(handler: CoreNextJsHandler, options?: CoreNextJsHandlerOptions): (request: Request, context?: {
+    params?: Record<string, string>;
+}) => Promise<Response>;
+export { createHandler as nextHandler };
+//# sourceMappingURL=nextjs.d.ts.map

package/dist/adapters/nextjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../src/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAEV,iBAAiB,EACjB,wBAAwB,EAEzB,MAAM,mBAAmB,CAAC;AAgI3B,wBAAgB,aAAa,CAC3B,OAAO,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,wBAAwB,GACjC,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAcxF;AAGD,OAAO,EAAE,aAAa,IAAI,WAAW,EAAE,CAAC"}