orez-sync-cf-host 0.5.19 → 0.5.21

package/dist/write-safeguards.js

@@ -0,0 +1,186 @@
+export class IngestBreakerError extends Error {
+    error;
+    windowRows;
+    budget;
+    retryAfterMs;
+    status = 429;
+    constructor(error, windowRows, budget, retryAfterMs) {
+        super(`${error}: ${windowRows}/${budget} rows; retry after ${retryAfterMs}ms`);
+        this.error = error;
+        this.windowRows = windowRows;
+        this.budget = budget;
+        this.retryAfterMs = retryAfterMs;
+        this.name = 'IngestBreakerError';
+    }
+}
+export class IngestCircuitBreaker {
+    #options;
+    #samples = [];
+    #billableRows = 0;
+    #logicalRows = 0;
+    #reason = null;
+    #retryAt = null;
+    #consecutiveTrips = 0;
+    constructor(options) {
+        for (const [name, value] of Object.entries(options)) {
+            if (name === 'now')
+                continue;
+            if (!Number.isSafeInteger(value) || Number(value) < 1)
+                throw new TypeError(`${name} must be a positive safe integer`);
+        }
+        this.#options = options;
+    }
+    #prune(now) {
+        const cutoff = now - this.#options.windowMs;
+        let remove = 0;
+        while (remove < this.#samples.length && this.#samples[remove].at <= cutoff) {
+            this.#billableRows -= this.#samples[remove].billableRows;
+            this.#logicalRows -= this.#samples[remove].logicalRows;
+            remove++;
+        }
+        if (remove > 0)
+            this.#samples.splice(0, remove);
+    }
+    status() {
+        const now = this.#options.now();
+        this.#prune(now);
+        const retryAfterMs = Math.max(0, (this.#retryAt ?? now) - now);
+        return {
+            windowRows: this.#billableRows,
+            billableRows: this.#billableRows,
+            logicalRows: this.#logicalRows,
+            budget: this.#options.budgetRows,
+            windowMs: this.#options.windowMs,
+            tripped: this.#reason !== null && retryAfterMs > 0,
+            reason: this.#reason,
+            retryAt: this.#retryAt,
+            retryAfterMs,
+            consecutiveTrips: this.#consecutiveTrips,
+        };
+    }
+    assertReady() {
+        const status = this.status();
+        if (status.tripped && status.reason) {
+            throw new IngestBreakerError(status.reason, status.windowRows, status.budget, status.retryAfterMs);
+        }
+    }
+    record(rows) {
+        this.recordLogical(rows);
+        this.recordBillable(rows);
+    }
+    #sample(now) {
+        this.#prune(now);
+        const last = this.#samples[this.#samples.length - 1];
+        if (last?.at === now)
+            return last;
+        const sample = { at: now, billableRows: 0, logicalRows: 0 };
+        this.#samples.push(sample);
+        return sample;
+    }
+    recordLogical(rows) {
+        if (!Number.isSafeInteger(rows) || rows <= 0)
+            return;
+        const sample = this.#sample(this.#options.now());
+        sample.logicalRows += rows;
+        this.#logicalRows += rows;
+    }
+    recordBillable(rows) {
+        this.assertReady();
+        if (!Number.isSafeInteger(rows) || rows <= 0)
+            return;
+        const now = this.#options.now();
+        const sample = this.#sample(now);
+        sample.billableRows += rows;
+        this.#billableRows += rows;
+        if (this.#billableRows > this.#options.budgetRows)
+            this.trip('ingestBudgetExceeded');
+    }
+    trip(reason) {
+        const now = this.#options.now();
+        this.#consecutiveTrips++;
+        const delay = Math.min(this.#options.maxBackoffMs, this.#options.initialBackoffMs * 2 ** (this.#consecutiveTrips - 1));
+        this.#reason = reason;
+        this.#retryAt = now + delay;
+        throw new IngestBreakerError(reason, this.#billableRows, this.#options.budgetRows, delay);
+    }
+    recovered() {
+        this.#reason = null;
+        this.#retryAt = null;
+        this.#consecutiveTrips = 0;
+    }
+    restore(reason, retryAt, consecutiveTrips) {
+        if (!Number.isFinite(retryAt) || retryAt <= 0)
+            return;
+        this.#reason = reason;
+        this.#retryAt = retryAt;
+        this.#consecutiveTrips = Math.max(1, Math.floor(consecutiveTrips) || 1);
+    }
+    reopen() {
+        this.#samples = [];
+        this.#billableRows = 0;
+        this.#logicalRows = 0;
+        this.recovered();
+    }
+}
+export function trackBillableCursorRows(cursor, record) {
+    if (!cursor || typeof cursor !== 'object')
+        return cursor;
+    let accountedRows = 0;
+    const account = () => {
+        const current = Number(cursor.rowsWritten ?? 0);
+        if (!Number.isSafeInteger(current) || current <= accountedRows)
+            return;
+        const delta = current - accountedRows;
+        accountedRows = current;
+        record(delta);
+    };
+    const wrapIterator = (iterator) => {
+        const next = iterator.next.bind(iterator);
+        return {
+            next(...args) {
+                try {
+                    return next(...args);
+                }
+                finally {
+                    account();
+                }
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+    };
+    let proxy;
+    proxy = new Proxy(cursor, {
+        get(target, property) {
+            const value = Reflect.get(target, property, target);
+            if (property === Symbol.iterator)
+                return () => proxy;
+            if ((property === 'next' || property === 'one' || property === 'toArray') &&
+                typeof value === 'function') {
+                return (...args) => {
+                    try {
+                        return Reflect.apply(value, target, args);
+                    }
+                    finally {
+                        account();
+                    }
+                };
+            }
+            if (property === 'raw' && typeof value === 'function') {
+                return (...args) => wrapIterator(Reflect.apply(value, target, args));
+            }
+            return typeof value === 'function' ? value.bind(target) : value;
+        },
+    });
+    account();
+    return proxy;
+}
+export function retryDelayMs(attempt, initialBackoffMs, maxBackoffMs) {
+    return Math.min(maxBackoffMs, initialBackoffMs * 2 ** Math.max(0, attempt - 1));
+}
+export function shouldRetryDelegatedPush(responseStatus, attempt, maxAttempts) {
+    if (attempt >= maxAttempts)
+        return false;
+    return responseStatus === null || responseStatus === 429 || responseStatus >= 500;
+}

package/package.json

@@ -1,31 +1,62 @@
 {
   "name": "orez-sync-cf-host",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
-    "./post-commit": "./src/post-commit.ts",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./post-commit": {
+      "types": "./dist/post-commit.d.ts",
+      "import": "./dist/post-commit.js"
+    },
     "./mutation-error": {
-      "types": "./src/mutation-error.ts",
-      "import": "./src/mutation-error.ts"
+      "types": "./dist/mutation-error.d.ts",
+      "import": "./dist/mutation-error.js"
+    },
+    "./node-wasm-loader": {
+      "types": "./dist/node-wasm-loader.d.ts",
+      "import": "./dist/node-wasm-loader.js"
+    },
+    "./bun-wasm-loader": {
+      "types": "./dist/bun-wasm-loader.d.ts",
+      "import": "./dist/bun-wasm-loader.js"
+    },
+    "./query-compiler": {
+      "types": "./dist/query-compiler.d.ts",
+      "import": "./dist/query-compiler.js"
     },
-    "./bun-wasm-loader": "./src/bun-wasm-loader.ts",
-    "./query-compiler": "./src/query-compiler.ts",
-    "./transaction-query": "./src/transaction-query.ts"
+    "./transaction-query": {
+      "types": "./dist/transaction-query.d.ts",
+      "import": "./dist/transaction-query.js"
+    },
+    "./vite-wasm-loader": {
+      "types": "./dist/vite-wasm-loader.d.ts",
+      "import": "./dist/vite-wasm-loader.js"
+    },
+    "./wasm-module.wasm": {
+      "types": "./dist/generated/sync_wasm_bg.wasm.d.ts",
+      "import": "./dist/generated/sync_wasm_bg.wasm"
+    }
   },
   "scripts": {
     "build:wasm": "wasm-pack build ../../crates/sync-wasm --target web --release --out-dir ../../packages/sync-cf-host/src/generated --out-name sync_wasm && rm -f src/generated/.gitignore && bun scripts/write-wasm-module-type.ts",
     "build:wasm:platform": "wasm-pack build ../../crates/sync-wasm --target web --release --out-dir ../../packages/sync-cf-host/src/generated --out-name sync_wasm -- --features platform-probes && rm -f src/generated/.gitignore && bun scripts/write-wasm-module-type.ts",
-    "bundle": "bun run build:wasm && wrangler deploy --dry-run --outdir dist",
-    "measure": "bun run build:wasm && bun measure.mjs",
-    "test": "bun run test:config && bun run test:query-compiler && bun run test:platform && bun run test:integration && bun run test:ingest && bun run test:restart",
-    "test:config": "bun test config.test.mjs write-safeguards.test.mjs mutation-error.test.mjs post-commit.test.mjs",
-    "test:integration": "bun run build:wasm && bun integration-test.mjs",
-    "test:ingest": "bun run build:wasm && bun ingest-test.mjs",
-    "test:query-compiler": "bun run build:wasm && bun test --preload orez-sync-cf-host/bun-wasm-loader query-compiler.test.mjs",
-    "test:restart": "bun restart-test.mjs",
-    "test:platform": "bun run build:wasm:platform && bun platform-test.mjs",
-    "typecheck": "bun run build:wasm:platform && tsc --noEmit"
+    "build:runtime": "rm -rf dist && mkdir -p dist && cp -R src/generated dist/generated && tsc -p tsconfig.build.json",
+    "build:dist": "bun run build:wasm && bun run build:runtime",
+    "build:dist:platform": "bun run build:wasm:platform && bun run build:runtime",
+    "bundle": "bun run build:dist && wrangler deploy --dry-run --outdir .wrangler/bundle",
+    "measure": "bun run build:dist && bun measure.mjs",
+    "test": "bun run test:config && bun run test:query-compiler && bun run test:package && bun run test:platform && bun run test:integration && bun run test:ingest && bun run test:restart",
+    "test:config": "bun test config.test.mjs write-safeguards.test.mjs mutation-error.test.mjs post-commit.test.mjs transaction-query.test.mjs",
+    "test:integration": "bun run build:dist && bun integration-test.mjs",
+    "test:ingest": "bun run build:dist && bun ingest-test.mjs",
+    "test:package": "bun run build:dist && node package-runtime-test.mjs",
+    "test:query-compiler": "bun run build:dist && bun test --preload orez-sync-cf-host/bun-wasm-loader query-compiler.test.mjs && node vite-ssr-query-compiler-test.mjs",
+    "test:restart": "bun run build:dist && bun restart-test.mjs",
+    "test:platform": "bun run build:dist:platform && bun platform-test.mjs",
+    "typecheck": "bun run build:dist:platform && tsc --noEmit"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "4.20260617.1",
@@ -35,7 +66,16 @@
     "workerd": "1.20260617.1",
     "wrangler": "4.103.0"
   },
+  "peerDependencies": {
+    "vite": ">=5"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
   "files": [
-    "src"
+    "dist",
+    "README.md"
   ]
 }

package/src/bun-wasm-loader.ts

@@ -1,16 +0,0 @@
-import { Buffer } from 'node:buffer'
-
-import { file, plugin } from 'bun'
-
-plugin({
-  name: 'orez-sync-cf-host-wasm',
-  setup(build) {
-    build.onLoad({ filter: /sync_wasm_bg\.wasm$/ }, async ({ path }) => {
-      const bytes = Buffer.from(await file(path).arrayBuffer()).toString('base64')
-      return {
-        contents: `export default new WebAssembly.Module(Uint8Array.fromBase64('${bytes}'))`,
-        loader: 'js',
-      }
-    })
-  },
-})

package/src/config.ts

@@ -1,102 +0,0 @@
-import type { PullCaps, SyncHostConfig, SyncHostEnv } from './types.js'
-
-export function validatePullCaps(caps: PullCaps): PullCaps {
-  if (!Number.isSafeInteger(caps.maxChangeRows) || caps.maxChangeRows < 1) {
-    throw new TypeError('caps.maxChangeRows must be a positive safe integer')
-  }
-  return caps
-}
-
-export function validateSyncHostConfig<Env extends SyncHostEnv>(
-  config: SyncHostConfig<Env>
-): SyncHostConfig<Env> {
-  if (typeof config.authorizeWake !== 'function') {
-    throw new TypeError('sync host config authorizeWake is required')
-  }
-  if (typeof config.authorizeNotify !== 'function') {
-    throw new TypeError('sync host config authorizeNotify is required')
-  }
-  const hasMutators = config.mutators !== undefined
-  const hasDelegate = config.mutateUrl !== undefined
-  if (hasMutators === hasDelegate) {
-    throw new TypeError('sync host config requires exactly one of mutators or mutateUrl')
-  }
-  if (hasDelegate && !config.upstream) {
-    throw new TypeError('sync host config mutateUrl requires upstream')
-  }
-  if (config.mutateBinding !== undefined && !hasDelegate) {
-    throw new TypeError('sync host config mutateBinding requires mutateUrl')
-  }
-  if (config.mutateOrigin !== undefined && !hasDelegate) {
-    throw new TypeError('sync host config mutateOrigin requires mutateUrl')
-  }
-  if (config.delegatedPushRetry !== undefined && !hasDelegate) {
-    throw new TypeError('sync host config delegatedPushRetry requires mutateUrl')
-  }
-  if (config.mutateBinding !== undefined && !config.mutateBinding) {
-    throw new TypeError('sync host config mutateBinding must not be empty')
-  }
-  if (hasMutators && config.upstream) {
-    throw new TypeError(
-      'sync host config cannot combine local mutators with upstream ingest'
-    )
-  }
-  if (config.mutateUrl && !config.mutateUrl.startsWith('/')) {
-    throw new TypeError('mutateUrl must be an absolute path')
-  }
-  if (config.mutateOrigin !== undefined) {
-    let origin: URL
-    try {
-      origin = new URL(config.mutateOrigin)
-    } catch {
-      throw new TypeError('mutateOrigin must be an absolute http(s) origin')
-    }
-    if (
-      (origin.protocol !== 'http:' && origin.protocol !== 'https:') ||
-      origin.origin !== config.mutateOrigin
-    ) {
-      throw new TypeError('mutateOrigin must be an absolute http(s) origin')
-    }
-  }
-  if (config.upstream) {
-    if (!config.upstream.binding) throw new TypeError('upstream.binding is required')
-    const limit = config.upstream.changeLimit ?? 1_000
-    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 10_000) {
-      throw new TypeError('upstream.changeLimit must be a safe integer in 1..10000')
-    }
-    const interval = config.upstream.intervalMs ?? 15_000
-    if (!Number.isSafeInteger(interval) || interval < 1_000) {
-      throw new TypeError('upstream.intervalMs must be a safe integer >= 1000')
-    }
-    for (const [name, value] of Object.entries({
-      ingestBudgetRows: config.upstream.ingestBudgetRows ?? 150_000,
-      ingestBudgetWindowMs: config.upstream.ingestBudgetWindowMs ?? 300_000,
-      ingestBackoffMs: config.upstream.ingestBackoffMs ?? 1_000,
-      ingestMaxBackoffMs: config.upstream.ingestMaxBackoffMs ?? 60_000,
-    })) {
-      if (!Number.isSafeInteger(value) || value < 1)
-        throw new TypeError(`upstream.${name} must be a positive safe integer`)
-    }
-  }
-  if (config.delegatedPushRetry) {
-    for (const [name, value] of Object.entries({
-      maxAttempts: config.delegatedPushRetry.maxAttempts ?? 3,
-      initialBackoffMs: config.delegatedPushRetry.initialBackoffMs ?? 100,
-      maxBackoffMs: config.delegatedPushRetry.maxBackoffMs ?? 1_000,
-      timeoutMs: config.delegatedPushRetry.timeoutMs ?? 5_000,
-    })) {
-      if (!Number.isSafeInteger(value) || value < 1)
-        throw new TypeError(`delegatedPushRetry.${name} must be a positive safe integer`)
-    }
-  }
-  if (config.transactionQueryBudget) {
-    for (const [name, value] of Object.entries(config.transactionQueryBudget)) {
-      if (!Number.isSafeInteger(value) || Number(value) < 1) {
-        throw new TypeError(
-          `transactionQueryBudget.${name} must be a positive safe integer`
-        )
-      }
-    }
-  }
-  return config
-}