@concavejs/runtime-cf-base 0.0.1-alpha.7 → 0.0.1-alpha.9

package/dist/durable-objects/blobstore-rpc.d.ts

@@ -0,0 +1,13 @@
+import type { BlobStore, StorageOptions, StorageMetadata } from "@concavejs/core/abstractions";
+/**
+ * BlobStore RPC surface for service-binding isolation.
+ * Provides async delegation methods for blob storage operations.
+ */
+export declare class BlobStoreRpc {
+    private readonly blobstore;
+    constructor(blobstore: BlobStore);
+    store(buffer: ArrayBuffer, options?: StorageOptions): Promise<StorageMetadata>;
+    get(storageId: string): Promise<ArrayBuffer | null>;
+    delete(storageId: string): Promise<void>;
+    getUrl(storageId: string): Promise<string | null>;
+}

package/dist/durable-objects/blobstore-rpc.js

@@ -0,0 +1,27 @@
+/**
+ * BlobStore RPC surface for service-binding isolation.
+ * Provides async delegation methods for blob storage operations.
+ */
+export class BlobStoreRpc {
+    blobstore;
+    constructor(blobstore) {
+        this.blobstore = blobstore;
+    }
+    async store(buffer, options) {
+        return this.blobstore.store(buffer, options);
+    }
+    async get(storageId) {
+        const result = await this.blobstore.get(storageId);
+        if (result === null)
+            return null;
+        if (result instanceof Blob)
+            return result.arrayBuffer();
+        return result;
+    }
+    async delete(storageId) {
+        return this.blobstore.delete(storageId);
+    }
+    async getUrl(storageId) {
+        return this.blobstore.getUrl(storageId);
+    }
+}

package/dist/durable-objects/concave-do-base.d.ts

@@ -63,6 +63,10 @@ export declare class ConcaveDOBase extends DurableObject {
     env: any;
     protected scheduler: ScheduledFunctionExecutor;
     protected cronExecutor: CronExecutor;
+    private readonly docStoreRpc;
+    private readonly blobStoreRpc;
+    private readonly syncNotifier;
+    private schedulerManager;
     constructor(state: DurableObjectState, env: any, config: ConcaveDOConfig);
     /**
      * Initialize scheduler and cron executor

package/dist/durable-objects/concave-do-base.js

@@ -14,6 +14,10 @@ import { runAsClientCall, runAsServerCall } from "@concavejs/core/udf";
 import { ScheduledFunctionExecutor, CronExecutor } from "@concavejs/core";
 import { resolveAuthContext } from "@concavejs/core/http";
 import { AdminAuthError, identityFromToken, isAdminToken, isSystemToken, JWTValidationError, resolveAdminAuthConfigFromEnv, resolveJwtValidationConfigFromEnv, resolveSystemAuthConfigFromEnv, setAdminAuthConfig, setJwtValidationConfig, setSystemAuthConfig, SystemAuthError, } from "@concavejs/core/auth";
+import { DocStoreRpc } from "./docstore-rpc";
+import { BlobStoreRpc } from "./blobstore-rpc";
+import { SyncNotifier } from "./sync-notifier";
+import { SchedulerManager } from "./scheduler-manager";
 const VERSIONED_API_PREFIX = /^\/api\/\d+\.\d+(?:\.\d+)?(?=\/|$)/;
 function stripApiVersionPrefix(pathname) {
     return pathname.replace(VERSIONED_API_PREFIX, "/api");
@@ -86,6 +90,10 @@ export class ConcaveDOBase extends DurableObject {
     env;
     scheduler;
     cronExecutor;
+    docStoreRpc;
+    blobStoreRpc;
+    syncNotifier;
+    schedulerManager;
     constructor(state, env, config) {
         super(state, env);
         this.doState = state;
@@ -108,6 +116,9 @@ export class ConcaveDOBase extends DurableObject {
         this._docstore = config.createDocstore ? config.createDocstore(adapterContext) : new DODocStore(state);
         // Create BlobStore (allow override for testing or alternative implementations)
         this._blobstore = config.createBlobstore?.(adapterContext);
+        this.docStoreRpc = new DocStoreRpc(this._docstore);
+        this.blobStoreRpc = this._blobstore ? new BlobStoreRpc(this._blobstore) : null;
+        this.syncNotifier = new SyncNotifier(state, env);
         // Create UDF executor from resolved runtime services
         this.udfExecutor = config.createUdfExecutor({
             ...adapterContext,
@@ -152,6 +163,7 @@ export class ConcaveDOBase extends DurableObject {
             notifyWrites,
             allocateTimestamp,
         });
+        this.schedulerManager = new SchedulerManager(this.scheduler, this.cronExecutor, this.doState);
     }
     /**
      * Discover and sync cron specs during DO initialization.
@@ -223,7 +235,9 @@ export class ConcaveDOBase extends DurableObject {
             const exec = () => this.execute(path, convexArgs, type, auth, componentPath, requestId, parsedSnapshotTimestamp);
             const result = caller === "server" ? await runAsServerCall(exec, path) : await runAsClientCall(exec);
             if (type === "mutation" || type === "action") {
-                this.doState.waitUntil(this.reschedule());
+                this.doState.waitUntil(this.reschedule().catch((error) => {
+                    console.error("[ConcaveDO] Failed to reschedule alarm", error?.message ?? error);
+                }));
             }
             const writtenTables = writtenTablesFromRanges(result.writtenRanges) ?? [];
             const responseBody = {
@@ -240,8 +254,9 @@ export class ConcaveDOBase extends DurableObject {
         }
         catch (e) {
             console.error(e);
-            return new Response("Internal Server Error", {
-                headers: this.corsHeaders(request),
+            const errorMessage = e?.message ?? "Internal Server Error";
+            return new Response(JSON.stringify({ error: errorMessage }), {
+                headers: { "Content-Type": "application/json", ...this.corsHeaders(request) },
                 status: 500,
             });
         }
@@ -288,170 +303,103 @@ export class ConcaveDOBase extends DurableObject {
      * Handle scheduled function alarms
      */
     async alarm() {
-        try {
-            const scheduledResult = await this.scheduler.runDueJobs();
-            const cronResult = await this.cronExecutor.runDueJobs();
-            const nextTimes = [scheduledResult.nextScheduledTime, cronResult.nextScheduledTime].filter((t) => t !== null);
-            if (nextTimes.length === 0) {
-                await this.doState.storage.deleteAlarm();
-            }
-            else {
-                await this.doState.storage.setAlarm(Math.min(...nextTimes));
-            }
-        }
-        catch (error) {
-            console.error("[ConcaveDO] Alarm handler failed:", error?.message ?? error);
-            // Re-check for pending jobs so we don't lose scheduled work
-            try {
-                await this.reschedule();
-            }
-            catch (rescheduleError) {
-                console.error("[ConcaveDO] Reschedule after alarm failure also failed:", rescheduleError?.message);
-            }
-        }
+        return this.schedulerManager.handleAlarm();
     }
     /**
      * Reschedule alarms
      */
     async reschedule() {
-        const scheduledTime = await this.scheduler.getNextScheduledTime();
-        const cronTime = await this.cronExecutor.getNextScheduledTime();
-        const nextTimes = [scheduledTime, cronTime].filter((t) => t !== null);
-        if (nextTimes.length === 0) {
-            await this.doState.storage.deleteAlarm();
-        }
-        else {
-            await this.doState.storage.setAlarm(Math.min(...nextTimes));
-        }
+        return this.schedulerManager.reschedule();
     }
     /**
      * Sync cron specs
      */
     async syncCronSpecs(cronSpecs) {
-        await this.cronExecutor.syncCronSpecs(cronSpecs);
-        await this.reschedule();
+        return this.schedulerManager.syncCronSpecs(cronSpecs);
     }
     // =============================================================================
     // DocStore RPC Methods - Direct delegation to _docstore
     // =============================================================================
     async setupSchema(options) {
-        return this._docstore.setupSchema(options);
+        return this.docStoreRpc.setupSchema(options);
     }
     async write(documents, indexes, conflictStrategy) {
-        return this._docstore.write(documents, indexes, conflictStrategy);
+        return this.docStoreRpc.write(documents, indexes, conflictStrategy);
     }
     async get(id, readTimestamp) {
-        return this._docstore.get(id, readTimestamp);
+        return this.docStoreRpc.get(id, readTimestamp);
     }
     async scan(table, readTimestamp) {
-        return this._docstore.scan(table, readTimestamp);
+        return this.docStoreRpc.scan(table, readTimestamp);
     }
     async scanPaginated(table, cursor, limit, order, readTimestamp) {
-        return this._docstore.scanPaginated(table, cursor, limit, order, readTimestamp);
+        return this.docStoreRpc.scanPaginated(table, cursor, limit, order, readTimestamp);
     }
     /**
      * Generators return arrays over RPC (cannot stream async generators)
      */
     async index_scan(indexId, tabletId, readTimestamp, interval, order) {
-        const results = [];
-        for await (const item of this._docstore.index_scan(indexId, tabletId, readTimestamp, interval, order)) {
-            results.push(item);
-        }
-        return results;
+        return this.docStoreRpc.index_scan(indexId, tabletId, readTimestamp, interval, order);
     }
     /**
      * Generators return arrays over RPC (cannot stream async generators)
      */
     async load_documents(range, order) {
-        const results = [];
-        for await (const item of this._docstore.load_documents(range, order)) {
-            results.push(item);
-        }
-        return results;
+        return this.docStoreRpc.load_documents(range, order);
     }
     async count(table) {
-        return this._docstore.count(table);
+        return this.docStoreRpc.count(table);
     }
     async search(indexId, searchQuery, filters, options) {
-        return this._docstore.search(indexId, searchQuery, filters, options);
+        return this.docStoreRpc.search(indexId, searchQuery, filters, options);
     }
     async vectorSearch(indexId, vector, limit, filters) {
-        return this._docstore.vectorSearch(indexId, vector, limit, filters);
+        return this.docStoreRpc.vectorSearch(indexId, vector, limit, filters);
     }
     async getGlobal(key) {
-        return this._docstore.getGlobal(key);
+        return this.docStoreRpc.getGlobal(key);
     }
     async writeGlobal(key, value) {
-        return this._docstore.writeGlobal(key, value);
+        return this.docStoreRpc.writeGlobal(key, value);
     }
     async previous_revisions(queries) {
-        const result = await this._docstore.previous_revisions(queries);
-        return Array.from(result.entries());
+        return this.docStoreRpc.previous_revisions(queries);
     }
     async previous_revisions_of_documents(queries) {
-        const result = await this._docstore.previous_revisions_of_documents(queries);
-        return Array.from(result.entries());
+        return this.docStoreRpc.previous_revisions_of_documents(queries);
     }
     // =============================================================================
     // Blobstore RPC Methods - Prefixed to avoid collision with other methods
     // =============================================================================
     async blobstoreStore(buffer, options) {
-        if (!this._blobstore) {
+        if (!this.blobStoreRpc) {
             throw new Error("Blobstore not configured");
         }
-        return this._blobstore.store(buffer, options);
+        return this.blobStoreRpc.store(buffer, options);
     }
     async blobstoreGet(storageId) {
-        if (!this._blobstore) {
+        if (!this.blobStoreRpc) {
             throw new Error("Blobstore not configured");
         }
-        const result = await this._blobstore.get(storageId);
-        if (result === null)
-            return null;
-        if (result instanceof Blob)
-            return result.arrayBuffer();
-        return result;
+        return this.blobStoreRpc.get(storageId);
     }
     async blobstoreDelete(storageId) {
-        if (!this._blobstore) {
+        if (!this.blobStoreRpc) {
             throw new Error("Blobstore not configured");
         }
-        return this._blobstore.delete(storageId);
+        return this.blobStoreRpc.delete(storageId);
     }
     async blobstoreGetUrl(storageId) {
-        if (!this._blobstore) {
+        if (!this.blobStoreRpc) {
             throw new Error("Blobstore not configured");
         }
-        return this._blobstore.getUrl(storageId);
+        return this.blobStoreRpc.getUrl(storageId);
     }
     /**
      * Notify SyncDO of writes for subscription invalidation
      */
     async notifySyncDo(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);
-        }
+        return this.syncNotifier.notify(writtenRanges, writtenTables, commitTimestamp);
     }
     /**
      * Get CORS headers for responses

package/dist/durable-objects/docstore-rpc.d.ts

@@ -0,0 +1,46 @@
+import type { DocStore, DocumentLogEntry, DatabaseIndexUpdate, Interval, Order, IndexKeyBytes, LatestDocument, TimestampRange, InternalDocumentId, GlobalKey, DocumentPrevTsQuery, SearchIndexDefinition, VectorIndexDefinition } from "@concavejs/core/docstore";
+import type { JSONValue } from "convex/values";
+/**
+ * DocStore RPC surface for service-binding isolation.
+ * Provides async delegation methods that flatten generators into arrays
+ * for RPC transport (async generators cannot be streamed over service bindings).
+ */
+export declare class DocStoreRpc {
+    private readonly docstore;
+    constructor(docstore: DocStore);
+    setupSchema(options?: {
+        searchIndexes?: SearchIndexDefinition[];
+        vectorIndexes?: VectorIndexDefinition[];
+    }): Promise<void>;
+    write(documents: DocumentLogEntry[], indexes: Set<{
+        ts: bigint;
+        update: DatabaseIndexUpdate;
+    }>, conflictStrategy: "Error" | "Overwrite"): Promise<void>;
+    get(id: InternalDocumentId, readTimestamp?: bigint): Promise<LatestDocument | null>;
+    scan(table: string, readTimestamp?: bigint): Promise<LatestDocument[]>;
+    scanPaginated(table: string, cursor: string | null, limit: number, order: Order, readTimestamp?: bigint): Promise<{
+        documents: LatestDocument[];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    index_scan(indexId: string, tabletId: string, readTimestamp: bigint, interval: Interval, order: Order): Promise<[IndexKeyBytes, LatestDocument][]>;
+    load_documents(range: TimestampRange, order: Order): Promise<DocumentLogEntry[]>;
+    count(table: string): Promise<number>;
+    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;
+    }[]>;
+    getGlobal(key: GlobalKey): Promise<JSONValue | null>;
+    writeGlobal(key: GlobalKey, value: JSONValue): Promise<void>;
+    previous_revisions(queries: Set<{
+        id: InternalDocumentId;
+        ts: bigint;
+    }>): Promise<[string, DocumentLogEntry][]>;
+    previous_revisions_of_documents(queries: Set<DocumentPrevTsQuery>): Promise<[string, DocumentLogEntry][]>;
+}

package/dist/durable-objects/docstore-rpc.js

@@ -0,0 +1,63 @@
+/**
+ * DocStore RPC surface for service-binding isolation.
+ * Provides async delegation methods that flatten generators into arrays
+ * for RPC transport (async generators cannot be streamed over service bindings).
+ */
+export class DocStoreRpc {
+    docstore;
+    constructor(docstore) {
+        this.docstore = docstore;
+    }
+    async setupSchema(options) {
+        return this.docstore.setupSchema(options);
+    }
+    async write(documents, indexes, conflictStrategy) {
+        return this.docstore.write(documents, indexes, conflictStrategy);
+    }
+    async get(id, readTimestamp) {
+        return this.docstore.get(id, readTimestamp);
+    }
+    async scan(table, readTimestamp) {
+        return this.docstore.scan(table, readTimestamp);
+    }
+    async scanPaginated(table, cursor, limit, order, readTimestamp) {
+        return this.docstore.scanPaginated(table, cursor, limit, order, readTimestamp);
+    }
+    async index_scan(indexId, tabletId, readTimestamp, interval, order) {
+        const results = [];
+        for await (const item of this.docstore.index_scan(indexId, tabletId, readTimestamp, interval, order)) {
+            results.push(item);
+        }
+        return results;
+    }
+    async load_documents(range, order) {
+        const results = [];
+        for await (const item of this.docstore.load_documents(range, order)) {
+            results.push(item);
+        }
+        return results;
+    }
+    async count(table) {
+        return this.docstore.count(table);
+    }
+    async search(indexId, searchQuery, filters, options) {
+        return this.docstore.search(indexId, searchQuery, filters, options);
+    }
+    async vectorSearch(indexId, vector, limit, filters) {
+        return this.docstore.vectorSearch(indexId, vector, limit, filters);
+    }
+    async getGlobal(key) {
+        return this.docstore.getGlobal(key);
+    }
+    async writeGlobal(key, value) {
+        return this.docstore.writeGlobal(key, value);
+    }
+    async previous_revisions(queries) {
+        const result = await this.docstore.previous_revisions(queries);
+        return Array.from(result.entries());
+    }
+    async previous_revisions_of_documents(queries) {
+        const result = await this.docstore.previous_revisions_of_documents(queries);
+        return Array.from(result.entries());
+    }
+}

package/dist/durable-objects/scheduler-manager.d.ts

@@ -0,0 +1,19 @@
+import type { ScheduledFunctionExecutor, CronExecutor } from "@concavejs/core";
+/**
+ * Manages scheduled function and cron job execution.
+ * Extracted from ConcaveDOBase for single-responsibility.
+ */
+export declare class SchedulerManager {
+    private readonly scheduler;
+    private readonly cronExecutor;
+    private readonly doState;
+    constructor(scheduler: ScheduledFunctionExecutor, cronExecutor: CronExecutor, doState: {
+        storage: {
+            setAlarm(time: number): Promise<void>;
+            deleteAlarm(): Promise<void>;
+        };
+    });
+    handleAlarm(): Promise<void>;
+    reschedule(): Promise<void>;
+    syncCronSpecs(cronSpecs: Record<string, any>): Promise<void>;
+}

package/dist/durable-objects/scheduler-manager.js

@@ -0,0 +1,52 @@
+/**
+ * Manages scheduled function and cron job execution.
+ * Extracted from ConcaveDOBase for single-responsibility.
+ */
+export class SchedulerManager {
+    scheduler;
+    cronExecutor;
+    doState;
+    constructor(scheduler, cronExecutor, doState) {
+        this.scheduler = scheduler;
+        this.cronExecutor = cronExecutor;
+        this.doState = doState;
+    }
+    async handleAlarm() {
+        try {
+            const scheduledResult = await this.scheduler.runDueJobs();
+            const cronResult = await this.cronExecutor.runDueJobs();
+            const nextTimes = [scheduledResult.nextScheduledTime, cronResult.nextScheduledTime].filter((t) => t !== null);
+            if (nextTimes.length === 0) {
+                await this.doState.storage.deleteAlarm();
+            }
+            else {
+                await this.doState.storage.setAlarm(Math.min(...nextTimes));
+            }
+        }
+        catch (error) {
+            console.error("[ConcaveDO] Alarm handler failed:", error?.message ?? error);
+            try {
+                await this.reschedule();
+            }
+            catch (rescheduleError) {
+                console.error("[ConcaveDO] Reschedule after alarm failure also failed:", rescheduleError?.message);
+            }
+        }
+    }
+    async reschedule() {
+        const scheduledTime = await this.scheduler.getNextScheduledTime();
+        const cronTime = await this.cronExecutor.getNextScheduledTime();
+        const nextTimes = [scheduledTime, cronTime].filter((t) => t !== null);
+        if (nextTimes.length === 0) {
+            await this.doState.storage.deleteAlarm();
+        }
+        else {
+            const alarmTime = Math.min(...nextTimes);
+            await this.doState.storage.setAlarm(alarmTime);
+        }
+    }
+    async syncCronSpecs(cronSpecs) {
+        await this.cronExecutor.syncCronSpecs(cronSpecs);
+        await this.reschedule();
+    }
+}

package/dist/durable-objects/sync-notifier.d.ts

@@ -0,0 +1,16 @@
+import type { SerializedKeyRange } from "@concavejs/core/queryengine";
+/**
+ * Notifies the SyncDO of writes for subscription invalidation.
+ * Extracted from ConcaveDOBase for single-responsibility.
+ */
+export declare class SyncNotifier {
+    private readonly doState;
+    private readonly env;
+    constructor(doState: {
+        id: {
+            name: string | null;
+            toString(): string;
+        };
+    }, env: any);
+    notify(writtenRanges?: SerializedKeyRange[], writtenTables?: string[], commitTimestamp?: bigint): Promise<void>;
+}

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/http/http-api.d.ts

@@ -1,7 +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;
 }
-export declare function handleHttpApiRequest(request: Request, env: Env, ctx: ExecutionContext, instance?: string): Promise<Response>;
+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 {};