@concavejs/runtime-cf-base 0.0.1-alpha.10

package/dist/durable-objects/sync-notifier.js

@@ -0,0 +1,38 @@
+/**
+ * Notifies the SyncDO of writes for subscription invalidation.
+ * Extracted from ConcaveDOBase for single-responsibility.
+ */
+export class SyncNotifier {
+    doState;
+    env;
+    constructor(doState, env) {
+        this.doState = doState;
+        this.env = env;
+    }
+    async notify(writtenRanges, writtenTables, commitTimestamp) {
+        if (!writtenRanges?.length && !writtenTables?.length) {
+            return;
+        }
+        try {
+            const instanceName = this.doState.id.name ?? "singleton";
+            const syncNamespace = this.env?.SYNC_DO;
+            if (!syncNamespace) {
+                return;
+            }
+            const syncId = syncNamespace.idFromName(instanceName);
+            const syncStub = syncNamespace.get(syncId);
+            await syncStub.fetch("http://do/notify", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    writtenRanges,
+                    writtenTables,
+                    commitTimestamp: commitTimestamp ? commitTimestamp.toString() : undefined,
+                }),
+            });
+        }
+        catch (error) {
+            console.warn("Failed to notify SyncDO", error?.message ?? error);
+        }
+    }
+}

package/dist/env.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Canonical environment type definitions for Concave Cloudflare Workers runtimes.
+ *
+ * Users can extend these interfaces via intersection types to add their own bindings.
+ */
+/** Core bindings required by every Concave Cloudflare worker. */
+export interface ConcaveEnv {
+    CONCAVE_DO: DurableObjectNamespace;
+    SYNC_DO: DurableObjectNamespace;
+}
+/** Bindings for R2-backed blob storage. */
+export interface ConcaveStorageEnv {
+    STORAGE_BUCKET: R2Bucket;
+    R2_PUBLIC_URL?: string;
+}
+/** Bindings for D1-backed docstore. */
+export interface ConcaveD1Env {
+    DB: D1Database;
+}

package/dist/env.js

@@ -0,0 +1,6 @@
+/**
+ * Canonical environment type definitions for Concave Cloudflare Workers runtimes.
+ *
+ * Users can extend these interfaces via intersection types to add their own bindings.
+ */
+export {};

package/dist/http/dx-http.d.ts

@@ -0,0 +1,43 @@
+import type { DocStore, DocumentLogEntry, DatabaseIndexUpdate, InternalDocumentId, Interval, Order, TimestampRange, GlobalKey, DocumentPrevTsQuery, LatestDocument, IndexKeyBytes, SearchIndexDefinition, VectorIndexDefinition } from "@concavejs/core/docstore";
+import type { JSONValue as JsonValue } from "convex/values";
+export declare class HttpDocStore implements DocStore {
+    private readonly url;
+    constructor(url: string);
+    private post;
+    setupSchema(options?: {
+        searchIndexes?: SearchIndexDefinition[];
+        vectorIndexes?: VectorIndexDefinition[];
+    }): Promise<void>;
+    write(documents: DocumentLogEntry[], indexes: Set<{
+        ts: bigint;
+        update: DatabaseIndexUpdate;
+    }>, conflictStrategy: "Error" | "Overwrite"): Promise<void>;
+    index_scan(indexId: string, tabletId: string, readTimestamp: bigint, interval: Interval, order: Order): AsyncGenerator<[IndexKeyBytes, LatestDocument]>;
+    load_documents(range: TimestampRange, order: Order): AsyncGenerator<DocumentLogEntry>;
+    getGlobal(key: GlobalKey): Promise<JsonValue | null>;
+    writeGlobal(key: GlobalKey, value: JsonValue): Promise<void>;
+    previous_revisions(queries: Set<{
+        id: InternalDocumentId;
+        ts: bigint;
+    }>): Promise<Map<string, DocumentLogEntry>>;
+    previous_revisions_of_documents(queries: Set<DocumentPrevTsQuery>): Promise<Map<string, DocumentLogEntry>>;
+    get(id: InternalDocumentId, readTimestamp?: bigint): Promise<LatestDocument | null>;
+    count(table: string): Promise<number>;
+    scan(table: string, readTimestamp?: bigint): Promise<LatestDocument[]>;
+    scanPaginated(tableId: string, cursor: string | null, limit: number, order: Order, readTimestamp?: bigint): Promise<{
+        documents: LatestDocument[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    search(indexId: string, searchQuery: string, filters: Map<string, unknown>, options?: {
+        limit?: number;
+    }): Promise<{
+        doc: LatestDocument;
+        score: number;
+    }[]>;
+    vectorSearch(indexId: string, vector: number[], limit: number, filters: Map<string, string>): Promise<{
+        doc: LatestDocument;
+        score: number;
+    }[]>;
+}
+export declare function handleRequest(docstore: DocStore, request: Request): Promise<Response>;

package/dist/http/dx-http.js

@@ -0,0 +1,327 @@
+// Serialization helpers
+function ab_to_hex(buffer) {
+    return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function hex_to_ab(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+    }
+    return bytes.buffer;
+}
+// Custom JSON serialization to handle BigInt, ArrayBuffer, Map, and Set.
+function serialize(obj) {
+    return JSON.stringify(obj, (_key, value) => {
+        if (typeof value === "bigint") {
+            return { __type: "bigint", value: value.toString() };
+        }
+        if (value instanceof ArrayBuffer) {
+            return { __type: "ArrayBuffer", value: ab_to_hex(value) };
+        }
+        if (value instanceof Map) {
+            return { __type: "Map", value: Array.from(value.entries()) };
+        }
+        if (value instanceof Set) {
+            return { __type: "Set", value: Array.from(value) };
+        }
+        return value;
+    });
+}
+function deserialize(json) {
+    const reviver = (_key, value) => {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            if (value.__type === "bigint") {
+                return BigInt(value.value);
+            }
+            if (value.__type === "ArrayBuffer") {
+                return hex_to_ab(value.value);
+            }
+            if (value.__type === "Map") {
+                return new Map(value.value.map(([k, v]) => [reviver("", k), reviver("", v)]));
+            }
+            if (value.__type === "Set") {
+                return new Set(value.value.map((v) => reviver("", v)));
+            }
+        }
+        return value;
+    };
+    return JSON.parse(json, reviver);
+}
+// Client-side implementation of DocStore over HTTP
+export class HttpDocStore {
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+    async post(path, body) {
+        const serializedBody = serialize(body);
+        return await fetch(`${this.url}/${path}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: serializedBody,
+        });
+    }
+    async setupSchema(options) {
+        const response = await this.post("setupSchema", options ?? {});
+        if (!response.ok) {
+            throw new Error(`setupSchema failed: ${await response.text()}`);
+        }
+    }
+    async write(documents, indexes, conflictStrategy) {
+        const response = await this.post("write", {
+            documents,
+            indexes,
+            conflictStrategy,
+        });
+        if (!response.ok) {
+            throw new Error(`write failed: ${await response.text()}`);
+        }
+    }
+    async *index_scan(indexId, tabletId, readTimestamp, interval, order) {
+        const response = await this.post("index_scan", {
+            indexId,
+            tabletId,
+            readTimestamp,
+            interval,
+            order,
+        });
+        if (!response.ok) {
+            throw new Error(`index_scan failed: ${await response.text()}`);
+        }
+        if (!response.body) {
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop();
+            for (const line of lines) {
+                if (line.trim() === "")
+                    continue;
+                yield deserialize(line);
+            }
+        }
+        if (buffer.trim() !== "") {
+            yield deserialize(buffer);
+        }
+    }
+    async *load_documents(range, order) {
+        const response = await this.post("load_documents", { range, order });
+        if (!response.ok) {
+            throw new Error(`load_documents failed: ${await response.text()}`);
+        }
+        if (!response.body) {
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop();
+            for (const line of lines) {
+                if (line.trim() === "")
+                    continue;
+                yield deserialize(line);
+            }
+        }
+        if (buffer.trim() !== "") {
+            yield deserialize(buffer);
+        }
+    }
+    async getGlobal(key) {
+        const response = await this.post("getGlobal", { key });
+        if (!response.ok) {
+            throw new Error(`getGlobal failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async writeGlobal(key, value) {
+        const response = await this.post("writeGlobal", { key, value });
+        if (!response.ok) {
+            throw new Error(`writeGlobal failed: ${await response.text()}`);
+        }
+    }
+    async previous_revisions(queries) {
+        const response = await this.post("previous_revisions", { queries });
+        if (!response.ok) {
+            throw new Error(`previous_revisions failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async previous_revisions_of_documents(queries) {
+        const response = await this.post("previous_revisions_of_documents", {
+            queries,
+        });
+        if (!response.ok) {
+            throw new Error(`previous_revisions_of_documents failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async get(id, readTimestamp) {
+        const response = await this.post("get", { id, readTimestamp });
+        if (!response.ok) {
+            throw new Error(`get failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async count(table) {
+        const response = await this.post("count", { table });
+        if (!response.ok) {
+            throw new Error(`count failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async scan(table, readTimestamp) {
+        const response = await this.post("scan", { table, readTimestamp });
+        if (!response.ok) {
+            throw new Error(`scan failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async scanPaginated(tableId, cursor, limit, order, readTimestamp) {
+        const response = await this.post("scanPaginated", { tableId, cursor, limit, order, readTimestamp });
+        if (!response.ok) {
+            throw new Error(`scanPaginated failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async search(indexId, searchQuery, filters, options) {
+        const response = await this.post("search", { indexId, searchQuery, filters, options });
+        if (!response.ok) {
+            throw new Error(`search failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+    async vectorSearch(indexId, vector, limit, filters) {
+        const response = await this.post("vectorSearch", { indexId, vector, limit, filters });
+        if (!response.ok) {
+            throw new Error(`vectorSearch failed: ${await response.text()}`);
+        }
+        return deserialize(await response.text());
+    }
+}
+// Server-side request handler
+export async function handleRequest(docstore, request) {
+    const url = new URL(request.url);
+    const path = url.pathname.split("/").pop();
+    if (request.method !== "POST") {
+        return new Response("Method not allowed", { status: 405 });
+    }
+    try {
+        const body = await request.text();
+        const args = body ? deserialize(body) : {};
+        switch (path) {
+            case "setupSchema":
+                await docstore.setupSchema(args);
+                return new Response(null, { status: 200 });
+            case "write":
+                await docstore.write(args.documents, args.indexes, args.conflictStrategy);
+                return new Response(null, { status: 200 });
+            case "index_scan": {
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        try {
+                            for await (const row of docstore.index_scan(args.indexId, args.tabletId, args.readTimestamp, args.interval, args.order)) {
+                                controller.enqueue(serialize(row) + "\n");
+                            }
+                            controller.close();
+                        }
+                        catch (e) {
+                            controller.error(e);
+                        }
+                    },
+                });
+                const encoder = new TextEncoder();
+                const encodedStream = stream.pipeThrough(new TransformStream({
+                    transform(chunk, controller) {
+                        controller.enqueue(encoder.encode(chunk));
+                    },
+                }));
+                return new Response(encodedStream, {
+                    headers: { "Content-Type": "application/x-ndjson" },
+                });
+            }
+            case "load_documents": {
+                const stream = new ReadableStream({
+                    async start(controller) {
+                        try {
+                            for await (const row of docstore.load_documents(args.range, args.order)) {
+                                controller.enqueue(serialize(row) + "\n");
+                            }
+                            controller.close();
+                        }
+                        catch (e) {
+                            controller.error(e);
+                        }
+                    },
+                });
+                const encoder = new TextEncoder();
+                const encodedStream = stream.pipeThrough(new TransformStream({
+                    transform(chunk, controller) {
+                        controller.enqueue(encoder.encode(chunk));
+                    },
+                }));
+                return new Response(encodedStream, {
+                    headers: { "Content-Type": "application/x-ndjson" },
+                });
+            }
+            case "getGlobal": {
+                const result = await docstore.getGlobal(args.key);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "writeGlobal":
+                await docstore.writeGlobal(args.key, args.value);
+                return new Response(null, { status: 200 });
+            case "previous_revisions": {
+                const result = await docstore.previous_revisions(args.queries);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "previous_revisions_of_documents": {
+                const result = await docstore.previous_revisions_of_documents(args.queries);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "get": {
+                const result = await docstore.get(args.id, args.readTimestamp);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "count": {
+                const result = await docstore.count(args.table);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            case "scan": {
+                const result = await docstore.scan(args.table, args.readTimestamp);
+                return new Response(serialize(result), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            default:
+                return new Response("Not Found", { status: 404 });
+        }
+    }
+    catch (e) {
+        return new Response(e.stack || e.toString(), { status: 500 });
+    }
+}

package/dist/http/http-api.d.ts

@@ -0,0 +1,38 @@
+import type { SerializedKeyRange } from "@concavejs/core/queryengine";
+/** Minimal Env shape needed by the HTTP API handler */
+interface Env {
+    CONCAVE_DO: DurableObjectNamespace;
+    SYNC_DO: DurableObjectNamespace;
+    SYNC_NOTIFY_QUEUE?: QueueLike;
+}
+type QueueLike = {
+    send(message: unknown): Promise<void>;
+};
+export interface HttpApiRoutingTargets {
+    /** Physical ConcaveDO name for execution traffic. Defaults to the logical `instance`. */
+    concaveDoName?: string;
+    /** Alias for non-DO runtimes to describe the write execution target identifier. */
+    concaveTargetName?: string;
+    /**
+     * Physical SyncDO names to notify after writes.
+     * Defaults to `[instance]`.
+     */
+    syncDoNames?: string[];
+    /** Alias for non-DO runtimes to describe sync invalidation targets. */
+    syncTargetNames?: string[];
+    /**
+     * Optional custom write dispatcher.
+     * When set, it is responsible for fanning out invalidations (queue, stream, etc.).
+     */
+    dispatchSyncWrites?: (payload: SyncWriteDispatchPayload) => Promise<void>;
+}
+export interface SyncWriteDispatchPayload {
+    logicalInstance: string;
+    projectId?: string;
+    syncTargets: string[];
+    writtenRanges?: SerializedKeyRange[];
+    writtenTables?: string[];
+    commitTimestamp?: string;
+}
+export declare function handleHttpApiRequest(request: Request, env: Env, ctx: ExecutionContext, instance?: string, routingTargets?: HttpApiRoutingTargets): Promise<Response>;
+export {};