@lix-js/sdk 0.15.1 → 0.16.1

package/dist/remote/server-protocol.js

@@ -1,417 +0,0 @@
-export const SERVER_PROTOCOL_VERSION = 6;
-export function encodeWireValue(value) {
-    switch (value.kind) {
-        case "null":
-            return { kind: "null", value: null };
-        case "boolean":
-            return { kind: "bool", value: value.value };
-        case "integer":
-            return { kind: "int", value: value.value };
-        case "real":
-            return { kind: "float", value: value.value };
-        case "text":
-            return { kind: "text", value: value.value };
-        case "jsonb":
-            return { kind: "jsonb", value: value.value };
-        case "row_ref":
-            return { kind: "row_ref", value: value.value };
-        case "timestamptz":
-            return { kind: "timestamptz", value: value.value };
-        case "blob":
-            return { kind: "blob", base64: bytesToBase64(value.blob) };
-    }
-}
-export function decodeExecuteResult(value) {
-    const result = record(value, "execute result");
-    if (!Array.isArray(result.columns)) {
-        throw protocolError("execute result columns must be an array");
-    }
-    const columns = result.columns.map((column, index) => {
-        const item = record(column, `execute result column ${index}`);
-        if (typeof item.name !== "string" || !isResultColumnType(item.type)) {
-            throw protocolError(`execute result column ${index} requires a string name and valid type`);
-        }
-        return { name: item.name, type: item.type };
-    });
-    if (!Array.isArray(result.rows)) {
-        throw protocolError("execute result rows must be an array");
-    }
-    const rows = result.rows.map((row, rowIndex) => {
-        if (!Array.isArray(row)) {
-            throw protocolError(`execute result row ${rowIndex} must be an array`);
-        }
-        if (row.length !== columns.length) {
-            throw protocolError(`execute result row ${rowIndex} has ${row.length} values for ${columns.length} columns`);
-        }
-        return row.map((entry, columnIndex) => {
-            const decoded = decodeWireValue(entry);
-            const declaredType = columns[columnIndex]?.type;
-            if (decoded.kind !== "null" && decoded.kind !== declaredType) {
-                throw protocolError(`execute result row ${rowIndex} column ${columnIndex} declares ${String(declaredType)} but contains ${decoded.kind}`);
-            }
-            return decoded;
-        });
-    });
-    if (typeof result.rowsAffected !== "number" ||
-        !Number.isSafeInteger(result.rowsAffected) ||
-        result.rowsAffected < 0) {
-        throw protocolError("execute result rowsAffected must be a non-negative safe integer");
-    }
-    if (!Array.isArray(result.notices)) {
-        throw protocolError("execute result notices must be an array");
-    }
-    const notices = result.notices.map((notice, index) => {
-        const item = record(notice, `execute result notice ${index}`);
-        if (typeof item.code !== "string" || typeof item.message !== "string") {
-            throw protocolError(`execute result notice ${index} requires code and message`);
-        }
-        if (item.hint !== undefined && typeof item.hint !== "string") {
-            throw protocolError(`execute result notice ${index} hint must be a string`);
-        }
-        return {
-            code: item.code,
-            message: item.message,
-            ...(item.hint === undefined ? {} : { hint: item.hint }),
-        };
-    });
-    return { columns, rows, rowsAffected: result.rowsAffected, notices };
-}
-function isResultColumnType(value) {
-    return (value === "null" ||
-        value === "boolean" ||
-        value === "integer" ||
-        value === "real" ||
-        value === "text" ||
-        value === "jsonb" ||
-        value === "row_ref" ||
-        value === "timestamptz" ||
-        value === "blob");
-}
-export function decodeExecuteBatchResult(value) {
-    const result = record(value, "execute batch result");
-    const statementIndex = nonNegativeSafeInteger(result.statementIndex, "execute batch result statementIndex");
-    if (result.label !== undefined && typeof result.label !== "string") {
-        throw protocolError("execute batch result label must be a string when present");
-    }
-    return {
-        ...decodeExecuteResult(value),
-        statementIndex,
-        ...(result.label === undefined ? {} : { label: result.label }),
-    };
-}
-export function decodeHandshake(value) {
-    const handshake = record(value, "Lix Server Protocol handshake");
-    if (handshake.protocolVersion !== SERVER_PROTOCOL_VERSION) {
-        throw protocolError(`unsupported Lix Server Protocol version: ${String(handshake.protocolVersion)}`);
-    }
-    if (typeof handshake.activeBranchId !== "string" ||
-        handshake.activeBranchId.length === 0) {
-        throw protocolError("Lix Server Protocol handshake requires activeBranchId");
-    }
-    if (typeof handshake.activeAccountId !== "string" ||
-        handshake.activeAccountId.length === 0) {
-        throw protocolError("Lix Server Protocol handshake requires activeAccountId");
-    }
-    if (typeof handshake.sessionId !== "string" ||
-        !/^[\x21-\x7e]{1,256}$/.test(handshake.sessionId)) {
-        throw protocolError("Lix Server Protocol handshake requires a valid sessionId");
-    }
-    return {
-        protocolVersion: SERVER_PROTOCOL_VERSION,
-        activeBranchId: handshake.activeBranchId,
-        activeAccountId: handshake.activeAccountId,
-        sessionId: handshake.sessionId,
-    };
-}
-export function decodeObserveEvent(value, base) {
-    const event = record(value, "observe event");
-    if (typeof event.sequence !== "number" ||
-        !Number.isSafeInteger(event.sequence) ||
-        event.sequence < 0) {
-        throw protocolError("observe event sequence must be a non-negative safe integer");
-    }
-    if (typeof event.mutationSequence !== "number" ||
-        !Number.isSafeInteger(event.mutationSequence) ||
-        event.mutationSequence < 0) {
-        throw protocolError("observe event mutationSequence must be a non-negative safe integer");
-    }
-    const hasResult = event.result !== undefined;
-    const hasDelta = event.delta !== undefined;
-    if (hasResult === hasDelta) {
-        throw protocolError("observe event requires exactly one of result or delta");
-    }
-    const sequence = event.sequence;
-    return {
-        sequence,
-        mutationSequence: event.mutationSequence,
-        rows: hasResult
-            ? decodeExecuteResult(event.result)
-            : applyObserveDelta(event.delta, sequence, base),
-    };
-}
-function applyObserveDelta(value, sequence, base) {
-    const delta = record(value, "observe event delta");
-    switch (delta.kind) {
-        case "single-blob-splice":
-            return applyObserveBlobDelta(delta, sequence, base);
-        case "row-splice":
-            return applyObserveRowSplice(delta, sequence, base);
-        default:
-            throw protocolError(`unknown observe delta kind: ${String(delta.kind)}`);
-    }
-}
-function applyObserveBlobDelta(delta, sequence, base) {
-    const baseSequence = nonNegativeSafeInteger(delta.baseSequence, "observe delta baseSequence");
-    const prefixBytes = nonNegativeSafeInteger(delta.prefixBytes, "observe delta prefixBytes");
-    const suffixBytes = nonNegativeSafeInteger(delta.suffixBytes, "observe delta suffixBytes");
-    if (typeof delta.insertBase64 !== "string") {
-        throw protocolError("observe delta insertBase64 must be a string");
-    }
-    if (base === undefined ||
-        base.sequence !== baseSequence ||
-        sequence !== baseSequence + 1) {
-        throw protocolError("observe blob delta does not match its transport base");
-    }
-    const baseValue = base.rows.rows[0]?.[0];
-    if (base.rows.columns.length !== 1 ||
-        base.rows.columns[0]?.name !== "content" ||
-        base.rows.columns[0]?.type !== "blob" ||
-        base.rows.rows.length !== 1 ||
-        base.rows.rows[0]?.length !== 1 ||
-        base.rows.rowsAffected !== 0 ||
-        base.rows.notices.length !== 0 ||
-        baseValue?.kind !== "blob") {
-        throw protocolError("observe blob delta base is not a point blob result");
-    }
-    if (prefixBytes + suffixBytes > baseValue.blob.byteLength) {
-        throw protocolError("observe blob delta prefix and suffix overlap");
-    }
-    const insert = base64ToBytes(delta.insertBase64);
-    const nextLength = prefixBytes + insert.byteLength + suffixBytes;
-    if (!Number.isSafeInteger(nextLength)) {
-        throw protocolError("observe blob delta result is too large");
-    }
-    let blob;
-    try {
-        blob = new Uint8Array(nextLength);
-    }
-    catch {
-        throw protocolError("observe blob delta result is too large");
-    }
-    blob.set(baseValue.blob.subarray(0, prefixBytes), 0);
-    blob.set(insert, prefixBytes);
-    blob.set(baseValue.blob.subarray(baseValue.blob.byteLength - suffixBytes), prefixBytes + insert.byteLength);
-    return {
-        columns: [{ name: "content", type: "blob" }],
-        rows: [[{ kind: "blob", value: null, blob }]],
-        rowsAffected: 0,
-        notices: [],
-    };
-}
-function applyObserveRowSplice(delta, sequence, base) {
-    const baseSequence = nonNegativeSafeInteger(delta.baseSequence, "observe row delta baseSequence");
-    const prefixRows = nonNegativeSafeInteger(delta.prefixRows, "observe row delta prefixRows");
-    const deleteRows = nonNegativeSafeInteger(delta.deleteRows, "observe row delta deleteRows");
-    if (base === undefined ||
-        base.sequence !== baseSequence ||
-        sequence !== baseSequence + 1) {
-        throw protocolError("observe row delta does not match its transport base");
-    }
-    if (!Array.isArray(delta.insertRows)) {
-        throw protocolError("observe row delta insertRows must be an array");
-    }
-    if (prefixRows > base.rows.rows.length ||
-        deleteRows > base.rows.rows.length - prefixRows) {
-        throw protocolError("observe row delta splice range is outside its transport base");
-    }
-    const suffixStart = prefixRows + deleteRows;
-    const nextRowCount = prefixRows + delta.insertRows.length + (base.rows.rows.length - suffixStart);
-    if (!Number.isSafeInteger(nextRowCount) ||
-        nextRowCount > 0xffff_ffff) {
-        throw protocolError("observe row delta result is too large");
-    }
-    let rows;
-    try {
-        rows = new Array(nextRowCount);
-    }
-    catch {
-        throw protocolError("observe row delta result is too large");
-    }
-    let destination = 0;
-    for (let index = 0; index < prefixRows; index += 1) {
-        rows[destination++] = base.rows.rows[index];
-    }
-    for (let rowIndex = 0; rowIndex < delta.insertRows.length; rowIndex += 1) {
-        const row = delta.insertRows[rowIndex];
-        if (!Array.isArray(row)) {
-            throw protocolError(`observe row delta insert row ${rowIndex} must be an array`);
-        }
-        if (row.length !== base.rows.columns.length) {
-            throw protocolError(`observe row delta insert row ${rowIndex} has ${row.length} values for ${base.rows.columns.length} columns`);
-        }
-        rows[destination++] = row.map((entry) => decodeWireValue(entry));
-    }
-    for (let index = suffixStart; index < base.rows.rows.length; index += 1) {
-        rows[destination++] = base.rows.rows[index];
-    }
-    return {
-        columns: [...base.rows.columns],
-        rows,
-        rowsAffected: base.rows.rowsAffected,
-        notices: base.rows.notices.map((notice) => ({ ...notice })),
-    };
-}
-export function remoteError(code, message, options = {}) {
-    const error = new Error(message);
-    error.name = "LixError";
-    error.code = code;
-    error.hint = options.hint;
-    error.details = options.details;
-    error.status = options.status;
-    return error;
-}
-export function protocolError(message) {
-    return remoteError("LIX_SERVER_PROTOCOL_ERROR", message);
-}
-export function errorFromResponseBody(value, status) {
-    const body = record(value, "Lix Server Protocol error response");
-    const rawError = record(body.error, "Lix Server Protocol error response error");
-    return remoteError(typeof rawError.code === "string"
-        ? rawError.code
-        : "LIX_REMOTE_REQUEST_FAILED", typeof rawError.message === "string"
-        ? rawError.message
-        : status === undefined
-            ? "Remote Lix operation failed"
-            : `Remote Lix request failed with status ${status}`, {
-        hint: typeof rawError.hint === "string" ? rawError.hint : undefined,
-        details: rawError.details,
-        status,
-    });
-}
-export function record(value, description) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw protocolError(`${description} must be an object`);
-    }
-    return value;
-}
-function decodeWireValue(value) {
-    const wire = record(value, "wire value");
-    switch (wire.kind) {
-        case "null":
-            if (wire.value !== null)
-                throw protocolError("null wire value is invalid");
-            return { kind: "null", value: null };
-        case "bool":
-            if (typeof wire.value !== "boolean") {
-                throw protocolError("bool wire value is invalid");
-            }
-            return { kind: "boolean", value: wire.value };
-        case "int":
-            if (typeof wire.value !== "number" || !Number.isSafeInteger(wire.value)) {
-                throw protocolError("int wire value is invalid");
-            }
-            return { kind: "integer", value: wire.value };
-        case "float":
-            if (typeof wire.value !== "number" || !Number.isFinite(wire.value)) {
-                throw protocolError("float wire value is invalid");
-            }
-            return { kind: "real", value: wire.value };
-        case "text":
-            if (typeof wire.value !== "string") {
-                throw protocolError("text wire value is invalid");
-            }
-            return { kind: "text", value: wire.value };
-        case "jsonb":
-            assertJsonValue(wire.value, "jsonb wire value");
-            return { kind: "jsonb", value: wire.value };
-        case "row_ref":
-            if (typeof wire.value !== "string") {
-                throw protocolError("row_ref wire value is invalid");
-            }
-            return { kind: "row_ref", value: wire.value };
-        case "timestamptz":
-            if (typeof wire.value !== "string") {
-                throw protocolError("timestamptz wire value is invalid");
-            }
-            return { kind: "timestamptz", value: wire.value };
-        case "blob":
-            if (typeof wire.base64 !== "string") {
-                throw protocolError("blob wire value is invalid");
-            }
-            return { kind: "blob", value: null, blob: base64ToBytes(wire.base64) };
-        default:
-            throw protocolError(`unknown wire value kind: ${String(wire.kind)}`);
-    }
-}
-function stringArray(value, description) {
-    if (!Array.isArray(value) ||
-        !value.every((entry) => typeof entry === "string")) {
-        throw protocolError(`${description} must be an array of strings`);
-    }
-    return [...value];
-}
-function nonNegativeSafeInteger(value, description) {
-    if (typeof value !== "number" ||
-        !Number.isSafeInteger(value) ||
-        value < 0) {
-        throw protocolError(`${description} must be a non-negative safe integer`);
-    }
-    return value;
-}
-function assertJsonValue(value, description) {
-    if (value === null ||
-        typeof value === "boolean" ||
-        (typeof value === "number" &&
-            Number.isFinite(value) &&
-            (!Number.isInteger(value) || Number.isSafeInteger(value))) ||
-        (typeof value === "string" && value.isWellFormed())) {
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const entry of value)
-            assertJsonValue(entry, description);
-        return;
-    }
-    if (value && typeof value === "object") {
-        for (const entry of Object.values(value)) {
-            assertJsonValue(entry, description);
-        }
-        return;
-    }
-    throw protocolError(`${description} is not valid Lix JSON`);
-}
-function bytesToBase64(bytes) {
-    const nativeToBase64 = bytes.toBase64;
-    if (typeof nativeToBase64 === "function") {
-        return nativeToBase64.call(bytes);
-    }
-    let binary = "";
-    const chunkSize = 0x8000;
-    for (let offset = 0; offset < bytes.length; offset += chunkSize) {
-        binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
-    }
-    return btoa(binary);
-}
-function base64ToBytes(base64) {
-    const nativeFromBase64 = Uint8Array.fromBase64;
-    if (typeof nativeFromBase64 === "function") {
-        try {
-            return nativeFromBase64(base64);
-        }
-        catch {
-            throw protocolError("blob wire value contains invalid base64");
-        }
-    }
-    let binary;
-    try {
-        binary = atob(base64);
-    }
-    catch {
-        throw protocolError("blob wire value contains invalid base64");
-    }
-    const bytes = new Uint8Array(binary.length);
-    for (let index = 0; index < binary.length; index += 1) {
-        bytes[index] = binary.charCodeAt(index);
-    }
-    return bytes;
-}