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

package/dist/http/http-api.js

@@ -60,7 +60,7 @@ function base64ToArrayBuffer(base64) {
  * Create a storage adapter that routes through the ConcaveDO's storage syscall handler.
  * This ensures storage operations are properly isolated within the DO.
  */
-function createStorageAdapter(concaveDO, _instance) {
+function createStorageAdapter(concaveDO) {
     return {
         store: async (blob) => {
             const buffer = await blob.arrayBuffer();
@@ -106,26 +106,66 @@ function createStorageAdapter(concaveDO, _instance) {
         },
     };
 }
-function createNotifyWrites(env, instance, ctx) {
+function createNotifyWrites(env, syncDoNames, ctx, logicalInstance, projectId, dispatchSyncWrites) {
     return async (writtenRanges, writtenTables, commitTimestamp) => {
         if (!writtenRanges?.length && !writtenTables?.length) {
             return;
         }
-        const syncDoId = env.SYNC_DO.idFromName(instance);
-        const syncDo = env.SYNC_DO.get(syncDoId);
         const payload = {
+            logicalInstance,
+            projectId,
+            syncTargets: syncDoNames,
             writtenRanges,
             writtenTables: writtenTables ?? writtenTablesFromRanges(writtenRanges),
             commitTimestamp: commitTimestamp ? commitTimestamp.toString() : undefined,
         };
-        ctx.waitUntil(syncDo.fetch("http://do/notify", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(payload),
-        }));
+        if (dispatchSyncWrites) {
+            ctx.waitUntil(dispatchSyncWrites(payload).catch((error) => {
+                console.warn("[notifyWrites] Custom sync write dispatch failed", error);
+            }));
+            return;
+        }
+        if (isQueueLike(env.SYNC_NOTIFY_QUEUE)) {
+            ctx.waitUntil(env.SYNC_NOTIFY_QUEUE.send(payload).catch((error) => {
+                console.warn("[notifyWrites] Queue-based sync write dispatch failed", error);
+            }));
+            return;
+        }
+        const doPayload = {
+            writtenRanges,
+            writtenTables: writtenTables ?? writtenTablesFromRanges(writtenRanges),
+            commitTimestamp: commitTimestamp ? commitTimestamp.toString() : undefined,
+        };
+        for (const syncDoName of syncDoNames) {
+            const syncDoId = env.SYNC_DO.idFromName(syncDoName);
+            const syncDo = env.SYNC_DO.get(syncDoId);
+            const headers = {
+                "Content-Type": "application/json",
+                "X-Concave-Instance": logicalInstance,
+            };
+            if (projectId) {
+                headers["X-Concave-Project-Id"] = projectId;
+            }
+            ctx.waitUntil(syncDo
+                .fetch("http://do/notify", {
+                method: "POST",
+                headers,
+                body: JSON.stringify(doPayload),
+            })
+                .catch((error) => {
+                console.warn("[notifyWrites] Direct SyncDO notify failed", error);
+            }));
+        }
     };
 }
-export async function handleHttpApiRequest(request, env, ctx, instance = "singleton") {
+function isQueueLike(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.send === "function";
+}
+export async function handleHttpApiRequest(request, env, ctx, instance = "singleton", routingTargets) {
     const corsHeaders = computeCorsHeaders(request);
     const apply = (response) => applyCors(response, corsHeaders);
     const url = new URL(request.url);
@@ -133,14 +173,19 @@ export async function handleHttpApiRequest(request, env, ctx, instance = "single
     if (pathParts[0] !== "api") {
         return apply(new Response("Not found", { status: 404 }));
     }
-    console.log(`[handleHttpApiRequest] instance=${instance}`);
-    const concaveId = env.CONCAVE_DO.idFromName(instance);
-    const concave = env.CONCAVE_DO.get(concaveId);
+    const logicalInstance = instance;
+    const concaveDoName = normalizeDoName(routingTargets?.concaveDoName ?? routingTargets?.concaveTargetName, logicalInstance);
+    const syncDoNames = normalizeSyncDoNames(routingTargets?.syncDoNames ?? routingTargets?.syncTargetNames, logicalInstance);
+    const projectId = request.headers.get("X-Concave-Project-Id") ?? undefined;
+    console.log(`[handleHttpApiRequest] logicalInstance=${logicalInstance} concaveDo=${concaveDoName} syncTargets=${syncDoNames.join(",")}`);
+    const concaveId = env.CONCAVE_DO.idFromName(concaveDoName);
+    const concaveRaw = env.CONCAVE_DO.get(concaveId);
+    const concave = wrapConcaveStub(concaveRaw, logicalInstance, projectId);
     const executor = new ConcaveStubExecutor(concave);
     const adapter = createClientAdapter(executor);
-    const notifyWrites = createNotifyWrites(env, instance, ctx);
+    const notifyWrites = createNotifyWrites(env, syncDoNames, ctx, logicalInstance, projectId, routingTargets?.dispatchSyncWrites);
     // Route storage operations through the DO's storage syscall handler
-    const storageAdapter = createStorageAdapter(concave, instance);
+    const storageAdapter = createStorageAdapter(concave);
     const authHeader = request.headers.get("Authorization");
     const headerToken = authHeader?.replace(/^Bearer\s+/i, "").trim() || undefined;
     let headerIdentity;
@@ -294,3 +339,38 @@ export async function handleHttpApiRequest(request, env, ctx, instance = "single
     }
     return apply(new Response("Not found", { status: 404 }));
 }
+function wrapConcaveStub(stub, logicalInstance, projectId) {
+    return {
+        fetch: async (input, init) => {
+            const headers = new Headers(init?.headers);
+            headers.set("X-Concave-Instance", logicalInstance);
+            if (projectId) {
+                headers.set("X-Concave-Project-Id", projectId);
+            }
+            return stub.fetch(input, {
+                ...init,
+                headers,
+            });
+        },
+    };
+}
+function normalizeDoName(target, fallback) {
+    const trimmed = target?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : fallback;
+}
+function normalizeSyncDoNames(targets, fallback) {
+    if (targets === undefined) {
+        return [fallback];
+    }
+    if (targets.length === 0) {
+        return [];
+    }
+    const deduped = new Set();
+    for (const target of targets) {
+        const trimmed = target.trim();
+        if (trimmed.length > 0) {
+            deduped.add(trimmed);
+        }
+    }
+    return Array.from(deduped);
+}

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 export * from "@concavejs/core";
 export type { ConcaveEnv, ConcaveStorageEnv, ConcaveD1Env } from "./env";
 export { UdfExecutorRpc } from "./worker/udf-worker";
-export { createConcaveWorker, resolveNamespaceBinding, createScopedNamespace, type ConcaveWorkerOptions, type ConcaveWorkerBindings, type ConcaveWorker, } from "./worker/create-concave-worker";
+export { createConcaveWorker, resolveNamespaceBinding, createScopedNamespace, type ConcaveWorkerOptions, type ConcaveWorkerBindings, type ConcaveWorker, type ConcaveWorkerRouteContext, type ConcaveWorkerRouteTargets, } from "./worker/create-concave-worker";
 export { DEFAULT_INSTANCE_KEY, DEFAULT_INSTANCE_VALUE, DEFAULT_INSTANCE_COOKIE_PATH, resolveInstanceFromRequest, maybeAttachInstanceCookie, readCookieValue, buildInstanceCookie, type InstanceResolution, type InstanceResolutionOptions, type InstanceCookieOptions, } from "./routing/instance";
+export { createCfSyncTopologyRuntime, buildPooledInstanceName as buildSyncPooledInstanceName, parseNodeIds as parseSyncNodeIds, parseNodeIdsByRegion as parseSyncNodeIdsByRegion, normalizeTargetList as normalizeSyncTargetList, type CfSyncTopologyConfig, type BuildShardMapFromReportsOptions as SyncBuildShardMapFromReportsOptions, type ResolveSyncFanoutDoNamesAsyncOptions, type CreateCfSyncTopologyRuntimeOptions, type CfSyncTopologyRuntime, } from "./routing/sync-topology";
 export { UdfExecInline } from "./udf/executor/inline-executor";
 export { UdfExecIsolated } from "./udf/executor/isolated-executor";
 export { ConcaveDOBase, type ConcaveDOConfig, type ConcaveDOAdapterContext, type ConcaveDOExecutorContext, } from "./durable-objects/concave-do-base";

package/dist/index.js

@@ -5,6 +5,7 @@ export { UdfExecutorRpc } from "./worker/udf-worker";
 export { createConcaveWorker, resolveNamespaceBinding, createScopedNamespace, } from "./worker/create-concave-worker";
 // Export instance routing helpers
 export { DEFAULT_INSTANCE_KEY, DEFAULT_INSTANCE_VALUE, DEFAULT_INSTANCE_COOKIE_PATH, resolveInstanceFromRequest, maybeAttachInstanceCookie, readCookieValue, buildInstanceCookie, } from "./routing/instance";
+export { createCfSyncTopologyRuntime, buildPooledInstanceName as buildSyncPooledInstanceName, parseNodeIds as parseSyncNodeIds, parseNodeIdsByRegion as parseSyncNodeIdsByRegion, normalizeTargetList as normalizeSyncTargetList, } from "./routing/sync-topology";
 // Export UDF executors
 export { UdfExecInline } from "./udf/executor/inline-executor";
 export { UdfExecIsolated } from "./udf/executor/isolated-executor";

package/dist/routing/sync-topology.d.ts

@@ -0,0 +1,40 @@
+import type { ConcaveWorkerRouteContext, ConcaveWorkerRouteTargets } from "../worker/create-concave-worker";
+import { type BuildShardMapFromReportsOptions as SharedBuildShardMapFromReportsOptions, type SyncShardMap, type SyncTopologyConfig } from "@concavejs/runtime-base";
+export interface CfSyncTopologyConfig extends SyncTopologyConfig {
+    syncAffinityKey: string;
+    regionKey: string;
+    regionByColo: Record<string, string>;
+    useColoAsRegion: boolean;
+}
+export interface BuildShardMapFromReportsOptions extends Omit<SharedBuildShardMapFromReportsOptions, "config"> {
+    logicalInstance: string;
+    env: Record<string, unknown>;
+}
+export interface ResolveSyncFanoutDoNamesAsyncOptions {
+    request?: Request;
+    projectId?: string;
+}
+export interface CreateCfSyncTopologyRuntimeOptions {
+    logPrefix?: string;
+    projectHeaderName?: string;
+    coordinatorBindingName?: string;
+    shardMapKvBindingName?: string;
+    resolveProjectId?: (request: Request, env: Record<string, unknown>) => string | undefined;
+    buildCoordinatorDoName: (logicalInstance: string, projectId?: string) => string;
+    buildShardMapKvKey: (logicalInstance: string, projectId?: string) => string;
+    buildShardMapCacheKey?: (logicalInstance: string, projectId?: string) => string;
+}
+export interface CfSyncTopologyRuntime {
+    resolveRouteTargets(context: ConcaveWorkerRouteContext): Promise<ConcaveWorkerRouteTargets>;
+    resolveSyncFanoutDoNames(logicalInstance: string, env: Record<string, unknown>): string[];
+    resolveSyncFanoutDoNamesAsync(logicalInstance: string, env: Record<string, unknown>, options?: ResolveSyncFanoutDoNamesAsyncOptions): Promise<string[]>;
+    resolveStaticSyncShardMap(logicalInstance: string, env: Record<string, unknown>, nowMs?: number): SyncShardMap;
+    buildShardMapFromReports(options: BuildShardMapFromReportsOptions): SyncShardMap;
+    resolveTopologyConfig(env: Record<string, unknown>): CfSyncTopologyConfig;
+    resolveRequestRegion(request: Request, env: Record<string, unknown>): string;
+}
+export declare function createCfSyncTopologyRuntime(options: CreateCfSyncTopologyRuntimeOptions): CfSyncTopologyRuntime;
+export declare function buildPooledInstanceName(logicalInstance: string, poolKind: "sync" | "udf", nodeId: string): string;
+export declare function parseNodeIds(raw: unknown): string[];
+export declare function parseNodeIdsByRegion(raw: unknown): Record<string, string[]>;
+export declare function normalizeTargetList(targets: string[] | undefined): string[];