lopata 0.15.0 → 0.16.1

package/dist/types/api/cors.d.ts

@@ -0,0 +1,2 @@
+export declare function withCors(response: Response): Response;
+export declare function handlePreflight(): Response;

package/dist/types/api/dispatch.d.ts

@@ -0,0 +1,393 @@
+import type { HandlerContext } from './types';
+declare const allHandlers: {
+    'hosts.check'(_input: {}, ctx: HandlerContext): import("./types").HostsCheckResponse;
+    'routes.list'(_input: {}, ctx: HandlerContext): import("./types").RouteInfo[];
+    'warnings.optionalDeps'(_input: {}): import("../warnings").OptionalDep[];
+    'analyticsEngine.list'({ dataset, limit }: {
+        dataset?: string;
+        limit?: number;
+    }): import("./types").AnalyticsEngineDataPoint[];
+    'analyticsEngine.get'({ id }: {
+        id: string;
+    }): import("./types").AnalyticsEngineDataPoint | null;
+    'analyticsEngine.delete'({ id }: {
+        id: string;
+    }): import("./types").OkResponse;
+    'analyticsEngine.datasets'(_input: {}): string[];
+    'analyticsEngine.stats'(_input: {}): {
+        total: number;
+        byDataset: Record<string, number>;
+    };
+    'ai.list'({ model, status, limit }: {
+        model?: string;
+        status?: string;
+        limit?: number;
+    }): import("./types").AiRequest[];
+    'ai.get'({ id }: {
+        id: string;
+    }): import("./types").AiRequest | null;
+    'ai.delete'({ id }: {
+        id: string;
+    }): import("./types").OkResponse;
+    'ai.stats'(_input: {}): {
+        total: number;
+        byModel: Record<string, number>;
+        byStatus: Record<string, number>;
+        avgDuration: number;
+    };
+    'ai.models'(_input: {}): string[];
+    'email.list'({ status, limit }: {
+        status?: string;
+        limit?: number;
+    }): import("./types").EmailRecord[];
+    'email.get'({ id }: {
+        id: string;
+    }): {
+        record: import("./types").EmailRecord;
+        raw: string;
+    } | null;
+    'email.delete'({ id }: {
+        id: string;
+    }): import("./types").OkResponse;
+    'email.trigger'({ from, to, subject, body }: {
+        from: string;
+        to: string;
+        subject?: string;
+        body?: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'email.stats'(_input: {}, _ctx: HandlerContext): {
+        total: number;
+        byStatus: Record<string, number>;
+    };
+    'scheduled.listTriggers'(_input: {}, ctx: HandlerContext): import("./handlers/scheduled").ScheduledTrigger[];
+    'scheduled.trigger'({ cron, workerName }: {
+        cron: string;
+        workerName?: string | null;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'errors.list'(input: {
+        limit?: number;
+        cursor?: string;
+    }): {
+        items: Array<{
+            id: string;
+            timestamp: number;
+            errorName: string;
+            errorMessage: string;
+            requestMethod: string | null;
+            requestUrl: string | null;
+            workerName: string | null;
+            traceId: string | null;
+            spanId: string | null;
+            source: string | null;
+        }>;
+        cursor: string | null;
+    };
+    'errors.get'(input: {
+        id: string;
+    }): {
+        id: string;
+        timestamp: number;
+        traceId: string | null;
+        spanId: string | null;
+        source: string | null;
+        data: unknown;
+    };
+    'errors.delete'(input: {
+        id: string;
+    }): {
+        ok: true;
+    };
+    'errors.clear'(_input: {}): {
+        ok: true;
+    };
+    'config.forService'({ type }: {
+        type: string;
+    }, ctx: HandlerContext): import("./handlers/config").ConfigGroup[];
+    'traces.list'(input: {
+        limit?: number;
+        cursor?: string;
+    }): {
+        items: import("./types").TraceSummary[];
+        cursor: string | null;
+    };
+    'traces.getTrace'(input: {
+        traceId: string;
+    }): import("./types").TraceDetail;
+    'traces.search'(input: {
+        query: string;
+        limit?: number;
+    }): {
+        items: import("./types").TraceSummary[];
+        cursor: string | null;
+    };
+    'traces.listSpans'(input: {
+        limit?: number;
+        cursor?: string;
+    }): {
+        items: Array<{
+            spanId: string;
+            traceId: string;
+            name: string;
+            status: string;
+            durationMs: number | null;
+            startTime: number;
+            workerName: string | null;
+        }>;
+        cursor: string | null;
+    };
+    'traces.listLogs'(input: {
+        limit?: number;
+        cursor?: string;
+    }): {
+        items: Array<{
+            id: number;
+            spanId: string;
+            traceId: string;
+            timestamp: number;
+            name: string;
+            level: string | null;
+            message: string | null;
+        }>;
+        cursor: string | null;
+    };
+    'traces.errors'(input: {
+        traceId: string;
+    }): {
+        id: string;
+        timestamp: number;
+        errorName: string;
+        errorMessage: string;
+        source: string | null;
+        data: unknown;
+    }[];
+    'traces.clear'(_input: {}): {
+        ok: true;
+    };
+    'containers.list'(_input: {}, ctx: HandlerContext): Promise<import("./types").ContainerSummary[]>;
+    'containers.listInstances'({ className }: {
+        className: string;
+    }, _ctx: HandlerContext): Promise<import("./types").ContainerInstance[]>;
+    'containers.getDetail'({ className, id }: {
+        className: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").ContainerDetail>;
+    'containers.getLogs'({ className, id, tail }: {
+        className: string;
+        id: string;
+        tail?: number;
+    }): Promise<{
+        logs: string;
+    }>;
+    'containers.stop'({ className, id }: {
+        className: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'containers.destroy'({ className, id }: {
+        className: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'workers.list'(_input: {}, ctx: HandlerContext): import("./types").WorkerInfo[];
+    'generations.detail'(input: {
+        id: number;
+        workerName?: string;
+    }, ctx: HandlerContext): import("./types").GenerationDetail;
+    'generations.list'(_input: {}, ctx: HandlerContext): import("./types").GenerationsData;
+    'generations.reload'(input: {
+        workerName?: string;
+    }, ctx: HandlerContext): Promise<{
+        ok: true;
+        generation: import("./types").GenerationInfo;
+    }>;
+    'generations.drain'(input: {
+        workerName?: string;
+    }, ctx: HandlerContext): {
+        ok: true;
+        stoppedGeneration: number;
+    };
+    'generations.config'({ gracePeriodMs, workerName }: {
+        gracePeriodMs: number;
+        workerName?: string;
+    }, ctx: HandlerContext): {
+        ok: true;
+        gracePeriodMs: number;
+    };
+    'cache.listCaches'(_input: {}): import("./types").CacheName[];
+    'cache.listEntries'({ name }: {
+        name: string;
+    }): import("./types").CacheEntry[];
+    'cache.deleteEntry'({ name, url }: {
+        name: string;
+        url: string;
+    }): import("./types").OkResponse;
+    'd1.listDatabases'(_input: {}, ctx: HandlerContext): import("./types").D1Database[];
+    'd1.listTables'({ dbName }: {
+        dbName: string;
+    }): import("./types").D1Table[];
+    'd1.generateSql'({ dbName, prompt }: {
+        dbName: string;
+        prompt: string;
+    }, ctx: HandlerContext): Promise<{
+        sql: string;
+    }>;
+    'd1.query'({ dbName, sql }: {
+        dbName: string;
+        sql: string;
+    }): import("./types").QueryResult;
+    'workflows.list'(_input: {}, ctx: HandlerContext): import("./types").WorkflowSummary[];
+    'workflows.listInstances'({ name, status }: {
+        name: string;
+        status?: string;
+    }): import("./types").WorkflowInstance[];
+    'workflows.getInstance'({ id }: {
+        name: string;
+        id: string;
+    }): import("./types").WorkflowDetail;
+    'workflows.terminate'({ name, id }: {
+        name: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'workflows.create'({ name, params }: {
+        name: string;
+        params: string;
+    }, ctx: HandlerContext): Promise<{
+        ok: true;
+        id: string;
+    }>;
+    'workflows.pause'({ name, id }: {
+        name: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'workflows.resume'({ name, id }: {
+        name: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'workflows.restart'({ name, id, fromStep }: {
+        name: string;
+        id: string;
+        fromStep?: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'workflows.skipSleep'({ name, id }: {
+        name: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'workflows.sendEvent'({ name, id, type, payload }: {
+        name: string;
+        id: string;
+        type: string;
+        payload?: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'workflows.duplicate'({ name, id }: {
+        name: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<{
+        ok: true;
+        id: string;
+    }>;
+    'do.listNamespaces'(_input: {}, ctx: HandlerContext): import("./types").DoNamespace[];
+    'do.listInstances'({ ns }: {
+        ns: string;
+    }): import("./types").DoInstance[];
+    'do.getInstance'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): import("./types").DoDetail;
+    'do.deleteEntry'({ ns, id, key }: {
+        ns: string;
+        id: string;
+        key: string;
+    }): import("./types").OkResponse;
+    'do.listSqlTables'({ ns, id }: {
+        ns: string;
+        id: string;
+    }): import("./types").D1Table[];
+    'do.triggerAlarm'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<import("./types").OkResponse>;
+    'do.cancelAlarm'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): import("./types").OkResponse;
+    'do.deleteInstance'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): import("./types").OkResponse;
+    'do.generateSql'({ ns, id, prompt }: {
+        ns: string;
+        id: string;
+        prompt: string;
+    }, ctx: HandlerContext): Promise<{
+        sql: string;
+    }>;
+    'do.sqlQuery'({ ns, id, sql }: {
+        ns: string;
+        id: string;
+        sql: string;
+    }): import("./types").QueryResult;
+    'queue.listQueues'(_input: {}, ctx: HandlerContext): import("./types").QueueInfo[];
+    'queue.listMessages'({ queue, limit, status }: {
+        queue: string;
+        limit?: number;
+        status?: string;
+    }): import("./types").QueueMessage[];
+    'queue.deleteMessage'({ queue, id }: {
+        queue: string;
+        id: string;
+    }): import("./types").OkResponse;
+    'queue.publishMessage'({ queue, body, contentType }: {
+        queue: string;
+        body: string;
+        contentType?: string;
+    }): import("./types").OkResponse;
+    'queue.requeueMessage'({ queue, id }: {
+        queue: string;
+        id: string;
+    }): import("./types").OkResponse;
+    'r2.listBuckets'(_input: {}, ctx: HandlerContext): import("./types").R2Bucket[];
+    'r2.listObjects'({ bucket, limit, cursor, prefix }: {
+        bucket: string;
+        limit?: number;
+        cursor?: string;
+        prefix?: string;
+    }): import("./types").Paginated<import("./types").R2Object>;
+    'r2.deleteObject'({ bucket, key }: {
+        bucket: string;
+        key: string;
+    }): import("./types").OkResponse;
+    'r2.renameObject'({ bucket, oldKey, newKey }: {
+        bucket: string;
+        oldKey: string;
+        newKey: string;
+    }): Promise<import("./types").OkResponse>;
+    'kv.listNamespaces'(_input: {}, ctx: HandlerContext): import("./types").KvNamespace[];
+    'kv.listKeys'({ ns, limit, cursor, prefix }: {
+        ns: string;
+        limit?: number;
+        cursor?: string;
+        prefix?: string;
+    }): import("./types").Paginated<import("./types").KvKey>;
+    'kv.getKey'({ ns, key }: {
+        ns: string;
+        key: string;
+    }): import("./types").KvValue;
+    'kv.putKey'({ ns, key, value, metadata, expirationTtl }: {
+        ns: string;
+        key: string;
+        value: string;
+        metadata?: string;
+        expirationTtl?: number;
+    }): import("./types").OkResponse;
+    'kv.deleteKey'({ ns, key }: {
+        ns: string;
+        key: string;
+    }): import("./types").OkResponse;
+    'overview.get'(_input: {}, ctx: HandlerContext): import("./types").OverviewData;
+};
+export type Procedures = {
+    [K in keyof typeof allHandlers]: {
+        input: Parameters<(typeof allHandlers)[K]>[0];
+        output: Awaited<ReturnType<(typeof allHandlers)[K]>>;
+    };
+};
+export declare function dispatch(request: Request, ctx: HandlerContext): Promise<Response>;
+export {};

package/dist/types/api/generate-sql.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from 'bun:sqlite';
+import type { LopataConfig } from '../lopata-config';
+export declare function generateSqlFromPrompt(db: Database, prompt: string, lopataConfig: LopataConfig | null): Promise<string>;

package/dist/types/api/handlers/ai.d.ts

@@ -0,0 +1,21 @@
+import type { AiRequest, OkResponse } from '../types';
+export declare const handlers: {
+    'ai.list'({ model, status, limit }: {
+        model?: string;
+        status?: string;
+        limit?: number;
+    }): AiRequest[];
+    'ai.get'({ id }: {
+        id: string;
+    }): AiRequest | null;
+    'ai.delete'({ id }: {
+        id: string;
+    }): OkResponse;
+    'ai.stats'(_input: {}): {
+        total: number;
+        byModel: Record<string, number>;
+        byStatus: Record<string, number>;
+        avgDuration: number;
+    };
+    'ai.models'(_input: {}): string[];
+};

package/dist/types/api/handlers/analytics-engine.d.ts

@@ -0,0 +1,18 @@
+import type { AnalyticsEngineDataPoint as AEDataPoint, OkResponse } from '../types';
+export declare const handlers: {
+    'analyticsEngine.list'({ dataset, limit }: {
+        dataset?: string;
+        limit?: number;
+    }): AEDataPoint[];
+    'analyticsEngine.get'({ id }: {
+        id: string;
+    }): AEDataPoint | null;
+    'analyticsEngine.delete'({ id }: {
+        id: string;
+    }): OkResponse;
+    'analyticsEngine.datasets'(_input: {}): string[];
+    'analyticsEngine.stats'(_input: {}): {
+        total: number;
+        byDataset: Record<string, number>;
+    };
+};

package/dist/types/api/handlers/cache.d.ts

@@ -0,0 +1,11 @@
+import type { CacheEntry, CacheName, OkResponse } from '../types';
+export declare const handlers: {
+    'cache.listCaches'(_input: {}): CacheName[];
+    'cache.listEntries'({ name }: {
+        name: string;
+    }): CacheEntry[];
+    'cache.deleteEntry'({ name, url }: {
+        name: string;
+        url: string;
+    }): OkResponse;
+};

package/dist/types/api/handlers/config.d.ts

@@ -0,0 +1,14 @@
+import type { HandlerContext } from '../types';
+export interface ConfigItem {
+    name: string;
+    value: string;
+}
+export interface ConfigGroup {
+    title: string;
+    items: ConfigItem[];
+}
+export declare const handlers: {
+    'config.forService'({ type }: {
+        type: string;
+    }, ctx: HandlerContext): ConfigGroup[];
+};

package/dist/types/api/handlers/containers.d.ts

@@ -0,0 +1,26 @@
+import type { ContainerDetail, ContainerInstance, ContainerSummary, HandlerContext, OkResponse } from '../types';
+export declare const handlers: {
+    'containers.list'(_input: {}, ctx: HandlerContext): Promise<ContainerSummary[]>;
+    'containers.listInstances'({ className }: {
+        className: string;
+    }, _ctx: HandlerContext): Promise<ContainerInstance[]>;
+    'containers.getDetail'({ className, id }: {
+        className: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<ContainerDetail>;
+    'containers.getLogs'({ className, id, tail }: {
+        className: string;
+        id: string;
+        tail?: number;
+    }): Promise<{
+        logs: string;
+    }>;
+    'containers.stop'({ className, id }: {
+        className: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<OkResponse>;
+    'containers.destroy'({ className, id }: {
+        className: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<OkResponse>;
+};

package/dist/types/api/handlers/d1.d.ts

@@ -0,0 +1,17 @@
+import type { D1Database as D1DatabaseInfo, D1Table, HandlerContext, QueryResult } from '../types';
+export declare const handlers: {
+    'd1.listDatabases'(_input: {}, ctx: HandlerContext): D1DatabaseInfo[];
+    'd1.listTables'({ dbName }: {
+        dbName: string;
+    }): D1Table[];
+    'd1.generateSql'({ dbName, prompt }: {
+        dbName: string;
+        prompt: string;
+    }, ctx: HandlerContext): Promise<{
+        sql: string;
+    }>;
+    'd1.query'({ dbName, sql }: {
+        dbName: string;
+        sql: string;
+    }): QueryResult;
+};

package/dist/types/api/handlers/do.d.ts

@@ -0,0 +1,44 @@
+import type { D1Table, DoDetail, DoInstance, DoNamespace, HandlerContext, OkResponse, QueryResult } from '../types';
+export declare const handlers: {
+    'do.listNamespaces'(_input: {}, ctx: HandlerContext): DoNamespace[];
+    'do.listInstances'({ ns }: {
+        ns: string;
+    }): DoInstance[];
+    'do.getInstance'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): DoDetail;
+    'do.deleteEntry'({ ns, id, key }: {
+        ns: string;
+        id: string;
+        key: string;
+    }): OkResponse;
+    'do.listSqlTables'({ ns, id }: {
+        ns: string;
+        id: string;
+    }): D1Table[];
+    'do.triggerAlarm'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): Promise<OkResponse>;
+    'do.cancelAlarm'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): OkResponse;
+    'do.deleteInstance'({ ns, id }: {
+        ns: string;
+        id: string;
+    }, ctx: HandlerContext): OkResponse;
+    'do.generateSql'({ ns, id, prompt }: {
+        ns: string;
+        id: string;
+        prompt: string;
+    }, ctx: HandlerContext): Promise<{
+        sql: string;
+    }>;
+    'do.sqlQuery'({ ns, id, sql }: {
+        ns: string;
+        id: string;
+        sql: string;
+    }): QueryResult;
+};

package/dist/types/api/handlers/email.d.ts

@@ -0,0 +1,26 @@
+import type { EmailRecord, HandlerContext, OkResponse } from '../types';
+export declare const handlers: {
+    'email.list'({ status, limit }: {
+        status?: string;
+        limit?: number;
+    }): EmailRecord[];
+    'email.get'({ id }: {
+        id: string;
+    }): {
+        record: EmailRecord;
+        raw: string;
+    } | null;
+    'email.delete'({ id }: {
+        id: string;
+    }): OkResponse;
+    'email.trigger'({ from, to, subject, body }: {
+        from: string;
+        to: string;
+        subject?: string;
+        body?: string;
+    }, ctx: HandlerContext): Promise<OkResponse>;
+    'email.stats'(_input: {}, _ctx: HandlerContext): {
+        total: number;
+        byStatus: Record<string, number>;
+    };
+};

package/dist/types/api/handlers/errors.d.ts

@@ -0,0 +1,38 @@
+export declare const handlers: {
+    'errors.list'(input: {
+        limit?: number;
+        cursor?: string;
+    }): {
+        items: Array<{
+            id: string;
+            timestamp: number;
+            errorName: string;
+            errorMessage: string;
+            requestMethod: string | null;
+            requestUrl: string | null;
+            workerName: string | null;
+            traceId: string | null;
+            spanId: string | null;
+            source: string | null;
+        }>;
+        cursor: string | null;
+    };
+    'errors.get'(input: {
+        id: string;
+    }): {
+        id: string;
+        timestamp: number;
+        traceId: string | null;
+        spanId: string | null;
+        source: string | null;
+        data: unknown;
+    };
+    'errors.delete'(input: {
+        id: string;
+    }): {
+        ok: true;
+    };
+    'errors.clear'(_input: {}): {
+        ok: true;
+    };
+};

package/dist/types/api/handlers/generations.d.ts

@@ -0,0 +1,27 @@
+import type { GenerationDetail, GenerationInfo, GenerationsData, HandlerContext } from '../types';
+export declare const handlers: {
+    'generations.detail'(input: {
+        id: number;
+        workerName?: string;
+    }, ctx: HandlerContext): GenerationDetail;
+    'generations.list'(_input: {}, ctx: HandlerContext): GenerationsData;
+    'generations.reload'(input: {
+        workerName?: string;
+    }, ctx: HandlerContext): Promise<{
+        ok: true;
+        generation: GenerationInfo;
+    }>;
+    'generations.drain'(input: {
+        workerName?: string;
+    }, ctx: HandlerContext): {
+        ok: true;
+        stoppedGeneration: number;
+    };
+    'generations.config'({ gracePeriodMs, workerName }: {
+        gracePeriodMs: number;
+        workerName?: string;
+    }, ctx: HandlerContext): {
+        ok: true;
+        gracePeriodMs: number;
+    };
+};

package/dist/types/api/handlers/hosts.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext, HostsCheckResponse } from '../types';
+export declare const handlers: {
+    'hosts.check'(_input: {}, ctx: HandlerContext): HostsCheckResponse;
+};

package/dist/types/api/handlers/kv.d.ts

@@ -0,0 +1,25 @@
+import type { HandlerContext, KvKey, KvNamespace, KvValue, OkResponse, Paginated } from '../types';
+export declare const handlers: {
+    'kv.listNamespaces'(_input: {}, ctx: HandlerContext): KvNamespace[];
+    'kv.listKeys'({ ns, limit, cursor, prefix }: {
+        ns: string;
+        limit?: number;
+        cursor?: string;
+        prefix?: string;
+    }): Paginated<KvKey>;
+    'kv.getKey'({ ns, key }: {
+        ns: string;
+        key: string;
+    }): KvValue;
+    'kv.putKey'({ ns, key, value, metadata, expirationTtl }: {
+        ns: string;
+        key: string;
+        value: string;
+        metadata?: string;
+        expirationTtl?: number;
+    }): OkResponse;
+    'kv.deleteKey'({ ns, key }: {
+        ns: string;
+        key: string;
+    }): OkResponse;
+};