orez 0.2.24 → 0.2.26

package/dist/cf-do/worker.js

@@ -0,0 +1,813 @@
+// @ts-nocheck — cloudflare:workers types not available in orez
+import { DurableObject } from 'cloudflare:workers';
+import { trackedChangeRow } from '../do-sql-tracking.js';
+import { DurableWatermarkState } from './watermark.js';
+const SCHEMA_VERSION = 1;
+const SQL_ERROR_SNIPPET_RADIUS = 1600;
+const SQL_ERROR_FALLBACK_LIMIT = 4000;
+function quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+function sqliteErrorOffset(message) {
+    const marker = 'offset ';
+    const start = message.indexOf(marker);
+    if (start < 0)
+        return null;
+    let index = start + marker.length;
+    let digits = '';
+    while (index < message.length) {
+        const code = message.charCodeAt(index);
+        if (code < 48 || code > 57)
+            break;
+        digits += message[index];
+        index++;
+    }
+    if (!digits)
+        return null;
+    const offset = Number(digits);
+    return Number.isFinite(offset) ? offset : null;
+}
+function sqlErrorSnippet(sql, message) {
+    const offset = sqliteErrorOffset(message);
+    if (offset !== null) {
+        const start = Math.max(0, offset - SQL_ERROR_SNIPPET_RADIUS);
+        const end = Math.min(sql.length, offset + SQL_ERROR_SNIPPET_RADIUS);
+        return `${start > 0 ? '...' : ''}${sql.slice(start, end)}${end < sql.length ? '...' : ''}`;
+    }
+    if (sql.length <= SQL_ERROR_FALLBACK_LIMIT)
+        return sql;
+    return `${sql.slice(0, SQL_ERROR_FALLBACK_LIMIT)}...`;
+}
+export class ZeroDO extends DurableObject {
+    sql;
+    watermarks;
+    schemaTables = new Set();
+    tableSchemas = new Map();
+    constructor(ctx, env) {
+        super(ctx, env);
+        this.sql = ctx.storage.sql;
+        this.watermarks = new DurableWatermarkState(this.sql);
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        if (request.method === 'OPTIONS') {
+            return new Response(null, {
+                headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                    'Access-Control-Allow-Headers': '*',
+                },
+            });
+        }
+        if (url.pathname.startsWith('/sync/v') && url.pathname.endsWith('/connect'))
+            return this.handleSyncConnect(request, url);
+        if ((url.pathname === '/zero/push' || url.pathname === '/api/zero/push') &&
+            request.method === 'POST')
+            return this.handleHttpPush(request);
+        if (url.pathname === '/exec' && request.method === 'POST')
+            return this.handleExec(request);
+        if (url.pathname === '/batch' && request.method === 'POST')
+            return this.handleBatch(request);
+        if (url.pathname === '/changes' &&
+            (request.method === 'GET' || request.method === 'POST'))
+            return this.handleChanges(request, url);
+        if (url.pathname === '/notify' && request.method === 'POST')
+            return Response.json({ ok: true, cookie: this.cookie() });
+        return new Response('not found', { status: 404 });
+    }
+    // ── Zero sync protocol ──────────────────────────────────────────────────
+    handleSyncConnect(request, url) {
+        if (request.headers.get('upgrade')?.toLowerCase() !== 'websocket') {
+            return new Response('expected websocket upgrade', { status: 426 });
+        }
+        const pair = new WebSocketPair();
+        const client = pair[0];
+        const server = pair[1];
+        const clientID = url.searchParams.get('clientID') || 'anon';
+        const clientGroupID = url.searchParams.get('clientGroupID') || 'default';
+        const userID = url.searchParams.get('userID') || 'anon';
+        const wsid = url.searchParams.get('wsid') || crypto.randomUUID();
+        const baseCookie = url.searchParams.get('baseCookie');
+        this.ctx.acceptWebSocket(server);
+        server.serializeAttachment({
+            clientID,
+            clientGroupID,
+            userID,
+            cookie: baseCookie ? baseCookie : null,
+            initialized: false,
+            desiredTableNames: [],
+            desiredQueries: [],
+        });
+        this.sendJSON(server, ['connected', { wsid, timestamp: Date.now() }]);
+        const secProtocol = request.headers.get('sec-websocket-protocol');
+        if (secProtocol) {
+            const initData = decodeInitConnection(secProtocol);
+            if (initData) {
+                const clientSchema = initData[1]?.clientSchema;
+                const patch = (initData[1]?.desiredQueriesPatch || []);
+                this.applyDesiredQueries(server, patch, clientSchema);
+            }
+        }
+        return new Response(null, {
+            status: 101,
+            headers: secProtocol ? { 'Sec-WebSocket-Protocol': secProtocol } : undefined,
+            webSocket: client,
+        });
+    }
+    async webSocketMessage(socket, messageData) {
+        this.watermarks.ensureTables();
+        const ws = socket;
+        const attachment = this.readSocketAttachment(ws);
+        if (!attachment)
+            return;
+        const message = this.parseMessage(messageData);
+        if (!message)
+            return;
+        const body = message[1] || {};
+        switch (message[0]) {
+            case 'initConnection':
+            case 'changeDesiredQueries':
+                this.applyDesiredQueries(ws, (body.desiredQueriesPatch || []), body.clientSchema);
+                break;
+            case 'push':
+                this.handlePush(ws, attachment, message[1]);
+                break;
+            case 'pull':
+                this.handlePull(ws, message[1]);
+                break;
+            case 'ping':
+                this.sendJSON(ws, ['pong', {}]);
+                break;
+        }
+    }
+    webSocketClose(_socket, _code, _reason, _wasClean) { }
+    applyDesiredQueries(socket, patch, clientSchema) {
+        const attachment = this.readSocketAttachment(socket);
+        if (!attachment)
+            return;
+        if (clientSchema)
+            this.ensureSchemaTables(clientSchema);
+        let nextAttachment = this.applyDesiredQueryPatch(attachment, patch);
+        socket.serializeAttachment(nextAttachment);
+        if (!nextAttachment.initialized) {
+            nextAttachment = this.sendSyncPoke(socket, { ...nextAttachment, initialized: true }, { lastMutationIDChanges: {}, rowsPatch: [] });
+        }
+        if (patch.length === 0)
+            return;
+        const rowsPatch = [
+            { op: 'clear' },
+            ...this.rowsPatchForTables(nextAttachment.desiredTableNames),
+        ];
+        this.sendSyncPoke(socket, nextAttachment, {
+            gotQueriesPatch: this.gotQueriesPatch(patch),
+            rowsPatch,
+        });
+    }
+    applyDesiredQueryPatch(attachment, patch) {
+        const desiredQueries = new Map();
+        for (const query of attachment.desiredQueries || [])
+            desiredQueries.set(query.hash, query.tableNames);
+        for (const op of patch) {
+            if (op.op === 'clear') {
+                desiredQueries.clear();
+            }
+            else if (op.op === 'put' && op.hash) {
+                desiredQueries.set(op.hash, this.resolveTablesFromPatch([op]));
+            }
+            else if (op.op === 'del' && op.hash) {
+                desiredQueries.delete(op.hash);
+            }
+        }
+        const queries = [...desiredQueries.entries()].map(([hash, tableNames]) => ({
+            hash,
+            tableNames,
+        }));
+        return {
+            ...attachment,
+            desiredQueries: queries,
+            desiredTableNames: [...new Set(queries.flatMap((query) => query.tableNames))],
+        };
+    }
+    gotQueriesPatch(patch) {
+        const got = [];
+        for (const op of patch) {
+            if (op.op === 'clear')
+                got.push({ op: 'clear' });
+            else if (op.hash)
+                got.push({ op: op.op, hash: op.hash });
+        }
+        return got;
+    }
+    rowsPatchForTables(tableNames) {
+        const rowsPatch = [];
+        for (const tn of tableNames) {
+            if (!this.tableExists(tn))
+                continue;
+            for (const row of this.readAllRows(tn))
+                rowsPatch.push({ op: 'put', tableName: tn, value: row });
+        }
+        return rowsPatch;
+    }
+    resolveTablesFromPatch(patch) {
+        const tables = [];
+        for (const op of patch) {
+            const tableFromName = this.tableNameFromOperationName(op.name);
+            if (tableFromName)
+                tables.push(tableFromName);
+            if (op.ast)
+                this.extractTableFromAST(op.ast, tables);
+        }
+        return tables;
+    }
+    extractTableFromAST(ast, tables) {
+        if (ast?.table)
+            tables.push(ast.table);
+        if (ast?.related)
+            for (const rel of ast.related) {
+                if (rel?.subquery?.table)
+                    tables.push(rel.subquery.table);
+                if (rel?.subquery?.related)
+                    this.extractTableFromAST(rel.subquery, tables);
+            }
+    }
+    handlePush(socket, attachment, body) {
+        const mutations = Array.isArray(body?.mutations) ? body.mutations : [];
+        const before = this.watermark();
+        const mutationResults = [];
+        const lastMutationIDChanges = {};
+        for (const m of mutations) {
+            const result = this.applyMutation(m);
+            mutationResults.push({ id: { clientID: m.clientID, id: m.id }, result });
+            lastMutationIDChanges[m.clientID] = m.id;
+        }
+        this.sendJSON(socket, ['pushResponse', { mutations: mutationResults }]);
+        const after = this.watermark();
+        const changes = after > before ? this.readChangesSince(before) : [];
+        const rowsPatch = changes.map((c) => this.syncRowPatchFromChange(c));
+        if (Object.keys(lastMutationIDChanges).length > 0 || rowsPatch.length > 0)
+            this.broadcastMutationPoke(attachment, {
+                lastMutationIDChanges,
+                rowsPatch,
+            });
+    }
+    async handleHttpPush(request) {
+        try {
+            const body = (await request.json());
+            const before = this.watermark();
+            const mutations = Array.isArray(body?.mutations) ? body.mutations : [];
+            const mutationResults = [];
+            const lastMutationIDChanges = {};
+            for (const m of mutations) {
+                const result = this.applyMutation(m);
+                mutationResults.push({ id: { clientID: m.clientID, id: m.id }, result });
+                lastMutationIDChanges[m.clientID] = m.id;
+            }
+            const after = this.watermark();
+            const changes = after > before ? this.readChangesSince(before) : [];
+            const rowsPatch = changes.map((c) => this.syncRowPatchFromChange(c));
+            if (Object.keys(lastMutationIDChanges).length > 0 || rowsPatch.length > 0)
+                this.broadcastPoke(body?.clientGroupID || 'default', {
+                    lastMutationIDChanges,
+                    rowsPatch,
+                });
+            return Response.json({ mutations: mutationResults });
+        }
+        catch (err) {
+            return Response.json({ error: err.message }, { status: 500 });
+        }
+    }
+    handlePull(socket, body) {
+        this.sendJSON(socket, [
+            'pull',
+            {
+                requestID: body?.requestID || crypto.randomUUID(),
+                cookie: this.cookie(),
+                lastMutationIDChanges: {},
+                patch: [],
+            },
+        ]);
+    }
+    // ── SQL execution endpoints ─────────────────────────────────────────────
+    async handleExec(request) {
+        let sql = '';
+        try {
+            const body = (await request.json());
+            sql = body.sql;
+            const params = Array.isArray(body.params) ? body.params : [];
+            const result = await this.ctx.storage.transaction(() => this.executeSQL(sql, params, body.track));
+            return Response.json(result);
+        }
+        catch (err) {
+            const suffix = sql ? ` while executing: ${sqlErrorSnippet(sql, err.message)}` : '';
+            console.error(`[exec-500] ${err.message} :: SQL=${sql.slice(0, 800)}`);
+            return Response.json({ error: `${err.message}${suffix}` }, { status: 500 });
+        }
+    }
+    /** Execute multiple statements atomically via ctx.storage.transaction() */
+    async handleBatch(request) {
+        try {
+            const { statements } = (await request.json());
+            const allRows = await this.ctx.storage.transaction(() => {
+                const results = [];
+                for (const statement of statements) {
+                    const item = typeof statement === 'string' ? { sql: statement } : statement;
+                    if (!item?.sql?.trim())
+                        continue;
+                    try {
+                        results.push(this.executeSQL(item.sql, Array.isArray(item.params) ? item.params : [], item.track));
+                    }
+                    catch (err) {
+                        throw new Error(`${err.message} while executing: ${sqlErrorSnippet(item.sql, err.message)}`);
+                    }
+                }
+                return results;
+            });
+            return Response.json({ results: allRows });
+        }
+        catch (err) {
+            return Response.json({ error: err.message }, { status: 500 });
+        }
+    }
+    async handleChanges(request, url) {
+        try {
+            let watermark = Number(url.searchParams.get('watermark') ?? url.searchParams.get('since') ?? 0);
+            let limit = Number(url.searchParams.get('limit') ?? 1000);
+            if (request.method === 'POST') {
+                const body = (await request.json().catch(() => ({})));
+                watermark = Number(body.watermark ?? body.since ?? watermark);
+                limit = Number(body.limit ?? limit);
+            }
+            if (!Number.isFinite(watermark) || watermark < 0)
+                watermark = 0;
+            if (!Number.isFinite(limit) || limit <= 0)
+                limit = 1000;
+            return Response.json({
+                watermark: this.watermark(),
+                changes: this.readChangesSince(watermark).slice(0, Math.min(limit, 10_000)),
+            });
+        }
+        catch (err) {
+            return Response.json({ error: err.message }, { status: 500 });
+        }
+    }
+    executeSQL(sql, params = [], track) {
+        const cursor = this.sql.exec(sql, ...params);
+        const columns = Array.isArray(cursor.columnNames) ? cursor.columnNames : [];
+        const rows = this.cursorRows(cursor);
+        if (!track)
+            return { rows, columns };
+        for (const row of rows) {
+            const trackedRow = trackedChangeRow(row, track);
+            if (track.operation === 'DELETE')
+                this.appendTrackedChange(track.tableName, 'DELETE', null, trackedRow);
+            else
+                this.appendTrackedChange(track.tableName, track.operation, trackedRow, null);
+        }
+        return {
+            rows: track.returnRows ? rows : [],
+            columns: track.returnRows ? columns : [],
+            affectedRows: rows.length,
+        };
+    }
+    cursorRows(cursor) {
+        return cursor.toArray().map((row) => {
+            const obj = {};
+            for (const k of Object.keys(row))
+                obj[k] = row[k];
+            return obj;
+        });
+    }
+    // ── CRUD operations ──────────────────────────────────────────────────────
+    applyMutation(mutation) {
+        if (mutation.type === 'crud' && mutation.name === '_zero_crud') {
+            return this.applyCrudMutation(mutation);
+        }
+        if (mutation.name === '_zero_cleanupResults')
+            return {};
+        if (mutation.type === 'custom')
+            return this.applyTableMutation(mutation);
+        return {
+            error: 'app',
+            message: `unsupported mutation ${mutation.type}:${mutation.name}`,
+        };
+    }
+    applyTableMutation(mutation) {
+        const [tableName, action] = this.tableActionFromMutationName(mutation.name);
+        if (!tableName || !action)
+            return { error: 'app', message: `invalid mutation name ${mutation.name}` };
+        if (!this.tableExists(tableName))
+            return { error: 'app', message: `unknown table ${tableName}` };
+        const value = (mutation.args[0] || {});
+        const primaryKey = this.primaryKeyForTable(tableName, []);
+        if (action === 'insert')
+            this.insertRow(tableName, value, primaryKey);
+        else if (action === 'upsert')
+            this.upsertRow(tableName, value, primaryKey);
+        else if (action === 'delete')
+            this.deleteRow(tableName, value, primaryKey);
+        else
+            this.updateRow(tableName, value, primaryKey);
+        return {};
+    }
+    tableActionFromMutationName(name) {
+        if (name.includes('|'))
+            return name.split('|', 2);
+        return name.split('.', 2);
+    }
+    tableNameFromOperationName(name) {
+        if (!name)
+            return null;
+        return name.split(/[.|]/, 1)[0] || null;
+    }
+    applyCrudMutation(mutation) {
+        const arg = mutation.args[0];
+        const ops = Array.isArray(arg?.ops) ? arg.ops : [];
+        for (const crud of ops) {
+            if (!crud?.tableName)
+                return { error: 'app', message: 'invalid crud mutation' };
+            if (!this.tableExists(crud.tableName))
+                return { error: 'app', message: `unknown table ${crud.tableName}` };
+            const value = crud.value || {};
+            const primaryKey = this.primaryKeyForTable(crud.tableName, crud.primaryKey || []);
+            if (crud.op === 'insert')
+                this.insertRow(crud.tableName, value, primaryKey);
+            else if (crud.op === 'upsert')
+                this.upsertRow(crud.tableName, value, primaryKey);
+            else if (crud.op === 'update')
+                this.updateRow(crud.tableName, value, primaryKey);
+            else if (crud.op === 'delete')
+                this.deleteRow(crud.tableName, value, primaryKey);
+        }
+        return {};
+    }
+    insertRow(tn, value, pk) {
+        if (this.readRowByPrimaryKey(tn, value, pk))
+            return;
+        const row = this.storageRow(tn, value, true);
+        const cols = Object.keys(row);
+        if (!cols.length)
+            return;
+        const qc = cols.map((c) => quoteIdent(c)).join(', ');
+        const ph = cols.map(() => '?').join(', ');
+        this.sql.exec(`INSERT INTO ${quoteIdent(tn)} (${qc}) VALUES (${ph})`, ...cols.map((c) => row[c]));
+        const next = this.readRowByPrimaryKey(tn, value, pk) || this.normalizeRow(tn, row);
+        this.appendChange(tn, 'INSERT', next, null);
+    }
+    upsertRow(tn, value, pk) {
+        const existing = this.readRowByPrimaryKey(tn, value, pk);
+        if (existing) {
+            this.updateRow(tn, value, pk);
+            return;
+        }
+        this.insertRow(tn, value, pk);
+    }
+    updateRow(tn, value, pk) {
+        if (!pk.length)
+            return;
+        const existing = this.readRowByPrimaryKey(tn, value, pk);
+        if (!existing)
+            return;
+        const nk = Object.keys(value).filter((c) => !pk.includes(c));
+        if (!nk.length)
+            return;
+        const storage = this.storageRow(tn, value, false);
+        this.sql.exec(`UPDATE ${quoteIdent(tn)} SET ${nk.map((c) => `${quoteIdent(c)} = ?`).join(', ')} WHERE ${this.primaryKeyWhere(pk)}`, ...nk.map((c) => storage[c]), ...pk.map((c) => this.storageColumnValue(tn, c, value[c])));
+        const next = this.readRowByPrimaryKey(tn, value, pk);
+        if (next)
+            this.appendChange(tn, 'UPDATE', next, existing);
+    }
+    deleteRow(tn, value, pk) {
+        if (!pk.length)
+            return;
+        const existing = this.readRowByPrimaryKey(tn, value, pk);
+        if (!existing)
+            return;
+        this.sql.exec(`DELETE FROM ${quoteIdent(tn)} WHERE ${this.primaryKeyWhere(pk)}`, ...pk.map((c) => this.storageColumnValue(tn, c, value[c])));
+        this.appendChange(tn, 'DELETE', null, existing);
+    }
+    appendChange(tn, op, rowData, oldData) {
+        this.appendTrackedChange(tn, op, rowData, oldData);
+    }
+    appendTrackedChange(tableName, op, rowData, oldData) {
+        this.watermarks.ensureTables();
+        const watermark = this.watermarks.next();
+        this.sql.exec('INSERT INTO _zero_changes (watermark, table_name, op, row_data, old_data) VALUES (?, ?, ?, ?, ?)', watermark, tableName, op, rowData ? JSON.stringify(rowData) : null, oldData ? JSON.stringify(oldData) : null);
+        this.watermarks.mark(watermark);
+    }
+    readChangesSince(watermark) {
+        this.watermarks.ensureTables();
+        return this.sql
+            .exec('SELECT watermark, table_name, op, row_data, old_data FROM _zero_changes WHERE watermark > ? ORDER BY watermark', watermark)
+            .toArray()
+            .map((row) => ({
+            watermark: Number(row.watermark),
+            tableName: String(row.table_name),
+            op: String(row.op),
+            rowData: row.row_data ? JSON.parse(String(row.row_data)) : null,
+            oldData: row.old_data ? JSON.parse(String(row.old_data)) : null,
+        }));
+    }
+    watermark() {
+        return this.watermarks.current();
+    }
+    ensureSchemaTables(clientSchema) {
+        this.ensureSchemaMetadataTable();
+        for (const [name, def] of Object.entries(clientSchema.tables)) {
+            this.tableSchemas.set(name, def);
+            this.sql.exec('INSERT OR REPLACE INTO _zero_schema_tables (name, schema_json) VALUES (?, ?)', name, JSON.stringify(def));
+            if (this.schemaTables.has(name))
+                continue;
+            const pk = def.primaryKey.map((c) => quoteIdent(c));
+            const pkClause = pk.length ? `, PRIMARY KEY (${pk.join(', ')})` : '';
+            const colDefs = Object.entries(def.columns).map(([cn, cd]) => {
+                const t = {
+                    string: 'TEXT',
+                    number: 'REAL',
+                    boolean: 'INTEGER',
+                    json: 'TEXT',
+                    bigint: 'TEXT',
+                };
+                return `${quoteIdent(cn)} ${t[cd.type] || 'TEXT'}`;
+            });
+            this.sql.exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(name)} (${colDefs.join(', ')}${pkClause})`);
+            this.schemaTables.add(name);
+        }
+    }
+    ensureSchemaMetadataTable() {
+        this.sql.exec('CREATE TABLE IF NOT EXISTS _zero_schema_tables (name TEXT PRIMARY KEY, schema_json TEXT NOT NULL)');
+    }
+    schemaForTable(tableName) {
+        const cached = this.tableSchemas.get(tableName);
+        if (cached)
+            return cached;
+        try {
+            this.ensureSchemaMetadataTable();
+            const row = this.sql
+                .exec('SELECT schema_json FROM _zero_schema_tables WHERE name = ?', tableName)
+                .one();
+            if (!row?.schema_json)
+                return undefined;
+            const schema = JSON.parse(String(row.schema_json));
+            this.tableSchemas.set(tableName, schema);
+            return schema;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    tableExists(n) {
+        try {
+            return !!this.sql
+                .exec("SELECT name FROM sqlite_master WHERE type='table' AND name=?", n)
+                .one();
+        }
+        catch {
+            return false;
+        }
+    }
+    readAllRows(tn) {
+        try {
+            return this.sql
+                .exec(`SELECT * FROM ${quoteIdent(tn)}`)
+                .toArray()
+                .map((row) => this.normalizeRow(tn, row));
+        }
+        catch {
+            return [];
+        }
+    }
+    readRowByPrimaryKey(tn, value, pk) {
+        if (!pk.length)
+            return null;
+        try {
+            const row = this.sql
+                .exec(`SELECT * FROM ${quoteIdent(tn)} WHERE ${this.primaryKeyWhere(pk)}`, ...pk.map((c) => this.storageColumnValue(tn, c, value[c])))
+                .one();
+            return row ? this.normalizeRow(tn, row) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    primaryKeyWhere(pk) {
+        return pk.map((c) => `${quoteIdent(c)} = ?`).join(' AND ');
+    }
+    primaryKeyForTable(tn, fallback) {
+        const schema = this.schemaForTable(tn);
+        if (schema?.primaryKey?.length)
+            return schema.primaryKey;
+        return fallback;
+    }
+    storageRow(tn, value, includeMissingSchemaColumns) {
+        const schema = this.schemaForTable(tn);
+        const row = {};
+        if (schema && includeMissingSchemaColumns) {
+            for (const column of Object.keys(schema.columns))
+                row[column] = this.storageColumnValue(tn, column, value[column] ?? null);
+        }
+        for (const column of Object.keys(value)) {
+            if (value[column] !== undefined)
+                row[column] = this.storageColumnValue(tn, column, value[column]);
+        }
+        return row;
+    }
+    storageColumnValue(tn, column, value) {
+        if (value === undefined || value === null)
+            return null;
+        const type = this.schemaForTable(tn)?.columns?.[column]?.type;
+        if (type === 'boolean')
+            return value ? 1 : 0;
+        if (type === 'json')
+            return typeof value === 'string' ? value : JSON.stringify(value);
+        if (type === 'number')
+            return Number(value);
+        if (type === 'bigint')
+            return String(value);
+        return value;
+    }
+    normalizeRow(tn, row) {
+        const schema = this.schemaForTable(tn);
+        const normalized = {};
+        for (const key of Object.keys(row)) {
+            const type = schema?.columns?.[key]?.type;
+            const value = row[key];
+            if (value === null || value === undefined) {
+                normalized[key] = null;
+            }
+            else if (type === 'boolean') {
+                normalized[key] =
+                    value === true || value === 1 || value === '1' || value === 'true';
+            }
+            else if (type === 'number') {
+                normalized[key] = Number(value);
+            }
+            else if (type === 'json' && typeof value === 'string') {
+                try {
+                    normalized[key] = JSON.parse(value);
+                }
+                catch {
+                    normalized[key] = value;
+                }
+            }
+            else {
+                normalized[key] = value;
+            }
+        }
+        return normalized;
+    }
+    sendSyncPoke(socket, attachment, part) {
+        const cookie = this.nextCookie();
+        const pokeID = crypto.randomUUID();
+        this.sendJSON(socket, [
+            'pokeStart',
+            {
+                pokeID,
+                baseCookie: attachment.cookie,
+                schemaVersions: {
+                    minSupportedVersion: SCHEMA_VERSION,
+                    maxSupportedVersion: SCHEMA_VERSION,
+                },
+                timestamp: Date.now(),
+            },
+        ]);
+        this.sendJSON(socket, ['pokePart', { pokeID, ...part }]);
+        this.sendJSON(socket, ['pokeEnd', { pokeID, cookie }]);
+        const nextAttachment = { ...attachment, cookie };
+        socket.serializeAttachment(nextAttachment);
+        return nextAttachment;
+    }
+    broadcastPoke(clientGroupID, part) {
+        for (const socket of this.ctx.getWebSockets()) {
+            const ws = socket;
+            const attachment = this.readSocketAttachment(ws);
+            if (!attachment)
+                continue;
+            if (attachment.clientGroupID !== clientGroupID)
+                continue;
+            this.sendSyncPoke(ws, attachment, part);
+        }
+    }
+    broadcastMutationPoke(sourceAttachment, part) {
+        const rowsPatch = part.rowsPatch || [];
+        const changedTables = new Set(rowsPatch
+            .map((op) => op?.tableName)
+            .filter((tableName) => !!tableName));
+        const hasLastMutationIDChanges = Object.keys(part.lastMutationIDChanges || {}).length > 0;
+        for (const socket of this.ctx.getWebSockets()) {
+            const ws = socket;
+            const attachment = this.readSocketAttachment(ws);
+            if (!attachment)
+                continue;
+            if (attachment.userID !== sourceAttachment.userID)
+                continue;
+            const isSourceClientGroup = attachment.clientGroupID === sourceAttachment.clientGroupID;
+            const wantsChangedRows = changedTables.size > 0 &&
+                attachment.desiredTableNames.some((tableName) => changedTables.has(tableName));
+            const nextPart = {};
+            if (wantsChangedRows)
+                nextPart.rowsPatch = rowsPatch;
+            if (isSourceClientGroup && hasLastMutationIDChanges)
+                nextPart.lastMutationIDChanges = part.lastMutationIDChanges;
+            if (!nextPart.rowsPatch && !nextPart.lastMutationIDChanges)
+                continue;
+            this.sendSyncPoke(ws, attachment, nextPart);
+        }
+    }
+    syncRowPatchFromChange(change) {
+        if (change.op === 'DELETE')
+            return {
+                op: 'del',
+                tableName: change.tableName,
+                id: this.primaryKeyValue(change.tableName, change.oldData || {}),
+            };
+        return {
+            op: 'put',
+            tableName: change.tableName,
+            value: this.normalizeRow(change.tableName, change.rowData || {}),
+        };
+    }
+    primaryKeyValue(tableName, row) {
+        const pk = this.primaryKeyForTable(tableName, []);
+        if (pk.length)
+            return Object.fromEntries(pk.map((column) => [column, row[column]]));
+        if ('id' in row)
+            return { id: row.id };
+        return row;
+    }
+    cookie() {
+        return String(this.watermark()).padStart(20, '0');
+    }
+    nextCookie() {
+        const watermark = this.watermarks.next();
+        this.watermarks.mark(watermark);
+        return String(watermark).padStart(20, '0');
+    }
+    readSocketAttachment(socket) {
+        const attachment = socket.deserializeAttachment();
+        if (!attachment)
+            return null;
+        return {
+            ...attachment,
+            initialized: attachment.initialized === true,
+            desiredTableNames: attachment.desiredTableNames || [],
+            desiredQueries: attachment.desiredQueries || [],
+        };
+    }
+    sendJSON(socket, msg) {
+        try {
+            socket.send(JSON.stringify(msg));
+        }
+        catch { }
+    }
+    parseMessage(data) {
+        try {
+            return JSON.parse(typeof data === 'string' ? data : new TextDecoder().decode(data));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export default {
+    async fetch(request, env) {
+        const url = new URL(request.url);
+        const id = env.ZERO_DO.idFromName('singleton');
+        if (url.pathname.startsWith('/sync/v') && url.pathname.endsWith('/connect')) {
+            return env.ZERO_DO.get(id).fetch(request);
+        }
+        if ((url.pathname === '/zero/push' || url.pathname === '/api/zero/push') &&
+            request.method === 'POST') {
+            return env.ZERO_DO.get(id).fetch(request);
+        }
+        if (url.pathname === '/exec' && request.method === 'POST') {
+            return env.ZERO_DO.get(id).fetch(request);
+        }
+        if (url.pathname === '/batch' && request.method === 'POST') {
+            return env.ZERO_DO.get(id).fetch(request);
+        }
+        if (url.pathname === '/changes' &&
+            (request.method === 'GET' || request.method === 'POST')) {
+            return env.ZERO_DO.get(id).fetch(request);
+        }
+        if (url.pathname === '/notify' && request.method === 'POST') {
+            return env.ZERO_DO.get(id).fetch(request);
+        }
+        return new Response('not found', { status: 404 });
+    },
+};
+function decodeInitConnection(secProtocol) {
+    try {
+        const decoded = decodeURIComponent(secProtocol);
+        const bytes = Uint8Array.from(atob(decoded), (char) => char.charCodeAt(0));
+        const protocols = JSON.parse(new TextDecoder().decode(bytes));
+        const message = protocols.initConnectionMessage;
+        if (Array.isArray(message) && message[0] === 'initConnection') {
+            return message;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=worker.js.map