mongodash 2.0.0 → 2.1.0

package/dist/types/src/reactiveTasks/ReactiveTaskTypes.d.ts

@@ -0,0 +1,389 @@
+import { Collection, Document, ObjectId, ResumeToken, WithId, Filter, FindOptions } from 'mongodb';
+import type { ReactiveTaskRetryStrategy } from './ReactiveTaskRetryStrategy';
+/**
+ * Represents the status of a task in the database.
+ */
+export type ReactiveTaskStatus = 'pending' | 'processing' | 'processing_dirty' | 'completed' | 'failed';
+/**
+ * Defines when orphaned task records should be deleted.
+ */
+export type CleanupDeleteWhen = 'sourceDocumentDeleted' | 'sourceDocumentDeletedOrNoLongerMatching' | 'never';
+/**
+ * Configuration for automatic cleanup of orphaned task records.
+ */
+export interface CleanupPolicy {
+    /**
+     * When to delete orphaned task records.
+     * Default: 'sourceDocumentDeleted'
+     */
+    deleteWhen?: CleanupDeleteWhen;
+    /**
+     * How long to keep task records after the deletion condition is met.
+     * Accepts duration strings ('24h', '7d') or milliseconds.
+     * Default: '24h'
+     */
+    keepFor?: string | number;
+}
+/**
+ * Structure of the task document stored in the `_tasks` collection.
+ */
+export interface ReactiveTaskRecord<T = Document> {
+    _id: string | ObjectId;
+    task: string;
+    sourceDocId: WithId<T>['_id'];
+    status: ReactiveTaskStatus;
+    attempts: number;
+    scheduledAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    startedAt?: Date | null;
+    completedAt?: Date | null;
+    lockExpiresAt?: Date | null;
+    firstErrorAt?: Date | null;
+    lastError?: string | null;
+    lastFinalizedAt?: Date | null;
+    initialScheduledAt?: Date | null;
+    lastObservedValues?: Record<string, unknown> | null;
+    lastSuccess?: {
+        at: Date;
+        durationMs: number;
+    } | null;
+    executionHistory?: Array<{
+        at: Date;
+        status: 'completed' | 'failed';
+        durationMs: number;
+        error?: string;
+    }>;
+}
+export interface MetaDocument {
+    _id: string;
+    lock?: {
+        expiresAt: Date;
+        instanceId: string;
+    };
+    streamState?: {
+        resumeToken: ResumeToken;
+        lastClusterTime?: Date;
+    };
+    reconciliation?: {
+        [taskName: string]: boolean;
+    };
+    reconciliationState?: {
+        [collectionName: string]: {
+            lastId: unknown;
+            taskNames: string[];
+            updatedAt: Date;
+        };
+    };
+    tasks?: {
+        [taskName: string]: {
+            triggerConfig: {
+                filter: Document;
+                watchProjection: Document;
+            };
+            handlerVersion: number;
+        };
+    };
+    lastReconciledAt?: Date;
+    lastCleanupAt?: Date;
+}
+export interface RegistryDocument {
+    _id: string;
+    instances: Array<{
+        id: string;
+        lastSeen: Date | string;
+        metrics: unknown;
+    }>;
+}
+/**
+ * Error thrown when `getDocument` fails because the document no longer matches the filter
+ * or has been deleted. The worker will catch this and mark the task as skipped (success).
+ */
+export declare class TaskConditionFailedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Context passed to the task handler.
+ * It provides access to the source document ID, snapshot data, fetching logic, and flow control.
+ */
+export interface ReactiveTaskContext<T = Document> {
+    /** The ID of the source document to process. */
+    docId: WithId<T>['_id'];
+    /**
+     * The snapshot of fields that were observed when the task was triggered.
+     * Useful for debugging or decision logic without fetching the full document.
+     */
+    watchedValues: Record<string, unknown> | null;
+    /**
+     * Atomically fetches the source document.
+     * Applies the task's `filter` logic to ensure the document still matches.
+     *
+     * @example
+     * ```ts
+     * const doc = await context.getDocument({ session });
+     * ```
+     *
+     * @param options MongoDB FindOptions (allows passing `session` for transactions, projection, etc.).
+     * @throws TaskConditionFailedError if document is not found or mismatch.
+     */
+    getDocument(options?: FindOptions): Promise<T>;
+    /**
+     * Defers the task execution to a later time.
+     * The task will remain 'pending' (or effectively so) until the specified time.
+     * Use this for temporary external failures (e.g. rate limits) or to postpone processing.
+     * This preserves the original `scheduledAt` for global lag calculation.
+     */
+    deferCurrent(delay: number | Date): void;
+    /**
+     * Pauses ALL tasks of this type (on this instance only) until the specified time.
+     * Useful for instance-local backoff (e.g. rate limits), but note that other instances will continue processing.
+     *
+     * IMPORTANT: This does NOT automatically defer the *current* task.
+     * The current task will be marked as successful unless you also call `deferCurrent()` or throw an error.
+     */
+    throttleAll(until: number | Date): void;
+}
+/**
+ * Worker function provided by the user.
+ */
+export type ReactiveTaskHandler<T = Document> = (context: ReactiveTaskContext<T>) => Promise<void>;
+export type RetryPolicy = {
+    /**
+     * Maximum number of attempts before marking as 'failed'.
+     * Includes the first run (e.g. 1 means "try once, do not retry").
+     * Set to -1 for infinite attempts.
+     * Default: 5 (if maxDuration is not set)
+     */
+    maxAttempts?: number;
+    /**
+     * Maximum duration since the *first* failure in the current sequence.
+     * If the task is still failing after this time window, it is marked as 'failed'.
+     * Example: '24h', '30m'
+     */
+    maxDuration?: string;
+    /**
+     * If true, resets the retry history (including `firstErrorAt`) when the task data changes.
+     * Default: true
+     */
+    resetRetriesOnDataChange?: boolean;
+} & ({
+    type: 'exponential';
+    min: number | string;
+    max: number | string;
+    factor?: number;
+} | {
+    type: 'linear';
+    interval: string;
+} | {
+    type: 'fixed';
+    interval: string;
+} | {
+    type: 'series';
+    intervals: string[];
+} | {
+    type: 'cron';
+    expression: string;
+});
+export interface EvolutionConfig {
+    /**
+     * Version of the task handler logic.
+     * Default: 1
+     */
+    handlerVersion?: number;
+    /**
+     * Policy to apply when the handler version increases.
+     * - 'none': Do nothing.
+     * - 'reprocess_failed': Reset 'failed' tasks to 'pending'.
+     * - 'reprocess_all': Reset ALL tasks (completed & failed) to 'pending'.
+     * Default: 'none'
+     */
+    onHandlerVersionChange?: 'none' | 'reprocess_failed' | 'reprocess_all';
+    /**
+     * Whether to trigger reconciliation when the trigger configuration (filter/watchProjection) changes.
+     * Default: true
+     */
+    reconcileOnTriggerChange?: boolean;
+}
+export interface ReactiveTask<T extends Document> {
+    collection: string | Collection<T>;
+    task: string;
+    watchProjection?: NonNullable<Parameters<Collection<T>['find']>[1]>['projection'];
+    /**
+     * Aggregation Expression (e.g. { $eq: ['$status', 'active'] }) OR Standard Query (e.g. { status: 'active' }).
+     * Standard queries are automatically converted to Aggregation Expressions.
+     */
+    filter?: Filter<T>;
+    handler: ReactiveTaskHandler<T>;
+    /** Time (ms) or interval description (e.g. "500ms", "1s") to postpone `scheduledAt` on change (Debouncing). Default: 1000ms */
+    debounce?: number | string;
+    /** Retry Policy configuration */
+    retryPolicy?: RetryPolicy;
+    /**
+     * Number of execution history entries to keep.
+     * Default: 5
+     */
+    executionHistoryLimit?: number;
+    /**
+     * Evolution configuration for handling changes to task definitions across deployments.
+     */
+    evolution?: EvolutionConfig;
+    /**
+     * Cleanup policy for orphaned task records.
+     * Controls when and how task records are automatically deleted.
+     */
+    cleanupPolicy?: CleanupPolicy;
+}
+export type ReactiveTaskInternal<T extends Document> = Omit<ReactiveTask<T>, 'collection'> & {
+    sourceCollection: Collection<T>;
+    tasksCollection: Collection<ReactiveTaskRecord<T>>;
+    initPromise: Promise<void>;
+    debounceMs: number;
+    retryStrategy: ReactiveTaskRetryStrategy;
+    executionHistoryLimit: number;
+    cleanupPolicyParsed: {
+        deleteWhen: CleanupDeleteWhen;
+        keepForMs: number;
+    };
+    repository: import('./ReactiveTaskRepository').ReactiveTaskRepository<T>;
+};
+/**
+ * Configuration options for the scheduler.
+ */
+export interface ReactiveTaskSchedulerOptions {
+    /**
+     * Optional unique identifier for this scheduler instance.
+     * Used for leader election, metrics aggregation, and debugging.
+     * If not provided, a random ObjectId hex string will be generated.
+     */
+    instanceId?: string;
+    /** Number of concurrent workers polling the DB. */
+    reactiveTaskConcurrency: number;
+    /** Optional caller to wrap task execution (e.g. for context propagation). */
+    reactiveTaskCaller?: ReactiveTaskCaller;
+    /** Optional filter to restrict which tasks this worker processes. */
+    reactiveTaskFilter?: ReactiveTaskFilter;
+    /**
+     * Monitoring configuration options.
+     */
+    monitoring?: {
+        /**
+         * Enable/disable metrics collection.
+         * Default: true
+         */
+        enabled?: boolean;
+        /**
+         * How often workers push local metrics to the global registry (ms).
+         * Default: 60000 (1m)
+         */
+        pushIntervalMs?: number;
+        /**
+         * Controls which set of metrics to return.
+         * Default: 'cluster'
+         */
+        scrapeMode?: 'local' | 'cluster';
+        /**
+         * Read preference for fetching the global registry and global stats.
+         * Default: 'secondaryPreferred'
+         */
+        readPreference?: 'primary' | 'primaryPreferred' | 'secondary' | 'secondaryPreferred' | 'nearest';
+    };
+    /**
+     * How often to run periodic cleanup of orphaned task records.
+     * Accepts duration strings ('24h'), milliseconds, or cron expressions ('0 3 * * *').
+     * Default: '24h'
+     */
+    reactiveTaskCleanupInterval?: number | string;
+}
+/**
+ * Filter function to restrict which tasks are processed by the worker.
+ */
+export interface ReactiveTaskFilter {
+    ({ task }: {
+        task: string;
+    }): boolean;
+}
+/**
+ * Caller function to wrap task execution.
+ */
+export interface ReactiveTaskCaller {
+    <T>(task: () => Promise<T>): Promise<T> | T;
+}
+export declare const CODE_REACTIVE_TASK_STARTED = "reactiveTaskStarted";
+export declare const CODE_REACTIVE_TASK_FINISHED = "reactiveTaskFinished";
+export declare const CODE_REACTIVE_TASK_FAILED = "reactiveTaskFailed";
+export declare const CODE_REACTIVE_TASK_PLANNER_STARTED = "reactiveTaskPlannerStarted";
+export declare const CODE_REACTIVE_TASK_PLANNER_STOPPED = "reactiveTaskPlannerStopped";
+export declare const CODE_REACTIVE_TASK_PLANNER_RECONCILIATION_STARTED = "reactiveTaskPlannerReconciliationStarted";
+export declare const CODE_REACTIVE_TASK_PLANNER_RECONCILIATION_FINISHED = "reactiveTaskPlannerReconciliationFinished";
+export declare const CODE_REACTIVE_TASK_PLANNER_STREAM_ERROR = "reactiveTaskPlannerStreamError";
+export declare const CODE_REACTIVE_TASK_LEADER_LOCK_LOST = "reactiveTaskLeaderLockLost";
+export declare const CODE_REACTIVE_TASK_INITIALIZED = "reactiveTaskInitialized";
+export declare const CODE_REACTIVE_TASK_CLEANUP = "reactiveTaskCleanup";
+export declare const REACTIVE_TASK_META_DOC_ID = "_mongodash_planner_meta";
+/**
+ * Filter for querying tasks.
+ * All fields are optional and operate as AND conditions.
+ */
+export interface ReactiveTaskQuery<T = unknown> {
+    /** Filter by specific task name(s) */
+    task?: string | string[];
+    /** Filter by task record ID */
+    _id?: string | ObjectId | string[] | ObjectId[];
+    /** Filter by task status */
+    status?: ReactiveTaskStatus | ReactiveTaskStatus[];
+    /**
+     * Filter by Source Document fields.
+     * This allows finding tasks based on the state of the original document.
+     *
+     * Examples:
+     * - `{ _id: 'user-123' }` -> Find tasks for specific doc.
+     * - `{ region: 'EU', active: true }` -> Find tasks for all active EU docs.
+     */
+    sourceDocFilter?: Filter<T>;
+    /** Search in lastError message (regex or text search) */
+    errorMessage?: string | RegExp;
+    /** Filter to tasks that have a lastError (true) or don't (false) */
+    hasError?: boolean;
+}
+export interface PaginationOptions {
+    limit?: number;
+    skip?: number;
+    sort?: {
+        field: keyof ReactiveTaskRecord;
+        direction: 1 | -1;
+    };
+}
+export interface PagedResult<T> {
+    items: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * Statistical summary of tasks matching a filter.
+ */
+export interface ReactiveTaskStatsOptions {
+    readPreference?: import('mongodb').ReadPreferenceLike;
+    groupByTask?: boolean;
+    includeStatusCounts?: boolean;
+    includeErrorCount?: boolean;
+    includeGlobalLag?: boolean;
+}
+export interface ReactiveTaskStatsResult {
+    statuses: {
+        _id: string | {
+            task: string;
+            status: string;
+        };
+        count: number;
+    }[];
+    errorCount?: number;
+    errorCounts?: {
+        _id: string;
+        count: number;
+    }[];
+    globalLag?: {
+        _id: string;
+        minScheduledAt: Date | null;
+    }[];
+}

package/dist/types/src/reactiveTasks/ReactiveTaskWorker.d.ts

@@ -0,0 +1,36 @@
+import { ReactiveTaskRegistry } from './ReactiveTaskRegistry';
+import { ReactiveTaskCaller, ReactiveTaskFilter } from './ReactiveTaskTypes';
+import { OnInfo } from '../OnInfo';
+import { OnError } from '../OnError';
+import { MetricsCollector } from './MetricsCollector';
+export interface WorkerCallbacks {
+    onTaskFound: (collectionName: string) => void;
+}
+/**
+ * Responsible for executing reactive tasks.
+ *
+ * Responsibilities:
+ * - Polls for pending tasks from the database.
+ * - Applies filtering to restrict which tasks this worker processes.
+ * - Locks tasks during execution to prevent concurrent processing.
+ * - Fetches the source document and executes the user-defined handler.
+ * - Handles task completion, failure, retries, and dead-letter queueing.
+ * - Manages the visibility timeout lock extension.
+ */
+export declare class ReactiveTaskWorker {
+    private instanceId;
+    private registry;
+    private callbacks;
+    private internalOptions;
+    private taskFilter?;
+    private onInfo;
+    private onError;
+    private metricsCollector?;
+    private taskCaller;
+    private throttledUntil;
+    constructor(instanceId: string, registry: ReactiveTaskRegistry, callbacks: WorkerCallbacks, internalOptions?: {
+        visibilityTimeoutMs: number;
+    }, taskCaller?: ReactiveTaskCaller, taskFilter?: ReactiveTaskFilter | undefined, onInfo?: OnInfo, onError?: OnError, metricsCollector?: MetricsCollector | undefined);
+    tryRunATask(collectionName: string): Promise<void>;
+    private processTask;
+}

package/dist/types/src/reactiveTasks/compileWatchProjection.d.ts

@@ -0,0 +1,12 @@
+import { Document } from 'mongodb';
+/**
+ * Compiles a user-friendly watchProjection into a strict Aggregation Expression.
+ * This handles:
+ * 1. Unflattening dotted keys (e.g. {'a.b': 1} -> {a: {b: '$a.b'}})
+ * 2. Converting shorthand inclusion (1/true) to field paths ('$key')
+ * 3. Validating that no unsupported features (like exclusion) are used.
+ *
+ * @param projection The user-provided projection.
+ * @returns An aggregation expression or string '$$ROOT'.
+ */
+export declare function compileWatchProjection(projection?: Document): Document | string;

package/dist/types/src/reactiveTasks/index.d.ts

@@ -0,0 +1,82 @@
+import { Document } from 'mongodb';
+import type { Registry } from 'prom-client';
+import { GlobalsCollection } from '../globalsCollection';
+import { OnError } from '../OnError';
+import { OnInfo } from '../OnInfo';
+import { ReactiveTaskManager } from './ReactiveTaskManager';
+import { ReactiveTaskRegistry } from './ReactiveTaskRegistry';
+import { PagedResult, PaginationOptions, ReactiveTask, ReactiveTaskQuery, ReactiveTaskRecord, ReactiveTaskSchedulerOptions } from './ReactiveTaskTypes';
+export { CODE_REACTIVE_TASK_CLEANUP, CODE_REACTIVE_TASK_FAILED, CODE_REACTIVE_TASK_FINISHED, CODE_REACTIVE_TASK_INITIALIZED, CODE_REACTIVE_TASK_LEADER_LOCK_LOST, CODE_REACTIVE_TASK_PLANNER_RECONCILIATION_FINISHED, CODE_REACTIVE_TASK_PLANNER_RECONCILIATION_STARTED, CODE_REACTIVE_TASK_PLANNER_STARTED, CODE_REACTIVE_TASK_PLANNER_STOPPED, CODE_REACTIVE_TASK_PLANNER_STREAM_ERROR, CODE_REACTIVE_TASK_STARTED, PagedResult, PaginationOptions, ReactiveTask, ReactiveTaskCaller, ReactiveTaskFilter, ReactiveTaskHandler, ReactiveTaskQuery, ReactiveTaskRecord, ReactiveTaskSchedulerOptions, ReactiveTaskStatus, REACTIVE_TASK_META_DOC_ID, TaskConditionFailedError, } from './ReactiveTaskTypes';
+export { scheduler as _scheduler };
+export type InitOptions = {
+    onError: OnError;
+    onInfo: OnInfo;
+    globalsCollection: GlobalsCollection;
+} & Partial<ReactiveTaskSchedulerOptions>;
+/**
+ * Main scheduler class implementing the described logic.
+ */
+/**
+ * Main entry point for the Reactive Tasks system.
+ *
+ * Responsibilities:
+ * - Orchestrates the initialization and configuration of the system.
+ * - Manages the lifecycle of `LeaderElector`, `ReactiveTaskPlanner`, and `ReactiveTaskWorker`.
+ * - Provides the public API for registering tasks and starting/stopping the system.
+ * - Configures the `ConcurrentRunner` for worker execution.
+ */
+export declare class ReactiveTaskScheduler {
+    private options;
+    private registry;
+    private _instanceId?;
+    private isRunning;
+    private concurrentRunner;
+    private leaderElector;
+    private taskPlanner;
+    private worker;
+    private metricsCollector;
+    private taskManager;
+    private internalOptions;
+    constructor();
+    /**
+     * Get the instanceId, generating one if not configured.
+     */
+    private get instanceId();
+    configure(options: Partial<ReactiveTaskSchedulerOptions>): void;
+    addTask(taskDef: ReactiveTask<Document>): Promise<void>;
+    /**
+     * Starts the entire system - leader election and workers.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the entire system.
+     */
+    stop(): Promise<void>;
+    getPrometheusMetrics(): Promise<Registry | null>;
+    getTaskManager(): ReactiveTaskManager;
+    getRegistry(): ReactiveTaskRegistry;
+}
+declare const scheduler: ReactiveTaskScheduler;
+export declare function init(initOptions: InitOptions): void;
+export declare function reactiveTask<T extends Document = Document>(taskDef: ReactiveTask<T>): Promise<void>;
+export declare function stopReactiveTasks(): Promise<void>;
+export declare function startReactiveTasks(): Promise<void>;
+/**
+ * Returns the Prometheus metrics for the Reactive Tasks system.
+ * Respects the 'scrapeMode' configuration.
+ */
+export declare function getPrometheusMetrics(): Promise<Registry | null>;
+/**
+ * List tasks matching the criteria.
+ */
+export declare function getReactiveTasks(query: ReactiveTaskQuery, pagination?: PaginationOptions): Promise<PagedResult<ReactiveTaskRecord>>;
+/**
+ * Count tasks matching criteria.
+ */
+export declare function countReactiveTasks(query: ReactiveTaskQuery): Promise<number>;
+/**
+ * Retries/Retriggers tasks matching the query.
+ */
+export declare function retryReactiveTasks(query: ReactiveTaskQuery): Promise<{
+    modifiedCount: number;
+}>;

package/dist/types/src/reactiveTasks/queryToExpression.d.ts

@@ -0,0 +1,13 @@
+import { Document } from 'mongodb';
+/**
+ * Converts a standard MongoDB query object into an Aggregation Expression.
+ * strict support for:
+ * - Implicit Equality: { a: 1 }
+ * - Comparisons: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin
+ * - Logical: $and, $or, $nor, $not
+ * - Regex: /pattern/, $regex
+ * - Existence: $exists
+ *
+ * THROWS error on unsupported operators (like $elemMatch, $all, $xyz) to avoid silent failures.
+ */
+export declare function queryToExpression(query: Document): Document;

package/dist/types/src/reactiveTasks/validateTaskFilter.d.ts

@@ -0,0 +1,10 @@
+import { Document } from 'mongodb';
+/**
+ * Normalizes the task filter into a valid Aggregation Expression.
+ * If the filter is a standard query (keys not starting with $), it is converted.
+ * If the filter is already an expression (keys starting with $), it is kept.
+ *
+ * @param filter The filter object to normalize.
+ * @param taskName The name of the task (for error context).
+ */
+export declare function normalizeTaskFilter(filter: Document | undefined, taskName: string): Document | undefined;

package/dist/types/src/task-management/OperationalTaskController.d.ts

@@ -0,0 +1,59 @@
+import { ReactiveTaskScheduler } from '../reactiveTasks/index';
+import { CronTaskQuery } from '../cronTasks';
+import { Document } from 'mongodb';
+export declare class OperationalTaskController {
+    private scheduler;
+    constructor(scheduler: ReactiveTaskScheduler);
+    getReactiveTasks(params: {
+        limit?: number;
+        skip?: number;
+        task?: string;
+        collection?: string;
+        status?: string;
+        errorMessage?: string;
+        hasError?: string;
+        sourceDocId?: string;
+    }): Promise<{
+        stats: import("../reactiveTasks/ReactiveTaskTypes").ReactiveTaskStatsResult;
+        items: import("../reactiveTasks/ReactiveTaskTypes").ReactiveTaskRecord<Document>[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    retryReactiveTasks(body: {
+        task?: string;
+        status?: string;
+        errorMessage?: string;
+        _id?: string;
+        sourceDocId?: string;
+    }): Promise<{
+        modifiedCount: number;
+    }>;
+    private createSmartIdFilter;
+    getCronTasks(params: CronTaskQuery): Promise<import("../cronTasks").CronPagedResult<import("../cronTasks").CronTaskRecord>>;
+    triggerCronTask(body: {
+        taskId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    getInfo(): Promise<{
+        databaseName: string;
+        reactiveTasks: {
+            name: string;
+            collection: string;
+            stats: {
+                success: number;
+                failed: number;
+                processing: number;
+                pending: number;
+                error: number;
+            };
+        }[];
+        cronTasks: {
+            id: string;
+            status: import("../cronTasks").CronTaskStatus;
+            lastRunError: string | null | undefined;
+            nextRunAt: Date;
+        }[];
+    }>;
+}

package/dist/types/src/task-management/index.d.ts

@@ -0,0 +1,3 @@
+export * from './OperationalTaskController';
+export * from './serveDashboard';
+export * from './types';

package/dist/types/src/task-management/serveDashboard.d.ts

@@ -0,0 +1,12 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { ReactiveTaskScheduler } from '../reactiveTasks/index';
+export interface ServeDashboardOptions {
+    dashboardPath?: string;
+    scheduler?: ReactiveTaskScheduler;
+}
+/**
+ * Serve the mongodash dashboard.
+ * Framework-agnostic: Works with Express, Koa, or native Node.js http.
+ * Returns true if the request was handled.
+ */
+export declare function serveDashboard(req: IncomingMessage, res: ServerResponse, options?: ServeDashboardOptions): Promise<boolean>;