@plyaz/types 1.18.0 → 1.18.2

package/dist/core/modules.d.ts

@@ -0,0 +1,408 @@
+/**
+ * Core Module System Types
+ *
+ * Framework-agnostic module interface for @plyaz/core.
+ * Modules implement this contract to integrate with Core.
+ */
+import type { DatabaseServiceInterface } from '../db/databaseService';
+import type { HttpMethod } from '../api/config/types';
+export type { HttpMethod };
+/**
+ * Core services available to modules
+ */
+export interface CoreServices {
+    db: DatabaseServiceInterface;
+    env: Record<string, string | undefined>;
+}
+/**
+ * Route handler context
+ */
+export interface CoreRouteContext {
+    params: Record<string, string>;
+    query: Record<string, string | string[]>;
+    body: unknown;
+    headers: Record<string, string>;
+    services: CoreServices;
+}
+/**
+ * Route handler function
+ */
+export type CoreRouteHandler = (ctx: CoreRouteContext) => Promise<{
+    status?: number;
+    body?: unknown;
+    headers?: Record<string, string>;
+}>;
+/**
+ * Route definition - framework agnostic
+ */
+export interface CoreRouteDefinition {
+    method: HttpMethod;
+    path: string;
+    handler: CoreRouteHandler;
+    middleware?: string[];
+    description?: string;
+}
+/**
+ * Module configuration schema (optional)
+ */
+export interface CoreModuleConfigSchema<T = unknown> {
+    parse: (config: unknown) => T;
+    safeParse: (config: unknown) => {
+        success: boolean;
+        data?: T;
+        error?: Error;
+    };
+}
+/**
+ * Service factory for creating module services
+ */
+export type CoreServiceFactory<T = unknown> = (services: CoreServices, config?: unknown) => T | Promise<T>;
+/**
+ * Module lifecycle hooks
+ */
+export interface CoreModuleLifecycle {
+    /**
+     * Called when module is initialized
+     * Use for setup, connections, etc.
+     */
+    onInit?(services: CoreServices): Promise<void>;
+    /**
+     * Called when module is being destroyed
+     * Use for cleanup, closing connections, etc.
+     */
+    onDestroy?(): Promise<void>;
+    /**
+     * Called when Core is fully initialized (all modules loaded)
+     */
+    onReady?(services: CoreServices): Promise<void>;
+}
+/**
+ * Core module definition - framework agnostic contract
+ *
+ * @example
+ * ```typescript
+ * const FeatureFlagModule: CoreModuleDefinition = {
+ *   name: 'featureFlags',
+ *   version: '1.0.0',
+ *   dependencies: ['db'],
+ *
+ *   routes: [
+ *     { method: 'GET', path: '/flags', handler: listFlags },
+ *     { method: 'GET', path: '/flags/:key', handler: getFlag },
+ *   ],
+ *
+ *   services: {
+ *     featureFlagService: (core) => new FeatureFlagService(core.db),
+ *   },
+ *
+ *   async onInit(services) {
+ *     // Initialize feature flag provider
+ *   },
+ * };
+ * ```
+ */
+export interface CoreModuleDefinition<TConfig = unknown> extends CoreModuleLifecycle {
+    /**
+     * Unique module name (used for registration and access)
+     */
+    name: string;
+    /**
+     * Module version
+     */
+    version?: string;
+    /**
+     * Core services this module depends on
+     */
+    dependencies?: ('db' | 'api' | 'cache' | 'logger')[];
+    /**
+     * HTTP routes provided by this module
+     */
+    routes?: CoreRouteDefinition[];
+    /**
+     * Services exposed by this module
+     */
+    services?: Record<string, CoreServiceFactory>;
+    /**
+     * Configuration schema for validation
+     */
+    configSchema?: CoreModuleConfigSchema<TConfig>;
+    /**
+     * Default configuration
+     */
+    defaultConfig?: Partial<TConfig>;
+}
+/**
+ * Registered module instance (after initialization)
+ */
+export interface CoreRegisteredModule<TConfig = unknown> {
+    definition: CoreModuleDefinition<TConfig>;
+    config: TConfig;
+    services: Record<string, unknown>;
+    initialized: boolean;
+}
+/**
+ * Module with configuration (result of .forRoot())
+ */
+export interface CoreConfiguredModule<TConfig = unknown> {
+    definition: CoreModuleDefinition<TConfig>;
+    config: TConfig;
+}
+/**
+ * Helper to create a module definition with forRoot pattern
+ */
+export interface CoreModuleFactory<TConfig = unknown> {
+    /**
+     * Module definition
+     */
+    definition: CoreModuleDefinition<TConfig>;
+    /**
+     * Configure module with options
+     */
+    forRoot(config?: Partial<TConfig>): CoreConfiguredModule<TConfig>;
+    /**
+     * Use module with default config
+     */
+    default: CoreConfiguredModule<TConfig>;
+}
+/**
+ * Supported HTTP frameworks for server mode
+ */
+export type CoreFrameworkType = 'node' | 'express' | 'nestjs' | 'nextjs';
+/**
+ * Server configuration
+ */
+export interface CoreServerConfig {
+    port: number;
+    host?: string;
+    framework?: CoreFrameworkType;
+    prefix?: string;
+    cors?: {
+        enabled: boolean;
+        origins?: string[];
+    };
+}
+/**
+ * Framework adapter interface
+ */
+export interface CoreFrameworkAdapter {
+    /**
+     * Framework name
+     */
+    name: CoreFrameworkType;
+    /**
+     * Register routes from modules
+     */
+    registerRoutes(routes: Array<{
+        moduleName: string;
+        routes: CoreRouteDefinition[];
+    }>, services: CoreServices): void | Promise<void>;
+    /**
+     * Start the server
+     */
+    start(config: CoreServerConfig): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Get the underlying framework instance (express app, fastify instance, etc.)
+     */
+    getInstance(): unknown;
+}
+/**
+ * Adapter factory function
+ */
+export type CoreAdapterFactory = () => CoreFrameworkAdapter;
+/**
+ * Runtime environment detection
+ */
+export type CoreRuntimeEnvironment = 'node' | 'nestjs' | 'express' | 'nuxt' | 'nextjs' | 'browser' | 'edge' | 'deno' | 'bun' | 'unknown';
+/**
+ * Runtime context type
+ */
+export type CoreRuntimeContext = 'backend' | 'frontend' | 'universal';
+/**
+ * Backend runtimes - always server-side
+ */
+export declare const BACKEND_RUNTIMES: readonly CoreRuntimeEnvironment[];
+/**
+ * Frontend runtimes - always client-side
+ */
+export declare const FRONTEND_RUNTIMES: readonly CoreRuntimeEnvironment[];
+/**
+ * Universal runtimes - can be either (SSR)
+ */
+export declare const UNIVERSAL_RUNTIMES: readonly CoreRuntimeEnvironment[];
+/**
+ * Handler context for Next.js API routes
+ * Provides services and parsed request data
+ */
+export interface CoreNextJsHandlerContext {
+    /** Database service */
+    db: unknown;
+    /** URL parameters (from dynamic routes like [id]) */
+    params: Record<string, string>;
+    /** Query string parameters */
+    query: Record<string, string | string[]>;
+    /** Request body (parsed JSON) */
+    body: unknown;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Original Request object */
+    request: Request;
+}
+/**
+ * Handler return type for Next.js API routes
+ */
+export interface CoreNextJsHandlerResult {
+    /** Response body (will be JSON serialized) */
+    [key: string]: unknown;
+    /** HTTP status code (default: 200) */
+    status?: number;
+    /** Response headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Handler function type for Next.js API routes
+ */
+export type CoreNextJsHandler = (ctx: CoreNextJsHandlerContext) => Promise<CoreNextJsHandlerResult | Response>;
+/**
+ * Options for Next.js createHandler
+ */
+export interface CoreNextJsHandlerOptions {
+    /** Core initialization options (used on first request) */
+    coreOptions?: Record<string, unknown>;
+}
+/**
+ * Core environment variables
+ */
+export interface CoreEnvVars {
+    DATABASE_URL?: string;
+    SUPABASE_URL?: string;
+    SUPABASE_SERVICE_ROLE_KEY?: string;
+    SUPABASE_ANON_PUBLIC_KEY?: string;
+    ENCRYPTION_KEY?: string;
+    API_BASE_URL?: string;
+    API_TIMEOUT?: string;
+    NODE_ENV?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Application environment type
+ */
+export type CoreAppEnvironment = 'development' | 'staging' | 'production' | 'test';
+/**
+ * API client initialization options
+ * Extends ApiClientOptions with Core-specific settings
+ */
+export interface CoreApiInitOptions {
+    /** Environment for API client configuration */
+    env?: CoreAppEnvironment;
+    /** Set this client as the default */
+    setAsDefault?: boolean;
+    /** Base URL for API requests */
+    baseURL?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Additional options passed to ApiClientService */
+    [key: string]: unknown;
+}
+/**
+ * Core initialization options
+ */
+export interface CoreInitOptions<TDbConfig = unknown, TApiConfig = CoreApiInitOptions> {
+    /** Path to .env file */
+    envPath?: string;
+    /** Global application environment */
+    environment?: CoreAppEnvironment;
+    /** Application context (webapp, backoffice, mobile, etc.) */
+    appContext?: CoreAppContext;
+    /** Explicit environment variables */
+    env?: CoreEnvVars;
+    /** Database configuration */
+    db?: TDbConfig;
+    /** API client configuration */
+    api?: TApiConfig;
+    /** Skip database initialization */
+    skipDb?: boolean;
+    /** Skip API client initialization */
+    skipApi?: boolean;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+/**
+ * Core initialization result
+ */
+export interface CoreServicesResult<TDb = unknown, TApi = unknown> {
+    db: TDb | null;
+    api: TApi | null;
+    env: CoreEnvVars;
+    runtime: CoreRuntimeEnvironment;
+    appContext: CoreAppContext;
+}
+/**
+ * Core module options for NestJS
+ */
+export interface CoreNestJsModuleOptions {
+    /** Path to .env file */
+    envPath?: string;
+    /** Database configuration */
+    db?: Record<string, unknown>;
+    /** Whether to make Core services globally available */
+    isGlobal?: boolean;
+}
+/**
+ * Async options for NestJS CoreModule
+ */
+export interface CoreNestJsModuleAsyncOptions {
+    imports?: unknown[];
+    inject?: unknown[];
+    useFactory: (...args: unknown[]) => CoreNestJsModuleOptions | Promise<CoreNestJsModuleOptions>;
+    isGlobal?: boolean;
+}
+/**
+ * Application context type
+ *
+ * Identifies which type of application is running.
+ * Different apps may have different feature flags, API endpoints, or UI behaviors.
+ */
+export type CoreAppContext = 'webapp' | 'backoffice' | 'mobile' | 'microapp' | 'cli';
+/**
+ * App context constants for type-safe comparisons
+ */
+export declare const APP_CONTEXTS: readonly CoreAppContext[];
+/**
+ * Service runtime compatibility
+ *
+ * Declares which runtimes a service can execute on.
+ * Services can be restricted to specific runtimes for security
+ * (e.g., backend-only services should never be bundled for frontend).
+ */
+export type CoreServiceRuntime = 'frontend' | 'backend' | 'universal';
+/**
+ * Domain service configuration
+ *
+ * Declares service metadata including runtime compatibility
+ * and feature flag requirements.
+ *
+ * @example
+ * ```typescript
+ * class CampaignDomainService {
+ *   static readonly config: CoreDomainServiceConfig = {
+ *     name: 'CampaignDomainService',
+ *     runtimes: ['frontend', 'backend'],
+ *     requiresFeatureFlag: 'campaigns:enabled',
+ *   };
+ * }
+ * ```
+ */
+export interface CoreDomainServiceConfig {
+    /** Service name for logging and debugging */
+    name: string;
+    /** Runtimes this service can run on */
+    runtimes: readonly CoreServiceRuntime[];
+    /** Feature flag required to use this service (optional) */
+    requiresFeatureFlag?: string;
+    /** App contexts this service is available in (optional, all if not specified) */
+    appContexts?: readonly CoreAppContext[];
+}

package/dist/db/audit.types.d.ts

@@ -7,6 +7,19 @@ export interface AuditContext {
     ipAddress?: string;
     userAgent?: string;
 }
+/**
+ * Failure details for failed operations
+ */
+export interface AuditFailureDetails {
+    /** Which extension/layer caused the failure */
+    source: string;
+    /** Error type/name */
+    error_type: string;
+    /** Error message */
+    error_message: string;
+    /** Error code if available */
+    error_code?: string;
+}
 export interface AuditEvent {
     operation: string;
     table: string;
@@ -14,9 +27,18 @@ export interface AuditEvent {
     userId?: string;
     requestId?: string;
     changes: {
+        /** State before the operation */
         before?: Record<string, string | number | boolean | Date>;
+        /** State after the operation (for successful operations) */
         after?: Record<string, string | number | boolean | Date>;
+        /** Fields that were modified */
         fields?: string[];
+        /** Data that was attempted to be written (for failed operations) */
+        attempted?: Record<string, string | number | boolean | Date>;
+        /** Failure details (for failed operations) */
+        failure?: AuditFailureDetails;
+        /** Fields that are encrypted at rest (values shown are decrypted for audit) */
+        encryptedFields?: string[];
     };
     timestamp: Date;
     ipAddress?: string;

package/dist/db/config.types.d.ts

@@ -28,6 +28,12 @@ export interface BaseAdapter {
     ssl?: boolean;
     /** Database schema name */
     schema?: string;
+    /**
+     * Custom ID column mappings for tables
+     * Example: { 'feature_flags': 'key', 'sessions': 'session_id' }
+     * Tables not specified will default to 'id'
+     */
+    tableIdColumns?: Record<string, string>;
 }
 /**
  * Drizzle adapter configuration
@@ -53,7 +59,21 @@ export interface SupabaseAdapterConfig extends BaseAdapter {
 export interface SQLAdapterConfig extends BaseAdapter {
     adapter: ADAPTERS.SQL;
 }
+/**
+ * Mock adapter configuration for testing
+ */
+export interface DbMockAdapterConfig extends BaseAdapter {
+    adapter: ADAPTERS.MOCK;
+    /** Initial data to populate the mock database */
+    initialData?: Record<string, Record<string, unknown>[]>;
+    /** Whether to auto-generate IDs for records without them */
+    autoGenerateIds?: boolean;
+    /** Simulated latency in milliseconds */
+    latency?: number;
+    /** Simulated failure rate (0-1) for chaos testing */
+    failRate?: number;
+}
 /**
  * Database configuration as a union of all adapter configurations
  */
-export type DatabaseConfig = DrizzleAdapterConfig | SupabaseAdapterConfig | SQLAdapterConfig;
+export type DatabaseConfig = DrizzleAdapterConfig | SupabaseAdapterConfig | SQLAdapterConfig | DbMockAdapterConfig;

package/dist/db/database.types.d.ts

@@ -80,6 +80,8 @@ export interface QueryOptions<TRecord extends object = object> {
     sort?: SortOptions<TRecord>[];
     /** Pagination options */
     pagination?: PaginationOptions;
+    /** Database schema to use (overrides adapter default) */
+    schema?: string;
 }
 /**
  * Filter conditions for queries

package/dist/db/databaseAdapter.d.ts

@@ -100,6 +100,11 @@ export interface DatabaseAdapterType {
      * @returns Promise that resolves when disconnected
      */
     disconnect(): Promise<void>;
+    /**
+     * Close the database connection and cleanup resources
+     * @returns Promise resolving to DatabaseResult indicating success or failure
+     */
+    close(): Promise<DatabaseResult<void>>;
     /**
      * Get the underlying database client
      * @returns The underlying database client
@@ -132,14 +137,14 @@ export interface DatabaseAdapterType {
      * @param options - Query options including filters, sorting, and pagination
      * @returns Promise resolving to DatabaseResult containing paginated data
      */
-    findMany<T>(table: string, options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
+    findMany<T extends Record<string, unknown>>(table: string, options?: QueryOptions<T>): Promise<DatabaseResult<PaginatedResult<T>>>;
     /**
      * Create a new record
      * @param table - Table name
      * @param data - Record data to create
      * @returns Promise resolving to DatabaseResult containing the created record
      */
-    create<T>(table: string, data: T): Promise<DatabaseResult<T>>;
+    create<T extends Record<string, unknown>>(table: string, data: T): Promise<DatabaseResult<T>>;
     /**
      * Update an existing record
      * @param table - Table name
@@ -174,10 +179,15 @@ export interface DatabaseAdapterType {
      * @param filter - Filter conditions
      * @returns Promise resolving to DatabaseResult containing the count
      */
-    count(table: string, filter?: Filter): Promise<DatabaseResult<number>>;
+    count<T extends Record<string, unknown> = Record<string, unknown>>(table: string, filter?: Filter<T>): Promise<DatabaseResult<number>>;
     /**
      * Perform health check on the database connection
      * @returns Promise resolving to DatabaseResult containing health status
      */
     healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    /**
+     * Reference to the underlying adapter (for extension/decorator adapters)
+     * Used to unwrap nested adapters to access the base adapter
+     */
+    baseAdapter?: DatabaseAdapterType;
 }

package/dist/db/databaseService.d.ts

@@ -8,6 +8,7 @@ import type { OperationConfig } from './features-config.types';
 import type { DatabaseEvent } from './event.types';
 import type { PaginatedResult } from './databsePagination';
 import type { AuditContext } from './audit.types';
+import type { DatabaseAdapterType } from './databaseAdapter';
 /**
  * Table name type - centralized table constants
  */
@@ -90,15 +91,15 @@ export interface DatabaseServiceInterface {
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to the record or null
      */
-    get<T>(table: TableName, id: string, config?: OperationConfig): Promise<DatabaseResult<T | null>>;
+    get<T extends Record<string, unknown>>(table: TableName, id: string, config?: OperationConfig): Promise<DatabaseResult<T | null>>;
     /**
      * List records with optional filtering, sorting, and pagination
      * @param table - Table name
-     * @param options - Query options
+     * @param options - Query options with type-safe fields
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to paginated results
      */
-    list<T>(table: TableName, options?: QueryOptions, config?: OperationConfig): Promise<DatabaseResult<PaginatedResult<T>>>;
+    list<T extends Record<string, unknown>>(table: TableName, options?: QueryOptions<T>, config?: OperationConfig): Promise<DatabaseResult<PaginatedResult<T>>>;
     /**
      * Create a new record
      * @param table - Table name
@@ -106,7 +107,7 @@ export interface DatabaseServiceInterface {
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to the created record
      */
-    create<T>(table: TableName, input: CreateInput<T>, config?: OperationConfig): Promise<DatabaseResult<T>>;
+    create<T extends Record<string, unknown>>(table: TableName, input: CreateInput<T>, config?: OperationConfig): Promise<DatabaseResult<T>>;
     /**
      * Update an existing record
      * @param table - Table name
@@ -115,7 +116,7 @@ export interface DatabaseServiceInterface {
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to the updated record
      */
-    update<T>(table: TableName, id: string, input: UpdateInput<T>, config?: OperationConfig): Promise<DatabaseResult<T>>;
+    update<T extends Record<string, unknown>>(table: TableName, id: string, input: UpdateInput<T>, config?: OperationConfig): Promise<DatabaseResult<T>>;
     /**
      * Delete a record
      * @param table - Table name
@@ -131,7 +132,7 @@ export interface DatabaseServiceInterface {
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to array of created records
      */
-    batchCreate<T>(table: TableName, inputs: CreateInput<T>[], config?: OperationConfig): Promise<DatabaseResult<T[]>>;
+    batchCreate<T extends Record<string, unknown>>(table: TableName, inputs: CreateInput<T>[], config?: OperationConfig): Promise<DatabaseResult<T[]>>;
     /**
      * Update multiple records in a batch
      * @param table - Table name
@@ -139,7 +140,7 @@ export interface DatabaseServiceInterface {
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to array of updated records
      */
-    batchUpdate<T>(table: TableName, updates: BatchUpdate<T>[], config?: OperationConfig): Promise<DatabaseResult<T[]>>;
+    batchUpdate<T extends Record<string, unknown>>(table: TableName, updates: BatchUpdate<T>[], config?: OperationConfig): Promise<DatabaseResult<T[]>>;
     /**
      * Delete multiple records in a batch
      * @param table - Table name
@@ -151,27 +152,27 @@ export interface DatabaseServiceInterface {
     /**
      * Execute a complex query with filters, sorting, and pagination
      * @param table - Table name
-     * @param query - Query configuration
+     * @param query - Query configuration with type-safe fields
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to paginated results
      */
-    query<T>(table: TableName, query: QueryOptions, config?: OperationConfig): Promise<DatabaseResult<PaginatedResult<T>>>;
+    query<T extends Record<string, unknown>>(table: TableName, query: QueryOptions<T>, config?: OperationConfig): Promise<DatabaseResult<PaginatedResult<T>>>;
     /**
      * Count records matching a filter
      * @param table - Table name
-     * @param filter - Optional filter conditions
+     * @param filter - Optional filter conditions with type-safe fields
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to the count
      */
-    count(table: TableName, filter?: Filter, config?: OperationConfig): Promise<DatabaseResult<number>>;
+    count<T extends Record<string, unknown> = Record<string, unknown>>(table: TableName, filter?: Filter<T>, config?: OperationConfig): Promise<DatabaseResult<number>>;
     /**
      * Find a single record by filter conditions
      * @param table - Table name
-     * @param filter - Filter conditions
+     * @param filter - Filter conditions with type-safe fields
      * @param config - Optional per-operation configuration overrides
      * @returns Promise resolving to the first matching record or null
      */
-    findOne<T>(table: TableName, filter: Filter, config?: OperationConfig): Promise<DatabaseResult<T | null>>;
+    findOne<T extends Record<string, unknown>>(table: TableName, filter: Filter<T>, config?: OperationConfig): Promise<DatabaseResult<T | null>>;
     /**
      * Soft delete a record (logical deletion)
      * @param table - Table name
@@ -219,43 +220,15 @@ export interface DatabaseServiceInterface {
      * @returns Current service status information
      */
     getStatus(): ServiceStatus;
-}
-/**
- * Legacy interface for backward compatibility
- * @deprecated Use DatabaseService instead
- */
-export interface DatabaseServiceType extends DatabaseServiceInterface {
-    /**
-     * @deprecated Use get() instead
-     */
-    findById<T>(table: string, id: string): Promise<DatabaseResult<T | null>>;
-    /**
-     * @deprecated Use list() instead
-     */
-    findMany<T>(table: string, options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
     /**
-     * Initialize the database service
-     * @deprecated Initialization is handled by factory
+     * Close the database connection
+     * Gracefully shuts down the connection and releases resources.
+     * @returns Promise resolving to DatabaseResult indicating success or failure
      */
-    initialize(): Promise<DatabaseResult<void>>;
+    close(): Promise<DatabaseResult<void>>;
     /**
-     * Register a table with the adapter
-     * @deprecated Tables are registered automatically
-     */
-    registerTable<T>(name: string, table: T, idColumn?: keyof T): void;
-    /**
-     * Check if a record exists
-     * @deprecated Use count() with filter instead
-     */
-    exists(table: string, id: string): Promise<DatabaseResult<boolean>>;
-    /**
-     * Find a single record by filter conditions
-     * @deprecated Use findOne() from main interface instead
-     */
-    findOne<T>(table: string, filter: Filter): Promise<DatabaseResult<T | null>>;
-    /**
-     * Soft delete a record (logical deletion)
-     * @deprecated Use softDelete() from main interface instead
+     * The underlying database adapter
+     * Used for direct adapter access when needed (e.g., CLI operations)
      */
-    softDelete(table: string, id: string): Promise<DatabaseResult<void>>;
+    adapter: DatabaseAdapterType;
 }