orcaq 1.0.33 → 1.1.2

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/encode.js

@@ -0,0 +1,95 @@
+import { VARINT, FIXED_64, LENGTH_DELIMITED } from "./util.js";
+export class MessageWriter {
+    #buf;
+    #array;
+    #view;
+    #pos;
+    constructor() {
+        this.#buf = new ArrayBuffer(256);
+        this.#array = new Uint8Array(this.#buf);
+        this.#view = new DataView(this.#buf);
+        this.#pos = 0;
+    }
+    #ensure(extra) {
+        if (this.#pos + extra <= this.#buf.byteLength) {
+            return;
+        }
+        let newCap = this.#buf.byteLength;
+        while (newCap < this.#pos + extra) {
+            newCap *= 2;
+        }
+        const newBuf = new ArrayBuffer(newCap);
+        const newArray = new Uint8Array(newBuf);
+        const newView = new DataView(newBuf);
+        newArray.set(new Uint8Array(this.#buf, 0, this.#pos));
+        this.#buf = newBuf;
+        this.#array = newArray;
+        this.#view = newView;
+    }
+    #varint(value) {
+        this.#ensure(5);
+        value = 0 | value;
+        do {
+            let byte = value & 0x7f;
+            value >>>= 7;
+            byte |= (value ? 0x80 : 0);
+            this.#array[this.#pos++] = byte;
+        } while (value);
+    }
+    #varintBig(value) {
+        this.#ensure(10);
+        value = value & 0xffffffffffffffffn;
+        do {
+            let byte = Number(value & 0x7fn);
+            value >>= 7n;
+            byte |= (value ? 0x80 : 0);
+            this.#array[this.#pos++] = byte;
+        } while (value);
+    }
+    #tag(tag, wireType) {
+        this.#varint((tag << 3) | wireType);
+    }
+    bytes(tag, value) {
+        this.#tag(tag, LENGTH_DELIMITED);
+        this.#varint(value.byteLength);
+        this.#ensure(value.byteLength);
+        this.#array.set(value, this.#pos);
+        this.#pos += value.byteLength;
+    }
+    string(tag, value) {
+        this.bytes(tag, new TextEncoder().encode(value));
+    }
+    message(tag, value, fun) {
+        const writer = new MessageWriter();
+        fun(writer, value);
+        this.bytes(tag, writer.data());
+    }
+    int32(tag, value) {
+        this.#tag(tag, VARINT);
+        this.#varint(value);
+    }
+    uint32(tag, value) {
+        this.int32(tag, value);
+    }
+    bool(tag, value) {
+        this.int32(tag, value ? 1 : 0);
+    }
+    sint64(tag, value) {
+        this.#tag(tag, VARINT);
+        this.#varintBig((value << 1n) ^ (value >> 63n));
+    }
+    double(tag, value) {
+        this.#tag(tag, FIXED_64);
+        this.#ensure(8);
+        this.#view.setFloat64(this.#pos, value, true);
+        this.#pos += 8;
+    }
+    data() {
+        return new Uint8Array(this.#buf, 0, this.#pos);
+    }
+}
+export function writeProtobufMessage(value, fun) {
+    const w = new MessageWriter();
+    fun(w, value);
+    return w.data();
+}

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/util.js

@@ -0,0 +1,6 @@
+export const VARINT = 0;
+export const FIXED_64 = 1;
+export const LENGTH_DELIMITED = 2;
+export const GROUP_START = 3;
+export const GROUP_END = 4;
+export const FIXED_32 = 5;

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/errors.js

@@ -0,0 +1,102 @@
+/** Generic error produced by the Hrana client. */
+export class ClientError extends Error {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "ClientError";
+    }
+}
+/** Error thrown when the server violates the protocol. */
+export class ProtoError extends ClientError {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "ProtoError";
+    }
+}
+/** Error thrown when the server returns an error response. */
+export class ResponseError extends ClientError {
+    code;
+    /** @internal */
+    proto;
+    /** @private */
+    constructor(message, protoError) {
+        super(message);
+        this.name = "ResponseError";
+        this.code = protoError.code;
+        this.proto = protoError;
+        this.stack = undefined;
+    }
+}
+/** Error thrown when the client or stream is closed. */
+export class ClosedError extends ClientError {
+    /** @private */
+    constructor(message, cause) {
+        if (cause !== undefined) {
+            super(`${message}: ${cause}`);
+            this.cause = cause;
+        }
+        else {
+            super(message);
+        }
+        this.name = "ClosedError";
+    }
+}
+/** Error thrown when the environment does not seem to support WebSockets. */
+export class WebSocketUnsupportedError extends ClientError {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "WebSocketUnsupportedError";
+    }
+}
+/** Error thrown when we encounter a WebSocket error. */
+export class WebSocketError extends ClientError {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "WebSocketError";
+    }
+}
+/** Error thrown when the HTTP server returns an error response. */
+export class HttpServerError extends ClientError {
+    status;
+    /** @private */
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "HttpServerError";
+    }
+}
+/** Error thrown when a libsql URL is not valid. */
+export class LibsqlUrlParseError extends ClientError {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "LibsqlUrlParseError";
+    }
+}
+/** Error thrown when the protocol version is too low to support a feature. */
+export class ProtocolVersionError extends ClientError {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "ProtocolVersionError";
+    }
+}
+/** Error thrown when an internal client error happens. */
+export class InternalError extends ClientError {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "InternalError";
+    }
+}
+/** Error thrown when the API is misused. */
+export class MisuseError extends ClientError {
+    /** @private */
+    constructor(message) {
+        super(message);
+        this.name = "MisuseError";
+    }
+}

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/http/client.js

@@ -0,0 +1,124 @@
+import { fetch, Request } from "@libsql/isomorphic-fetch";
+import { Client } from "../client.js";
+import { ClientError, ClosedError, ProtocolVersionError } from "../errors.js";
+import { HttpStream } from "./stream.js";
+export const checkEndpoints = [
+    {
+        versionPath: "v3-protobuf",
+        pipelinePath: "v3-protobuf/pipeline",
+        cursorPath: "v3-protobuf/cursor",
+        version: 3,
+        encoding: "protobuf",
+    },
+    /*
+    {
+        versionPath: "v3",
+        pipelinePath: "v3/pipeline",
+        cursorPath: "v3/cursor",
+        version: 3,
+        encoding: "json",
+    },
+    */
+];
+const fallbackEndpoint = {
+    versionPath: "v2",
+    pipelinePath: "v2/pipeline",
+    cursorPath: undefined,
+    version: 2,
+    encoding: "json",
+};
+/** A client for the Hrana protocol over HTTP. */
+export class HttpClient extends Client {
+    #url;
+    #jwt;
+    #fetch;
+    #closed;
+    #streams;
+    /** @private */
+    _endpointPromise;
+    /** @private */
+    _endpoint;
+    /** @private */
+    constructor(url, jwt, customFetch, protocolVersion = 2) {
+        super();
+        this.#url = url;
+        this.#jwt = jwt;
+        this.#fetch = customFetch ?? fetch;
+        this.#closed = undefined;
+        this.#streams = new Set();
+        if (protocolVersion == 3) {
+            this._endpointPromise = findEndpoint(this.#fetch, this.#url);
+            this._endpointPromise.then((endpoint) => this._endpoint = endpoint, (error) => this.#setClosed(error));
+        }
+        else {
+            this._endpointPromise = Promise.resolve(fallbackEndpoint);
+            this._endpointPromise.then((endpoint) => this._endpoint = endpoint, (error) => this.#setClosed(error));
+        }
+    }
+    /** Get the protocol version supported by the server. */
+    async getVersion() {
+        if (this._endpoint !== undefined) {
+            return this._endpoint.version;
+        }
+        return (await this._endpointPromise).version;
+    }
+    // Make sure that the negotiated version is at least `minVersion`.
+    /** @private */
+    _ensureVersion(minVersion, feature) {
+        if (minVersion <= fallbackEndpoint.version) {
+            return;
+        }
+        else if (this._endpoint === undefined) {
+            throw new ProtocolVersionError(`${feature} is supported only on protocol version ${minVersion} and higher, ` +
+                "but the version supported by the HTTP server is not yet known. " +
+                "Use Client.getVersion() to wait until the version is available.");
+        }
+        else if (this._endpoint.version < minVersion) {
+            throw new ProtocolVersionError(`${feature} is supported only on protocol version ${minVersion} and higher, ` +
+                `but the HTTP server only supports version ${this._endpoint.version}.`);
+        }
+    }
+    /** Open a {@link HttpStream}, a stream for executing SQL statements. */
+    openStream() {
+        if (this.#closed !== undefined) {
+            throw new ClosedError("Client is closed", this.#closed);
+        }
+        const stream = new HttpStream(this, this.#url, this.#jwt, this.#fetch);
+        this.#streams.add(stream);
+        return stream;
+    }
+    /** @private */
+    _streamClosed(stream) {
+        this.#streams.delete(stream);
+    }
+    /** Close the client and all its streams. */
+    close() {
+        this.#setClosed(new ClientError("Client was manually closed"));
+    }
+    /** True if the client is closed. */
+    get closed() {
+        return this.#closed !== undefined;
+    }
+    #setClosed(error) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        this.#closed = error;
+        for (const stream of Array.from(this.#streams)) {
+            stream._setClosed(new ClosedError("Client was closed", error));
+        }
+    }
+}
+async function findEndpoint(customFetch, clientUrl) {
+    const fetch = customFetch;
+    for (const endpoint of checkEndpoints) {
+        const url = new URL(endpoint.versionPath, clientUrl);
+        const request = new Request(url.toString(), { method: "GET" });
+        const response = await fetch(request);
+        await response.arrayBuffer();
+        if (response.ok) {
+            return endpoint;
+        }
+    }
+    return fallbackEndpoint;
+}

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/http/cursor.js

@@ -0,0 +1,135 @@
+import { ByteQueue } from "../byte_queue.js";
+import { Cursor } from "../cursor.js";
+import * as jsond from "../encoding/json/decode.js";
+import * as protobufd from "../encoding/protobuf/decode.js";
+import { ClientError, ClosedError, ProtoError, InternalError } from "../errors.js";
+import { impossible } from "../util.js";
+import { CursorRespBody as json_CursorRespBody } from "./json_decode.js";
+import { CursorRespBody as protobuf_CursorRespBody } from "./protobuf_decode.js";
+import { CursorEntry as json_CursorEntry } from "../shared/json_decode.js";
+import { CursorEntry as protobuf_CursorEntry } from "../shared/protobuf_decode.js";
+export class HttpCursor extends Cursor {
+    #stream;
+    #encoding;
+    #reader;
+    #queue;
+    #closed;
+    #done;
+    /** @private */
+    constructor(stream, encoding) {
+        super();
+        this.#stream = stream;
+        this.#encoding = encoding;
+        this.#reader = undefined;
+        this.#queue = new ByteQueue(16 * 1024);
+        this.#closed = undefined;
+        this.#done = false;
+    }
+    async open(response) {
+        if (response.body === null) {
+            throw new ProtoError("No response body for cursor request");
+        }
+        this.#reader = response.body.getReader();
+        const respBody = await this.#nextItem(json_CursorRespBody, protobuf_CursorRespBody);
+        if (respBody === undefined) {
+            throw new ProtoError("Empty response to cursor request");
+        }
+        return respBody;
+    }
+    /** Fetch the next entry from the cursor. */
+    next() {
+        return this.#nextItem(json_CursorEntry, protobuf_CursorEntry);
+    }
+    /** Close the cursor. */
+    close() {
+        this._setClosed(new ClientError("Cursor was manually closed"));
+    }
+    /** @private */
+    _setClosed(error) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        this.#closed = error;
+        this.#stream._cursorClosed(this);
+        if (this.#reader !== undefined) {
+            this.#reader.cancel();
+        }
+    }
+    /** True if the cursor is closed. */
+    get closed() {
+        return this.#closed !== undefined;
+    }
+    async #nextItem(jsonFun, protobufDef) {
+        for (;;) {
+            if (this.#done) {
+                return undefined;
+            }
+            else if (this.#closed !== undefined) {
+                throw new ClosedError("Cursor is closed", this.#closed);
+            }
+            if (this.#encoding === "json") {
+                const jsonData = this.#parseItemJson();
+                if (jsonData !== undefined) {
+                    const jsonText = new TextDecoder().decode(jsonData);
+                    const jsonValue = JSON.parse(jsonText);
+                    return jsond.readJsonObject(jsonValue, jsonFun);
+                }
+            }
+            else if (this.#encoding === "protobuf") {
+                const protobufData = this.#parseItemProtobuf();
+                if (protobufData !== undefined) {
+                    return protobufd.readProtobufMessage(protobufData, protobufDef);
+                }
+            }
+            else {
+                throw impossible(this.#encoding, "Impossible encoding");
+            }
+            if (this.#reader === undefined) {
+                throw new InternalError("Attempted to read from HTTP cursor before it was opened");
+            }
+            const { value, done } = await this.#reader.read();
+            if (done && this.#queue.length === 0) {
+                this.#done = true;
+            }
+            else if (done) {
+                throw new ProtoError("Unexpected end of cursor stream");
+            }
+            else {
+                this.#queue.push(value);
+            }
+        }
+    }
+    #parseItemJson() {
+        const data = this.#queue.data();
+        const newlineByte = 10;
+        const newlinePos = data.indexOf(newlineByte);
+        if (newlinePos < 0) {
+            return undefined;
+        }
+        const jsonData = data.slice(0, newlinePos);
+        this.#queue.shift(newlinePos + 1);
+        return jsonData;
+    }
+    #parseItemProtobuf() {
+        const data = this.#queue.data();
+        let varintValue = 0;
+        let varintLength = 0;
+        for (;;) {
+            if (varintLength >= data.byteLength) {
+                return undefined;
+            }
+            const byte = data[varintLength];
+            varintValue |= (byte & 0x7f) << (7 * varintLength);
+            varintLength += 1;
+            if (!(byte & 0x80)) {
+                break;
+            }
+        }
+        if (data.byteLength < varintLength + varintValue) {
+            return undefined;
+        }
+        const protobufData = data.slice(varintLength, varintLength + varintValue);
+        this.#queue.shift(varintLength + varintValue);
+        return protobufData;
+    }
+}

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/http/json_decode.js

@@ -0,0 +1,62 @@
+import { ProtoError } from "../errors.js";
+import * as d from "../encoding/json/decode.js";
+import { Error, StmtResult, BatchResult, DescribeResult } from "../shared/json_decode.js";
+export function PipelineRespBody(obj) {
+    const baton = d.stringOpt(obj["baton"]);
+    const baseUrl = d.stringOpt(obj["base_url"]);
+    const results = d.arrayObjectsMap(obj["results"], StreamResult);
+    return { baton, baseUrl, results };
+}
+function StreamResult(obj) {
+    const type = d.string(obj["type"]);
+    if (type === "ok") {
+        const response = StreamResponse(d.object(obj["response"]));
+        return { type: "ok", response };
+    }
+    else if (type === "error") {
+        const error = Error(d.object(obj["error"]));
+        return { type: "error", error };
+    }
+    else {
+        throw new ProtoError("Unexpected type of StreamResult");
+    }
+}
+function StreamResponse(obj) {
+    const type = d.string(obj["type"]);
+    if (type === "close") {
+        return { type: "close" };
+    }
+    else if (type === "execute") {
+        const result = StmtResult(d.object(obj["result"]));
+        return { type: "execute", result };
+    }
+    else if (type === "batch") {
+        const result = BatchResult(d.object(obj["result"]));
+        return { type: "batch", result };
+    }
+    else if (type === "sequence") {
+        return { type: "sequence" };
+    }
+    else if (type === "describe") {
+        const result = DescribeResult(d.object(obj["result"]));
+        return { type: "describe", result };
+    }
+    else if (type === "store_sql") {
+        return { type: "store_sql" };
+    }
+    else if (type === "close_sql") {
+        return { type: "close_sql" };
+    }
+    else if (type === "get_autocommit") {
+        const isAutocommit = d.boolean(obj["is_autocommit"]);
+        return { type: "get_autocommit", isAutocommit };
+    }
+    else {
+        throw new ProtoError("Unexpected type of StreamResponse");
+    }
+}
+export function CursorRespBody(obj) {
+    const baton = d.stringOpt(obj["baton"]);
+    const baseUrl = d.stringOpt(obj["base_url"]);
+    return { baton, baseUrl };
+}

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/http/json_encode.js

@@ -0,0 +1,55 @@
+import { Stmt, Batch } from "../shared/json_encode.js";
+import { impossible } from "../util.js";
+export function PipelineReqBody(w, msg) {
+    if (msg.baton !== undefined) {
+        w.string("baton", msg.baton);
+    }
+    w.arrayObjects("requests", msg.requests, StreamRequest);
+}
+function StreamRequest(w, msg) {
+    w.stringRaw("type", msg.type);
+    if (msg.type === "close") {
+        // do nothing
+    }
+    else if (msg.type === "execute") {
+        w.object("stmt", msg.stmt, Stmt);
+    }
+    else if (msg.type === "batch") {
+        w.object("batch", msg.batch, Batch);
+    }
+    else if (msg.type === "sequence") {
+        if (msg.sql !== undefined) {
+            w.string("sql", msg.sql);
+        }
+        if (msg.sqlId !== undefined) {
+            w.number("sql_id", msg.sqlId);
+        }
+    }
+    else if (msg.type === "describe") {
+        if (msg.sql !== undefined) {
+            w.string("sql", msg.sql);
+        }
+        if (msg.sqlId !== undefined) {
+            w.number("sql_id", msg.sqlId);
+        }
+    }
+    else if (msg.type === "store_sql") {
+        w.number("sql_id", msg.sqlId);
+        w.string("sql", msg.sql);
+    }
+    else if (msg.type === "close_sql") {
+        w.number("sql_id", msg.sqlId);
+    }
+    else if (msg.type === "get_autocommit") {
+        // do nothing
+    }
+    else {
+        throw impossible(msg, "Impossible type of StreamRequest");
+    }
+}
+export function CursorReqBody(w, msg) {
+    if (msg.baton !== undefined) {
+        w.string("baton", msg.baton);
+    }
+    w.object("batch", msg.batch, Batch);
+}

package/.output/server/node_modules/@libsql/hrana-client/lib-esm/http/protobuf_decode.js

@@ -0,0 +1,44 @@
+import { Error, StmtResult, BatchResult, DescribeResult } from "../shared/protobuf_decode.js";
+export const PipelineRespBody = {
+    default() { return { baton: undefined, baseUrl: undefined, results: [] }; },
+    1(r, msg) { msg.baton = r.string(); },
+    2(r, msg) { msg.baseUrl = r.string(); },
+    3(r, msg) { msg.results.push(r.message(StreamResult)); },
+};
+const StreamResult = {
+    default() { return { type: "none" }; },
+    1(r) { return { type: "ok", response: r.message(StreamResponse) }; },
+    2(r) { return { type: "error", error: r.message(Error) }; },
+};
+const StreamResponse = {
+    default() { return { type: "none" }; },
+    1(r) { return { type: "close" }; },
+    2(r) { return r.message(ExecuteStreamResp); },
+    3(r) { return r.message(BatchStreamResp); },
+    4(r) { return { type: "sequence" }; },
+    5(r) { return r.message(DescribeStreamResp); },
+    6(r) { return { type: "store_sql" }; },
+    7(r) { return { type: "close_sql" }; },
+    8(r) { return r.message(GetAutocommitStreamResp); },
+};
+const ExecuteStreamResp = {
+    default() { return { type: "execute", result: StmtResult.default() }; },
+    1(r, msg) { msg.result = r.message(StmtResult); },
+};
+const BatchStreamResp = {
+    default() { return { type: "batch", result: BatchResult.default() }; },
+    1(r, msg) { msg.result = r.message(BatchResult); },
+};
+const DescribeStreamResp = {
+    default() { return { type: "describe", result: DescribeResult.default() }; },
+    1(r, msg) { msg.result = r.message(DescribeResult); },
+};
+const GetAutocommitStreamResp = {
+    default() { return { type: "get_autocommit", isAutocommit: false }; },
+    1(r, msg) { msg.isAutocommit = r.bool(); },
+};
+export const CursorRespBody = {
+    default() { return { baton: undefined, baseUrl: undefined }; },
+    1(r, msg) { msg.baton = r.string(); },
+    2(r, msg) { msg.baseUrl = r.string(); },
+};