orcaq 1.0.33 → 1.1.2

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

@@ -0,0 +1,78 @@
+import { Stmt, Batch } from "../shared/protobuf_encode.js";
+import { impossible } from "../util.js";
+export function PipelineReqBody(w, msg) {
+    if (msg.baton !== undefined) {
+        w.string(1, msg.baton);
+    }
+    for (const req of msg.requests) {
+        w.message(2, req, StreamRequest);
+    }
+}
+function StreamRequest(w, msg) {
+    if (msg.type === "close") {
+        w.message(1, msg, CloseStreamReq);
+    }
+    else if (msg.type === "execute") {
+        w.message(2, msg, ExecuteStreamReq);
+    }
+    else if (msg.type === "batch") {
+        w.message(3, msg, BatchStreamReq);
+    }
+    else if (msg.type === "sequence") {
+        w.message(4, msg, SequenceStreamReq);
+    }
+    else if (msg.type === "describe") {
+        w.message(5, msg, DescribeStreamReq);
+    }
+    else if (msg.type === "store_sql") {
+        w.message(6, msg, StoreSqlStreamReq);
+    }
+    else if (msg.type === "close_sql") {
+        w.message(7, msg, CloseSqlStreamReq);
+    }
+    else if (msg.type === "get_autocommit") {
+        w.message(8, msg, GetAutocommitStreamReq);
+    }
+    else {
+        throw impossible(msg, "Impossible type of StreamRequest");
+    }
+}
+function CloseStreamReq(_w, _msg) {
+}
+function ExecuteStreamReq(w, msg) {
+    w.message(1, msg.stmt, Stmt);
+}
+function BatchStreamReq(w, msg) {
+    w.message(1, msg.batch, Batch);
+}
+function SequenceStreamReq(w, msg) {
+    if (msg.sql !== undefined) {
+        w.string(1, msg.sql);
+    }
+    if (msg.sqlId !== undefined) {
+        w.int32(2, msg.sqlId);
+    }
+}
+function DescribeStreamReq(w, msg) {
+    if (msg.sql !== undefined) {
+        w.string(1, msg.sql);
+    }
+    if (msg.sqlId !== undefined) {
+        w.int32(2, msg.sqlId);
+    }
+}
+function StoreSqlStreamReq(w, msg) {
+    w.int32(1, msg.sqlId);
+    w.string(2, msg.sql);
+}
+function CloseSqlStreamReq(w, msg) {
+    w.int32(1, msg.sqlId);
+}
+function GetAutocommitStreamReq(_w, _msg) {
+}
+export function CursorReqBody(w, msg) {
+    if (msg.baton !== undefined) {
+        w.string(1, msg.baton);
+    }
+    w.message(2, msg.batch, Batch);
+}

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

@@ -0,0 +1,363 @@
+import { Request, Headers } from "@libsql/isomorphic-fetch";
+import { ClientError, HttpServerError, ProtocolVersionError, ProtoError, ClosedError, InternalError, } from "../errors.js";
+import { readJsonObject, writeJsonObject, readProtobufMessage, writeProtobufMessage, } from "../encoding/index.js";
+import { IdAlloc } from "../id_alloc.js";
+import { Queue } from "../queue.js";
+import { queueMicrotask } from "../queue_microtask.js";
+import { errorFromProto } from "../result.js";
+import { Sql } from "../sql.js";
+import { Stream } from "../stream.js";
+import { impossible } from "../util.js";
+import { HttpCursor } from "./cursor.js";
+import { PipelineReqBody as json_PipelineReqBody } from "./json_encode.js";
+import { PipelineReqBody as protobuf_PipelineReqBody } from "./protobuf_encode.js";
+import { CursorReqBody as json_CursorReqBody } from "./json_encode.js";
+import { CursorReqBody as protobuf_CursorReqBody } from "./protobuf_encode.js";
+import { PipelineRespBody as json_PipelineRespBody } from "./json_decode.js";
+import { PipelineRespBody as protobuf_PipelineRespBody } from "./protobuf_decode.js";
+export class HttpStream extends Stream {
+    #client;
+    #baseUrl;
+    #jwt;
+    #fetch;
+    #baton;
+    #queue;
+    #flushing;
+    #cursor;
+    #closing;
+    #closeQueued;
+    #closed;
+    #sqlIdAlloc;
+    /** @private */
+    constructor(client, baseUrl, jwt, customFetch) {
+        super(client.intMode);
+        this.#client = client;
+        this.#baseUrl = baseUrl.toString();
+        this.#jwt = jwt;
+        this.#fetch = customFetch;
+        this.#baton = undefined;
+        this.#queue = new Queue();
+        this.#flushing = false;
+        this.#closing = false;
+        this.#closeQueued = false;
+        this.#closed = undefined;
+        this.#sqlIdAlloc = new IdAlloc();
+    }
+    /** Get the {@link HttpClient} object that this stream belongs to. */
+    client() {
+        return this.#client;
+    }
+    /** @private */
+    _sqlOwner() {
+        return this;
+    }
+    /** Cache a SQL text on the server. */
+    storeSql(sql) {
+        const sqlId = this.#sqlIdAlloc.alloc();
+        this.#sendStreamRequest({ type: "store_sql", sqlId, sql }).then(() => undefined, (error) => this._setClosed(error));
+        return new Sql(this, sqlId);
+    }
+    /** @private */
+    _closeSql(sqlId) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        this.#sendStreamRequest({ type: "close_sql", sqlId }).then(() => this.#sqlIdAlloc.free(sqlId), (error) => this._setClosed(error));
+    }
+    /** @private */
+    _execute(stmt) {
+        return this.#sendStreamRequest({ type: "execute", stmt }).then((response) => {
+            return response.result;
+        });
+    }
+    /** @private */
+    _batch(batch) {
+        return this.#sendStreamRequest({ type: "batch", batch }).then((response) => {
+            return response.result;
+        });
+    }
+    /** @private */
+    _describe(protoSql) {
+        return this.#sendStreamRequest({
+            type: "describe",
+            sql: protoSql.sql,
+            sqlId: protoSql.sqlId
+        }).then((response) => {
+            return response.result;
+        });
+    }
+    /** @private */
+    _sequence(protoSql) {
+        return this.#sendStreamRequest({
+            type: "sequence",
+            sql: protoSql.sql,
+            sqlId: protoSql.sqlId,
+        }).then((_response) => {
+            return undefined;
+        });
+    }
+    /** Check whether the SQL connection underlying this stream is in autocommit state (i.e., outside of an
+     * explicit transaction). This requires protocol version 3 or higher.
+     */
+    getAutocommit() {
+        this.#client._ensureVersion(3, "getAutocommit()");
+        return this.#sendStreamRequest({
+            type: "get_autocommit",
+        }).then((response) => {
+            return response.isAutocommit;
+        });
+    }
+    #sendStreamRequest(request) {
+        return new Promise((responseCallback, errorCallback) => {
+            this.#pushToQueue({ type: "pipeline", request, responseCallback, errorCallback });
+        });
+    }
+    /** @private */
+    _openCursor(batch) {
+        return new Promise((cursorCallback, errorCallback) => {
+            this.#pushToQueue({ type: "cursor", batch, cursorCallback, errorCallback });
+        });
+    }
+    /** @private */
+    _cursorClosed(cursor) {
+        if (cursor !== this.#cursor) {
+            throw new InternalError("Cursor was closed, but it was not associated with the stream");
+        }
+        this.#cursor = undefined;
+        queueMicrotask(() => this.#flushQueue());
+    }
+    /** Immediately close the stream. */
+    close() {
+        this._setClosed(new ClientError("Stream was manually closed"));
+    }
+    /** Gracefully close the stream. */
+    closeGracefully() {
+        this.#closing = true;
+        queueMicrotask(() => this.#flushQueue());
+    }
+    /** True if the stream is closed. */
+    get closed() {
+        return this.#closed !== undefined || this.#closing;
+    }
+    /** @private */
+    _setClosed(error) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        this.#closed = error;
+        if (this.#cursor !== undefined) {
+            this.#cursor._setClosed(error);
+        }
+        this.#client._streamClosed(this);
+        for (;;) {
+            const entry = this.#queue.shift();
+            if (entry !== undefined) {
+                entry.errorCallback(error);
+            }
+            else {
+                break;
+            }
+        }
+        if ((this.#baton !== undefined || this.#flushing) && !this.#closeQueued) {
+            this.#queue.push({
+                type: "pipeline",
+                request: { type: "close" },
+                responseCallback: () => undefined,
+                errorCallback: () => undefined,
+            });
+            this.#closeQueued = true;
+            queueMicrotask(() => this.#flushQueue());
+        }
+    }
+    #pushToQueue(entry) {
+        if (this.#closed !== undefined) {
+            throw new ClosedError("Stream is closed", this.#closed);
+        }
+        else if (this.#closing) {
+            throw new ClosedError("Stream is closing", undefined);
+        }
+        else {
+            this.#queue.push(entry);
+            queueMicrotask(() => this.#flushQueue());
+        }
+    }
+    #flushQueue() {
+        if (this.#flushing || this.#cursor !== undefined) {
+            return;
+        }
+        if (this.#closing && this.#queue.length === 0) {
+            this._setClosed(new ClientError("Stream was gracefully closed"));
+            return;
+        }
+        const endpoint = this.#client._endpoint;
+        if (endpoint === undefined) {
+            this.#client._endpointPromise.then(() => this.#flushQueue(), (error) => this._setClosed(error));
+            return;
+        }
+        const firstEntry = this.#queue.shift();
+        if (firstEntry === undefined) {
+            return;
+        }
+        else if (firstEntry.type === "pipeline") {
+            const pipeline = [firstEntry];
+            for (;;) {
+                const entry = this.#queue.first();
+                if (entry !== undefined && entry.type === "pipeline") {
+                    pipeline.push(entry);
+                    this.#queue.shift();
+                }
+                else if (entry === undefined && this.#closing && !this.#closeQueued) {
+                    pipeline.push({
+                        type: "pipeline",
+                        request: { type: "close" },
+                        responseCallback: () => undefined,
+                        errorCallback: () => undefined,
+                    });
+                    this.#closeQueued = true;
+                    break;
+                }
+                else {
+                    break;
+                }
+            }
+            this.#flushPipeline(endpoint, pipeline);
+        }
+        else if (firstEntry.type === "cursor") {
+            this.#flushCursor(endpoint, firstEntry);
+        }
+        else {
+            throw impossible(firstEntry, "Impossible type of QueueEntry");
+        }
+    }
+    #flushPipeline(endpoint, pipeline) {
+        this.#flush(() => this.#createPipelineRequest(pipeline, endpoint), (resp) => decodePipelineResponse(resp, endpoint.encoding), (respBody) => respBody.baton, (respBody) => respBody.baseUrl, (respBody) => handlePipelineResponse(pipeline, respBody), (error) => pipeline.forEach((entry) => entry.errorCallback(error)));
+    }
+    #flushCursor(endpoint, entry) {
+        const cursor = new HttpCursor(this, endpoint.encoding);
+        this.#cursor = cursor;
+        this.#flush(() => this.#createCursorRequest(entry, endpoint), (resp) => cursor.open(resp), (respBody) => respBody.baton, (respBody) => respBody.baseUrl, (_respBody) => entry.cursorCallback(cursor), (error) => entry.errorCallback(error));
+    }
+    #flush(createRequest, decodeResponse, getBaton, getBaseUrl, handleResponse, handleError) {
+        let promise;
+        try {
+            const request = createRequest();
+            const fetch = this.#fetch;
+            promise = fetch(request);
+        }
+        catch (error) {
+            promise = Promise.reject(error);
+        }
+        this.#flushing = true;
+        promise.then((resp) => {
+            if (!resp.ok) {
+                return errorFromResponse(resp).then((error) => {
+                    throw error;
+                });
+            }
+            return decodeResponse(resp);
+        }).then((r) => {
+            this.#baton = getBaton(r);
+            this.#baseUrl = getBaseUrl(r) ?? this.#baseUrl;
+            handleResponse(r);
+        }).catch((error) => {
+            this._setClosed(error);
+            handleError(error);
+        }).finally(() => {
+            this.#flushing = false;
+            this.#flushQueue();
+        });
+    }
+    #createPipelineRequest(pipeline, endpoint) {
+        return this.#createRequest(new URL(endpoint.pipelinePath, this.#baseUrl), {
+            baton: this.#baton,
+            requests: pipeline.map((entry) => entry.request),
+        }, endpoint.encoding, json_PipelineReqBody, protobuf_PipelineReqBody);
+    }
+    #createCursorRequest(entry, endpoint) {
+        if (endpoint.cursorPath === undefined) {
+            throw new ProtocolVersionError("Cursors are supported only on protocol version 3 and higher, " +
+                `but the HTTP server only supports version ${endpoint.version}.`);
+        }
+        return this.#createRequest(new URL(endpoint.cursorPath, this.#baseUrl), {
+            baton: this.#baton,
+            batch: entry.batch,
+        }, endpoint.encoding, json_CursorReqBody, protobuf_CursorReqBody);
+    }
+    #createRequest(url, reqBody, encoding, jsonFun, protobufFun) {
+        let bodyData;
+        let contentType;
+        if (encoding === "json") {
+            bodyData = writeJsonObject(reqBody, jsonFun);
+            contentType = "application/json";
+        }
+        else if (encoding === "protobuf") {
+            bodyData = writeProtobufMessage(reqBody, protobufFun);
+            contentType = "application/x-protobuf";
+        }
+        else {
+            throw impossible(encoding, "Impossible encoding");
+        }
+        const headers = new Headers();
+        headers.set("content-type", contentType);
+        if (this.#jwt !== undefined) {
+            headers.set("authorization", `Bearer ${this.#jwt}`);
+        }
+        return new Request(url.toString(), { method: "POST", headers, body: bodyData });
+    }
+}
+function handlePipelineResponse(pipeline, respBody) {
+    if (respBody.results.length !== pipeline.length) {
+        throw new ProtoError("Server returned unexpected number of pipeline results");
+    }
+    for (let i = 0; i < pipeline.length; ++i) {
+        const result = respBody.results[i];
+        const entry = pipeline[i];
+        if (result.type === "ok") {
+            if (result.response.type !== entry.request.type) {
+                throw new ProtoError("Received unexpected type of response");
+            }
+            entry.responseCallback(result.response);
+        }
+        else if (result.type === "error") {
+            entry.errorCallback(errorFromProto(result.error));
+        }
+        else if (result.type === "none") {
+            throw new ProtoError("Received unrecognized type of StreamResult");
+        }
+        else {
+            throw impossible(result, "Received impossible type of StreamResult");
+        }
+    }
+}
+async function decodePipelineResponse(resp, encoding) {
+    if (encoding === "json") {
+        const respJson = await resp.json();
+        return readJsonObject(respJson, json_PipelineRespBody);
+    }
+    if (encoding === "protobuf") {
+        const respData = await resp.arrayBuffer();
+        return readProtobufMessage(new Uint8Array(respData), protobuf_PipelineRespBody);
+    }
+    await resp.body?.cancel();
+    throw impossible(encoding, "Impossible encoding");
+}
+async function errorFromResponse(resp) {
+    const respType = resp.headers.get("content-type") ?? "text/plain";
+    let message = `Server returned HTTP status ${resp.status}`;
+    if (respType === "application/json") {
+        const respBody = await resp.json();
+        if ("message" in respBody) {
+            return errorFromProto(respBody);
+        }
+        return new HttpServerError(message, resp.status);
+    }
+    if (respType === "text/plain") {
+        const respBody = (await resp.text()).trim();
+        if (respBody !== "") {
+            message += `: ${respBody}`;
+        }
+        return new HttpServerError(message, resp.status);
+    }
+    await resp.body?.cancel();
+    return new HttpServerError(message, resp.status);
+}

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

@@ -0,0 +1,47 @@
+import { InternalError } from "./errors.js";
+// An allocator of non-negative integer ids.
+//
+// This clever data structure has these "ideal" properties:
+// - It consumes memory proportional to the number of used ids (which is optimal).
+// - All operations are O(1) time.
+// - The allocated ids are small (with a slight modification, we could always provide the smallest possible
+// id).
+export class IdAlloc {
+    // Set of all allocated ids
+    #usedIds;
+    // Set of all free ids lower than `#usedIds.size`
+    #freeIds;
+    constructor() {
+        this.#usedIds = new Set();
+        this.#freeIds = new Set();
+    }
+    // Returns an id that was free, and marks it as used.
+    alloc() {
+        // this "loop" is just a way to pick an arbitrary element from the `#freeIds` set
+        for (const freeId of this.#freeIds) {
+            this.#freeIds.delete(freeId);
+            this.#usedIds.add(freeId);
+            // maintain the invariant of `#freeIds`
+            if (!this.#usedIds.has(this.#usedIds.size - 1)) {
+                this.#freeIds.add(this.#usedIds.size - 1);
+            }
+            return freeId;
+        }
+        // the `#freeIds` set is empty, so there are no free ids lower than `#usedIds.size`
+        // this means that `#usedIds` is a set that contains all numbers from 0 to `#usedIds.size - 1`,
+        // so `#usedIds.size` is free
+        const freeId = this.#usedIds.size;
+        this.#usedIds.add(freeId);
+        return freeId;
+    }
+    free(id) {
+        if (!this.#usedIds.delete(id)) {
+            throw new InternalError("Freeing an id that is not allocated");
+        }
+        // maintain the invariant of `#freeIds`
+        this.#freeIds.delete(this.#usedIds.size);
+        if (id < this.#usedIds.size) {
+            this.#freeIds.add(id);
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+import { WebSocket } from "@libsql/isomorphic-ws";
+import { subprotocolsV2, subprotocolsV3 } from "./ws/client.js";
+import { WebSocketUnsupportedError } from "./errors.js";
+import { HttpClient } from "./http/client.js";
+import { WsClient } from "./ws/client.js";
+export { WebSocket } from "@libsql/isomorphic-ws";
+export { fetch, Request, Headers } from "@libsql/isomorphic-fetch";
+export { Client } from "./client.js";
+export * from "./errors.js";
+export { Batch, BatchStep, BatchCond } from "./batch.js";
+export { parseLibsqlUrl } from "./libsql_url.js";
+export { Sql } from "./sql.js";
+export { Stmt } from "./stmt.js";
+export { Stream } from "./stream.js";
+export { HttpClient } from "./http/client.js";
+export { HttpStream } from "./http/stream.js";
+export { WsClient } from "./ws/client.js";
+export { WsStream } from "./ws/stream.js";
+/** Open a Hrana client over WebSocket connected to the given `url`. */
+export function openWs(url, jwt, protocolVersion = 2) {
+    if (typeof WebSocket === "undefined") {
+        throw new WebSocketUnsupportedError("WebSockets are not supported in this environment");
+    }
+    var subprotocols = undefined;
+    if (protocolVersion == 3) {
+        subprotocols = Array.from(subprotocolsV3.keys());
+    }
+    else {
+        subprotocols = Array.from(subprotocolsV2.keys());
+    }
+    const socket = new WebSocket(url, subprotocols);
+    return new WsClient(socket, jwt);
+}
+/** Open a Hrana client over HTTP connected to the given `url`.
+ *
+ * If the `customFetch` argument is passed and not `undefined`, it is used in place of the `fetch` function
+ * from `@libsql/isomorphic-fetch`. This function is always called with a `Request` object from
+ * `@libsql/isomorphic-fetch`.
+ */
+export function openHttp(url, jwt, customFetch, protocolVersion = 2) {
+    return new HttpClient(url instanceof URL ? url : new URL(url), jwt, customFetch, protocolVersion);
+}

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

@@ -0,0 +1,75 @@
+import { LibsqlUrlParseError } from "./errors.js";
+;
+/** Parses a URL compatible with the libsql client (`@libsql/client`). This URL may have the "libsql:" scheme
+ * and may contain query parameters. */
+export function parseLibsqlUrl(urlStr) {
+    const url = new URL(urlStr);
+    let authToken = undefined;
+    let tls = undefined;
+    for (const [key, value] of url.searchParams.entries()) {
+        if (key === "authToken") {
+            authToken = value;
+        }
+        else if (key === "tls") {
+            if (value === "0") {
+                tls = false;
+            }
+            else if (value === "1") {
+                tls = true;
+            }
+            else {
+                throw new LibsqlUrlParseError(`Unknown value for the "tls" query argument: ${JSON.stringify(value)}`);
+            }
+        }
+        else {
+            throw new LibsqlUrlParseError(`Unknown URL query argument ${JSON.stringify(key)}`);
+        }
+    }
+    let hranaWsScheme;
+    let hranaHttpScheme;
+    if ((url.protocol === "http:" || url.protocol === "ws:") && (tls === true)) {
+        throw new LibsqlUrlParseError(`A ${JSON.stringify(url.protocol)} URL cannot opt into TLS using ?tls=1`);
+    }
+    else if ((url.protocol === "https:" || url.protocol === "wss:") && (tls === false)) {
+        throw new LibsqlUrlParseError(`A ${JSON.stringify(url.protocol)} URL cannot opt out of TLS using ?tls=0`);
+    }
+    if (url.protocol === "http:" || url.protocol === "https:") {
+        hranaHttpScheme = url.protocol;
+    }
+    else if (url.protocol === "ws:" || url.protocol === "wss:") {
+        hranaWsScheme = url.protocol;
+    }
+    else if (url.protocol === "libsql:") {
+        if (tls === false) {
+            if (!url.port) {
+                throw new LibsqlUrlParseError(`A "libsql:" URL with ?tls=0 must specify an explicit port`);
+            }
+            hranaHttpScheme = "http:";
+            hranaWsScheme = "ws:";
+        }
+        else {
+            hranaHttpScheme = "https:";
+            hranaWsScheme = "wss:";
+        }
+    }
+    else {
+        throw new LibsqlUrlParseError(`This client does not support ${JSON.stringify(url.protocol)} URLs. ` +
+            'Please use a "libsql:", "ws:", "wss:", "http:" or "https:" URL instead.');
+    }
+    if (url.username || url.password) {
+        throw new LibsqlUrlParseError("This client does not support HTTP Basic authentication with a username and password. " +
+            'You can authenticate using a token passed in the "authToken" URL query parameter.');
+    }
+    if (url.hash) {
+        throw new LibsqlUrlParseError("URL fragments are not supported");
+    }
+    let hranaPath = url.pathname;
+    if (hranaPath === "/") {
+        hranaPath = "";
+    }
+    const hranaWsUrl = hranaWsScheme !== undefined
+        ? `${hranaWsScheme}//${url.host}${hranaPath}` : undefined;
+    const hranaHttpUrl = hranaHttpScheme !== undefined
+        ? `${hranaHttpScheme}//${url.host}${hranaPath}` : undefined;
+    return { hranaWsUrl, hranaHttpUrl, authToken };
+}

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

@@ -0,0 +1,26 @@
+export class Queue {
+    #pushStack;
+    #shiftStack;
+    constructor() {
+        this.#pushStack = [];
+        this.#shiftStack = [];
+    }
+    get length() {
+        return this.#pushStack.length + this.#shiftStack.length;
+    }
+    push(elem) {
+        this.#pushStack.push(elem);
+    }
+    shift() {
+        if (this.#shiftStack.length === 0 && this.#pushStack.length > 0) {
+            this.#shiftStack = this.#pushStack.reverse();
+            this.#pushStack = [];
+        }
+        return this.#shiftStack.pop();
+    }
+    first() {
+        return this.#shiftStack.length !== 0
+            ? this.#shiftStack[this.#shiftStack.length - 1]
+            : this.#pushStack[0];
+    }
+}

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

@@ -0,0 +1,13 @@
+// queueMicrotask() ponyfill
+// https://github.com/libsql/libsql-client-ts/issues/47
+let _queueMicrotask;
+if (typeof queueMicrotask !== "undefined") {
+    _queueMicrotask = queueMicrotask;
+}
+else {
+    const resolved = Promise.resolve();
+    _queueMicrotask = (callback) => {
+        resolved.then(callback);
+    };
+}
+export { _queueMicrotask as queueMicrotask };