Initial commit: New MoreminiMore website with fresh design

node_modules/@libsql/hrana-client/lib-cjs/ws/client.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsClient = exports.subprotocolsV3 = exports.subprotocolsV2 = void 0;
+const client_js_1 = require("../client.js");
+const index_js_1 = require("../encoding/index.js");
+const errors_js_1 = require("../errors.js");
+const id_alloc_js_1 = require("../id_alloc.js");
+const result_js_1 = require("../result.js");
+const sql_js_1 = require("../sql.js");
+const util_js_1 = require("../util.js");
+const stream_js_1 = require("./stream.js");
+const json_encode_js_1 = require("./json_encode.js");
+const protobuf_encode_js_1 = require("./protobuf_encode.js");
+const json_decode_js_1 = require("./json_decode.js");
+const protobuf_decode_js_1 = require("./protobuf_decode.js");
+exports.subprotocolsV2 = new Map([
+    ["hrana2", { version: 2, encoding: "json" }],
+    ["hrana1", { version: 1, encoding: "json" }],
+]);
+exports.subprotocolsV3 = new Map([
+    ["hrana3-protobuf", { version: 3, encoding: "protobuf" }],
+    ["hrana3", { version: 3, encoding: "json" }],
+    ["hrana2", { version: 2, encoding: "json" }],
+    ["hrana1", { version: 1, encoding: "json" }],
+]);
+/** A client for the Hrana protocol over a WebSocket. */
+class WsClient extends client_js_1.Client {
+    #socket;
+    // List of callbacks that we queue until the socket transitions from the CONNECTING to the OPEN state.
+    #openCallbacks;
+    // Have we already transitioned from CONNECTING to OPEN and fired the callbacks in #openCallbacks?
+    #opened;
+    // Stores the error that caused us to close the client (and the socket). If we are not closed, this is
+    // `undefined`.
+    #closed;
+    // Have we received a response to our "hello" from the server?
+    #recvdHello;
+    // Subprotocol negotiated with the server. It is only available after the socket transitions to the OPEN
+    // state.
+    #subprotocol;
+    // Has the `getVersion()` function been called? This is only used to validate that the API is used
+    // correctly.
+    #getVersionCalled;
+    // A map from request id to the responses that we expect to receive from the server.
+    #responseMap;
+    // An allocator of request ids.
+    #requestIdAlloc;
+    // An allocator of stream ids.
+    /** @private */
+    _streamIdAlloc;
+    // An allocator of cursor ids.
+    /** @private */
+    _cursorIdAlloc;
+    // An allocator of SQL text ids.
+    #sqlIdAlloc;
+    /** @private */
+    constructor(socket, jwt) {
+        super();
+        this.#socket = socket;
+        this.#openCallbacks = [];
+        this.#opened = false;
+        this.#closed = undefined;
+        this.#recvdHello = false;
+        this.#subprotocol = undefined;
+        this.#getVersionCalled = false;
+        this.#responseMap = new Map();
+        this.#requestIdAlloc = new id_alloc_js_1.IdAlloc();
+        this._streamIdAlloc = new id_alloc_js_1.IdAlloc();
+        this._cursorIdAlloc = new id_alloc_js_1.IdAlloc();
+        this.#sqlIdAlloc = new id_alloc_js_1.IdAlloc();
+        this.#socket.binaryType = "arraybuffer";
+        this.#socket.addEventListener("open", () => this.#onSocketOpen());
+        this.#socket.addEventListener("close", (event) => this.#onSocketClose(event));
+        this.#socket.addEventListener("error", (event) => this.#onSocketError(event));
+        this.#socket.addEventListener("message", (event) => this.#onSocketMessage(event));
+        this.#send({ type: "hello", jwt });
+    }
+    // Send (or enqueue to send) a message to the server.
+    #send(msg) {
+        if (this.#closed !== undefined) {
+            throw new errors_js_1.InternalError("Trying to send a message on a closed client");
+        }
+        if (this.#opened) {
+            this.#sendToSocket(msg);
+        }
+        else {
+            const openCallback = () => this.#sendToSocket(msg);
+            const errorCallback = () => undefined;
+            this.#openCallbacks.push({ openCallback, errorCallback });
+        }
+    }
+    // The socket transitioned from CONNECTING to OPEN
+    #onSocketOpen() {
+        const protocol = this.#socket.protocol;
+        if (protocol === undefined) {
+            this.#setClosed(new errors_js_1.ClientError("The `WebSocket.protocol` property is undefined. This most likely means that the WebSocket " +
+                "implementation provided by the environment is broken. If you are using Miniflare 2, " +
+                "please update to Miniflare 3, which fixes this problem."));
+            return;
+        }
+        else if (protocol === "") {
+            this.#subprotocol = { version: 1, encoding: "json" };
+        }
+        else {
+            this.#subprotocol = exports.subprotocolsV3.get(protocol);
+            if (this.#subprotocol === undefined) {
+                this.#setClosed(new errors_js_1.ProtoError(`Unrecognized WebSocket subprotocol: ${JSON.stringify(protocol)}`));
+                return;
+            }
+        }
+        for (const callbacks of this.#openCallbacks) {
+            callbacks.openCallback();
+        }
+        this.#openCallbacks.length = 0;
+        this.#opened = true;
+    }
+    #sendToSocket(msg) {
+        const encoding = this.#subprotocol.encoding;
+        if (encoding === "json") {
+            const jsonMsg = (0, index_js_1.writeJsonObject)(msg, json_encode_js_1.ClientMsg);
+            this.#socket.send(jsonMsg);
+        }
+        else if (encoding === "protobuf") {
+            const protobufMsg = (0, index_js_1.writeProtobufMessage)(msg, protobuf_encode_js_1.ClientMsg);
+            this.#socket.send(protobufMsg);
+        }
+        else {
+            throw (0, util_js_1.impossible)(encoding, "Impossible encoding");
+        }
+    }
+    /** Get the protocol version negotiated with the server, possibly waiting until the socket is open. */
+    getVersion() {
+        return new Promise((versionCallback, errorCallback) => {
+            this.#getVersionCalled = true;
+            if (this.#closed !== undefined) {
+                errorCallback(this.#closed);
+            }
+            else if (!this.#opened) {
+                const openCallback = () => versionCallback(this.#subprotocol.version);
+                this.#openCallbacks.push({ openCallback, errorCallback });
+            }
+            else {
+                versionCallback(this.#subprotocol.version);
+            }
+        });
+    }
+    // Make sure that the negotiated version is at least `minVersion`.
+    /** @private */
+    _ensureVersion(minVersion, feature) {
+        if (this.#subprotocol === undefined || !this.#getVersionCalled) {
+            throw new errors_js_1.ProtocolVersionError(`${feature} is supported only on protocol version ${minVersion} and higher, ` +
+                "but the version supported by the WebSocket server is not yet known. " +
+                "Use Client.getVersion() to wait until the version is available.");
+        }
+        else if (this.#subprotocol.version < minVersion) {
+            throw new errors_js_1.ProtocolVersionError(`${feature} is supported on protocol version ${minVersion} and higher, ` +
+                `but the WebSocket server only supports version ${this.#subprotocol.version}`);
+        }
+    }
+    // Send a request to the server and invoke a callback when we get the response.
+    /** @private */
+    _sendRequest(request, callbacks) {
+        if (this.#closed !== undefined) {
+            callbacks.errorCallback(new errors_js_1.ClosedError("Client is closed", this.#closed));
+            return;
+        }
+        const requestId = this.#requestIdAlloc.alloc();
+        this.#responseMap.set(requestId, { ...callbacks, type: request.type });
+        this.#send({ type: "request", requestId, request });
+    }
+    // The socket encountered an error.
+    #onSocketError(event) {
+        const eventMessage = event.message;
+        const message = eventMessage ?? "WebSocket was closed due to an error";
+        this.#setClosed(new errors_js_1.WebSocketError(message));
+    }
+    // The socket was closed.
+    #onSocketClose(event) {
+        let message = `WebSocket was closed with code ${event.code}`;
+        if (event.reason) {
+            message += `: ${event.reason}`;
+        }
+        this.#setClosed(new errors_js_1.WebSocketError(message));
+    }
+    // Close the client with the given error.
+    #setClosed(error) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        this.#closed = error;
+        for (const callbacks of this.#openCallbacks) {
+            callbacks.errorCallback(error);
+        }
+        this.#openCallbacks.length = 0;
+        for (const [requestId, responseState] of this.#responseMap.entries()) {
+            responseState.errorCallback(error);
+            this.#requestIdAlloc.free(requestId);
+        }
+        this.#responseMap.clear();
+        this.#socket.close();
+    }
+    // We received a message from the socket.
+    #onSocketMessage(event) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        try {
+            let msg;
+            const encoding = this.#subprotocol.encoding;
+            if (encoding === "json") {
+                if (typeof event.data !== "string") {
+                    this.#socket.close(3003, "Only text messages are accepted with JSON encoding");
+                    this.#setClosed(new errors_js_1.ProtoError("Received non-text message from server with JSON encoding"));
+                    return;
+                }
+                msg = (0, index_js_1.readJsonObject)(JSON.parse(event.data), json_decode_js_1.ServerMsg);
+            }
+            else if (encoding === "protobuf") {
+                if (!(event.data instanceof ArrayBuffer)) {
+                    this.#socket.close(3003, "Only binary messages are accepted with Protobuf encoding");
+                    this.#setClosed(new errors_js_1.ProtoError("Received non-binary message from server with Protobuf encoding"));
+                    return;
+                }
+                msg = (0, index_js_1.readProtobufMessage)(new Uint8Array(event.data), protobuf_decode_js_1.ServerMsg);
+            }
+            else {
+                throw (0, util_js_1.impossible)(encoding, "Impossible encoding");
+            }
+            this.#handleMsg(msg);
+        }
+        catch (e) {
+            this.#socket.close(3007, "Could not handle message");
+            this.#setClosed(e);
+        }
+    }
+    // Handle a message from the server.
+    #handleMsg(msg) {
+        if (msg.type === "none") {
+            throw new errors_js_1.ProtoError("Received an unrecognized ServerMsg");
+        }
+        else if (msg.type === "hello_ok" || msg.type === "hello_error") {
+            if (this.#recvdHello) {
+                throw new errors_js_1.ProtoError("Received a duplicated hello response");
+            }
+            this.#recvdHello = true;
+            if (msg.type === "hello_error") {
+                throw (0, result_js_1.errorFromProto)(msg.error);
+            }
+            return;
+        }
+        else if (!this.#recvdHello) {
+            throw new errors_js_1.ProtoError("Received a non-hello message before a hello response");
+        }
+        if (msg.type === "response_ok") {
+            const requestId = msg.requestId;
+            const responseState = this.#responseMap.get(requestId);
+            this.#responseMap.delete(requestId);
+            if (responseState === undefined) {
+                throw new errors_js_1.ProtoError("Received unexpected OK response");
+            }
+            this.#requestIdAlloc.free(requestId);
+            try {
+                if (responseState.type !== msg.response.type) {
+                    console.dir({ responseState, msg });
+                    throw new errors_js_1.ProtoError("Received unexpected type of response");
+                }
+                responseState.responseCallback(msg.response);
+            }
+            catch (e) {
+                responseState.errorCallback(e);
+                throw e;
+            }
+        }
+        else if (msg.type === "response_error") {
+            const requestId = msg.requestId;
+            const responseState = this.#responseMap.get(requestId);
+            this.#responseMap.delete(requestId);
+            if (responseState === undefined) {
+                throw new errors_js_1.ProtoError("Received unexpected error response");
+            }
+            this.#requestIdAlloc.free(requestId);
+            responseState.errorCallback((0, result_js_1.errorFromProto)(msg.error));
+        }
+        else {
+            throw (0, util_js_1.impossible)(msg, "Impossible ServerMsg type");
+        }
+    }
+    /** Open a {@link WsStream}, a stream for executing SQL statements. */
+    openStream() {
+        return stream_js_1.WsStream.open(this);
+    }
+    /** Cache a SQL text on the server. This requires protocol version 2 or higher. */
+    storeSql(sql) {
+        this._ensureVersion(2, "storeSql()");
+        const sqlId = this.#sqlIdAlloc.alloc();
+        const sqlObj = new sql_js_1.Sql(this, sqlId);
+        const responseCallback = () => undefined;
+        const errorCallback = (e) => sqlObj._setClosed(e);
+        const request = { type: "store_sql", sqlId, sql };
+        this._sendRequest(request, { responseCallback, errorCallback });
+        return sqlObj;
+    }
+    /** @private */
+    _closeSql(sqlId) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        const responseCallback = () => this.#sqlIdAlloc.free(sqlId);
+        const errorCallback = (e) => this.#setClosed(e);
+        const request = { type: "close_sql", sqlId };
+        this._sendRequest(request, { responseCallback, errorCallback });
+    }
+    /** Close the client and the WebSocket. */
+    close() {
+        this.#setClosed(new errors_js_1.ClientError("Client was manually closed"));
+    }
+    /** True if the client is closed. */
+    get closed() {
+        return this.#closed !== undefined;
+    }
+}
+exports.WsClient = WsClient;

node_modules/@libsql/hrana-client/lib-cjs/ws/cursor.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsCursor = void 0;
+const errors_js_1 = require("../errors.js");
+const cursor_js_1 = require("../cursor.js");
+const queue_js_1 = require("../queue.js");
+const fetchChunkSize = 1000;
+const fetchQueueSize = 10;
+class WsCursor extends cursor_js_1.Cursor {
+    #client;
+    #stream;
+    #cursorId;
+    #entryQueue;
+    #fetchQueue;
+    #closed;
+    #done;
+    /** @private */
+    constructor(client, stream, cursorId) {
+        super();
+        this.#client = client;
+        this.#stream = stream;
+        this.#cursorId = cursorId;
+        this.#entryQueue = new queue_js_1.Queue();
+        this.#fetchQueue = new queue_js_1.Queue();
+        this.#closed = undefined;
+        this.#done = false;
+    }
+    /** Fetch the next entry from the cursor. */
+    async next() {
+        for (;;) {
+            if (this.#closed !== undefined) {
+                throw new errors_js_1.ClosedError("Cursor is closed", this.#closed);
+            }
+            while (!this.#done && this.#fetchQueue.length < fetchQueueSize) {
+                this.#fetchQueue.push(this.#fetch());
+            }
+            const entry = this.#entryQueue.shift();
+            if (this.#done || entry !== undefined) {
+                return entry;
+            }
+            // we assume that `Cursor.next()` is never called concurrently
+            await this.#fetchQueue.shift().then((response) => {
+                if (response === undefined) {
+                    return;
+                }
+                for (const entry of response.entries) {
+                    this.#entryQueue.push(entry);
+                }
+                this.#done ||= response.done;
+            });
+        }
+    }
+    #fetch() {
+        return this.#stream._sendCursorRequest(this, {
+            type: "fetch_cursor",
+            cursorId: this.#cursorId,
+            maxCount: fetchChunkSize,
+        }).then((resp) => resp, (error) => {
+            this._setClosed(error);
+            return undefined;
+        });
+    }
+    /** @private */
+    _setClosed(error) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        this.#closed = error;
+        this.#stream._sendCursorRequest(this, {
+            type: "close_cursor",
+            cursorId: this.#cursorId,
+        }).catch(() => undefined);
+        this.#stream._cursorClosed(this);
+    }
+    /** Close the cursor. */
+    close() {
+        this._setClosed(new errors_js_1.ClientError("Cursor was manually closed"));
+    }
+    /** True if the cursor is closed. */
+    get closed() {
+        return this.#closed !== undefined;
+    }
+}
+exports.WsCursor = WsCursor;

node_modules/@libsql/hrana-client/lib-cjs/ws/json_decode.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerMsg = void 0;
+const errors_js_1 = require("../errors.js");
+const d = __importStar(require("../encoding/json/decode.js"));
+const json_decode_js_1 = require("../shared/json_decode.js");
+function ServerMsg(obj) {
+    const type = d.string(obj["type"]);
+    if (type === "hello_ok") {
+        return { type: "hello_ok" };
+    }
+    else if (type === "hello_error") {
+        const error = (0, json_decode_js_1.Error)(d.object(obj["error"]));
+        return { type: "hello_error", error };
+    }
+    else if (type === "response_ok") {
+        const requestId = d.number(obj["request_id"]);
+        const response = Response(d.object(obj["response"]));
+        return { type: "response_ok", requestId, response };
+    }
+    else if (type === "response_error") {
+        const requestId = d.number(obj["request_id"]);
+        const error = (0, json_decode_js_1.Error)(d.object(obj["error"]));
+        return { type: "response_error", requestId, error };
+    }
+    else {
+        throw new errors_js_1.ProtoError("Unexpected type of ServerMsg");
+    }
+}
+exports.ServerMsg = ServerMsg;
+function Response(obj) {
+    const type = d.string(obj["type"]);
+    if (type === "open_stream") {
+        return { type: "open_stream" };
+    }
+    else if (type === "close_stream") {
+        return { type: "close_stream" };
+    }
+    else if (type === "execute") {
+        const result = (0, json_decode_js_1.StmtResult)(d.object(obj["result"]));
+        return { type: "execute", result };
+    }
+    else if (type === "batch") {
+        const result = (0, json_decode_js_1.BatchResult)(d.object(obj["result"]));
+        return { type: "batch", result };
+    }
+    else if (type === "open_cursor") {
+        return { type: "open_cursor" };
+    }
+    else if (type === "close_cursor") {
+        return { type: "close_cursor" };
+    }
+    else if (type === "fetch_cursor") {
+        const entries = d.arrayObjectsMap(obj["entries"], json_decode_js_1.CursorEntry);
+        const done = d.boolean(obj["done"]);
+        return { type: "fetch_cursor", entries, done };
+    }
+    else if (type === "sequence") {
+        return { type: "sequence" };
+    }
+    else if (type === "describe") {
+        const result = (0, json_decode_js_1.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 errors_js_1.ProtoError("Unexpected type of Response");
+    }
+}

node_modules/@libsql/hrana-client/lib-cjs/ws/json_encode.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientMsg = void 0;
+const json_encode_js_1 = require("../shared/json_encode.js");
+const util_js_1 = require("../util.js");
+function ClientMsg(w, msg) {
+    w.stringRaw("type", msg.type);
+    if (msg.type === "hello") {
+        if (msg.jwt !== undefined) {
+            w.string("jwt", msg.jwt);
+        }
+    }
+    else if (msg.type === "request") {
+        w.number("request_id", msg.requestId);
+        w.object("request", msg.request, Request);
+    }
+    else {
+        throw (0, util_js_1.impossible)(msg, "Impossible type of ClientMsg");
+    }
+}
+exports.ClientMsg = ClientMsg;
+function Request(w, msg) {
+    w.stringRaw("type", msg.type);
+    if (msg.type === "open_stream") {
+        w.number("stream_id", msg.streamId);
+    }
+    else if (msg.type === "close_stream") {
+        w.number("stream_id", msg.streamId);
+    }
+    else if (msg.type === "execute") {
+        w.number("stream_id", msg.streamId);
+        w.object("stmt", msg.stmt, json_encode_js_1.Stmt);
+    }
+    else if (msg.type === "batch") {
+        w.number("stream_id", msg.streamId);
+        w.object("batch", msg.batch, json_encode_js_1.Batch);
+    }
+    else if (msg.type === "open_cursor") {
+        w.number("stream_id", msg.streamId);
+        w.number("cursor_id", msg.cursorId);
+        w.object("batch", msg.batch, json_encode_js_1.Batch);
+    }
+    else if (msg.type === "close_cursor") {
+        w.number("cursor_id", msg.cursorId);
+    }
+    else if (msg.type === "fetch_cursor") {
+        w.number("cursor_id", msg.cursorId);
+        w.number("max_count", msg.maxCount);
+    }
+    else if (msg.type === "sequence") {
+        w.number("stream_id", msg.streamId);
+        if (msg.sql !== undefined) {
+            w.string("sql", msg.sql);
+        }
+        if (msg.sqlId !== undefined) {
+            w.number("sql_id", msg.sqlId);
+        }
+    }
+    else if (msg.type === "describe") {
+        w.number("stream_id", msg.streamId);
+        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") {
+        w.number("stream_id", msg.streamId);
+    }
+    else {
+        throw (0, util_js_1.impossible)(msg, "Impossible type of Request");
+    }
+}

node_modules/@libsql/hrana-client/lib-cjs/ws/proto.js

@@ -0,0 +1,18 @@
+"use strict";
+// Types for the structures specific to Hrana over WebSockets.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../shared/proto.js"), exports);

node_modules/@libsql/hrana-client/lib-cjs/ws/protobuf_decode.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerMsg = void 0;
+const protobuf_decode_js_1 = require("../shared/protobuf_decode.js");
+exports.ServerMsg = {
+    default() { return { type: "none" }; },
+    1(r) { return { type: "hello_ok" }; },
+    2(r) { return r.message(HelloErrorMsg); },
+    3(r) { return r.message(ResponseOkMsg); },
+    4(r) { return r.message(ResponseErrorMsg); },
+};
+const HelloErrorMsg = {
+    default() { return { type: "hello_error", error: protobuf_decode_js_1.Error.default() }; },
+    1(r, msg) { msg.error = r.message(protobuf_decode_js_1.Error); },
+};
+const ResponseErrorMsg = {
+    default() { return { type: "response_error", requestId: 0, error: protobuf_decode_js_1.Error.default() }; },
+    1(r, msg) { msg.requestId = r.int32(); },
+    2(r, msg) { msg.error = r.message(protobuf_decode_js_1.Error); },
+};
+const ResponseOkMsg = {
+    default() {
+        return {
+            type: "response_ok",
+            requestId: 0,
+            response: { type: "none" },
+        };
+    },
+    1(r, msg) { msg.requestId = r.int32(); },
+    2(r, msg) { msg.response = { type: "open_stream" }; },
+    3(r, msg) { msg.response = { type: "close_stream" }; },
+    4(r, msg) { msg.response = r.message(ExecuteResp); },
+    5(r, msg) { msg.response = r.message(BatchResp); },
+    6(r, msg) { msg.response = { type: "open_cursor" }; },
+    7(r, msg) { msg.response = { type: "close_cursor" }; },
+    8(r, msg) { msg.response = r.message(FetchCursorResp); },
+    9(r, msg) { msg.response = { type: "sequence" }; },
+    10(r, msg) { msg.response = r.message(DescribeResp); },
+    11(r, msg) { msg.response = { type: "store_sql" }; },
+    12(r, msg) { msg.response = { type: "close_sql" }; },
+    13(r, msg) { msg.response = r.message(GetAutocommitResp); },
+};
+const ExecuteResp = {
+    default() { return { type: "execute", result: protobuf_decode_js_1.StmtResult.default() }; },
+    1(r, msg) { msg.result = r.message(protobuf_decode_js_1.StmtResult); },
+};
+const BatchResp = {
+    default() { return { type: "batch", result: protobuf_decode_js_1.BatchResult.default() }; },
+    1(r, msg) { msg.result = r.message(protobuf_decode_js_1.BatchResult); },
+};
+const FetchCursorResp = {
+    default() { return { type: "fetch_cursor", entries: [], done: false }; },
+    1(r, msg) { msg.entries.push(r.message(protobuf_decode_js_1.CursorEntry)); },
+    2(r, msg) { msg.done = r.bool(); },
+};
+const DescribeResp = {
+    default() { return { type: "describe", result: protobuf_decode_js_1.DescribeResult.default() }; },
+    1(r, msg) { msg.result = r.message(protobuf_decode_js_1.DescribeResult); },
+};
+const GetAutocommitResp = {
+    default() { return { type: "get_autocommit", isAutocommit: false }; },
+    1(r, msg) { msg.isAutocommit = r.bool(); },
+};

node_modules/@libsql/hrana-client/lib-cjs/ws/protobuf_encode.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientMsg = void 0;
+const protobuf_encode_js_1 = require("../shared/protobuf_encode.js");
+const util_js_1 = require("../util.js");
+function ClientMsg(w, msg) {
+    if (msg.type === "hello") {
+        w.message(1, msg, HelloMsg);
+    }
+    else if (msg.type === "request") {
+        w.message(2, msg, RequestMsg);
+    }
+    else {
+        throw (0, util_js_1.impossible)(msg, "Impossible type of ClientMsg");
+    }
+}
+exports.ClientMsg = ClientMsg;
+function HelloMsg(w, msg) {
+    if (msg.jwt !== undefined) {
+        w.string(1, msg.jwt);
+    }
+}
+function RequestMsg(w, msg) {
+    w.int32(1, msg.requestId);
+    const request = msg.request;
+    if (request.type === "open_stream") {
+        w.message(2, request, OpenStreamReq);
+    }
+    else if (request.type === "close_stream") {
+        w.message(3, request, CloseStreamReq);
+    }
+    else if (request.type === "execute") {
+        w.message(4, request, ExecuteReq);
+    }
+    else if (request.type === "batch") {
+        w.message(5, request, BatchReq);
+    }
+    else if (request.type === "open_cursor") {
+        w.message(6, request, OpenCursorReq);
+    }
+    else if (request.type === "close_cursor") {
+        w.message(7, request, CloseCursorReq);
+    }
+    else if (request.type === "fetch_cursor") {
+        w.message(8, request, FetchCursorReq);
+    }
+    else if (request.type === "sequence") {
+        w.message(9, request, SequenceReq);
+    }
+    else if (request.type === "describe") {
+        w.message(10, request, DescribeReq);
+    }
+    else if (request.type === "store_sql") {
+        w.message(11, request, StoreSqlReq);
+    }
+    else if (request.type === "close_sql") {
+        w.message(12, request, CloseSqlReq);
+    }
+    else if (request.type === "get_autocommit") {
+        w.message(13, request, GetAutocommitReq);
+    }
+    else {
+        throw (0, util_js_1.impossible)(request, "Impossible type of Request");
+    }
+}
+function OpenStreamReq(w, msg) {
+    w.int32(1, msg.streamId);
+}
+function CloseStreamReq(w, msg) {
+    w.int32(1, msg.streamId);
+}
+function ExecuteReq(w, msg) {
+    w.int32(1, msg.streamId);
+    w.message(2, msg.stmt, protobuf_encode_js_1.Stmt);
+}
+function BatchReq(w, msg) {
+    w.int32(1, msg.streamId);
+    w.message(2, msg.batch, protobuf_encode_js_1.Batch);
+}
+function OpenCursorReq(w, msg) {
+    w.int32(1, msg.streamId);
+    w.int32(2, msg.cursorId);
+    w.message(3, msg.batch, protobuf_encode_js_1.Batch);
+}
+function CloseCursorReq(w, msg) {
+    w.int32(1, msg.cursorId);
+}
+function FetchCursorReq(w, msg) {
+    w.int32(1, msg.cursorId);
+    w.uint32(2, msg.maxCount);
+}
+function SequenceReq(w, msg) {
+    w.int32(1, msg.streamId);
+    if (msg.sql !== undefined) {
+        w.string(2, msg.sql);
+    }
+    if (msg.sqlId !== undefined) {
+        w.int32(3, msg.sqlId);
+    }
+}
+function DescribeReq(w, msg) {
+    w.int32(1, msg.streamId);
+    if (msg.sql !== undefined) {
+        w.string(2, msg.sql);
+    }
+    if (msg.sqlId !== undefined) {
+        w.int32(3, msg.sqlId);
+    }
+}
+function StoreSqlReq(w, msg) {
+    w.int32(1, msg.sqlId);
+    w.string(2, msg.sql);
+}
+function CloseSqlReq(w, msg) {
+    w.int32(1, msg.sqlId);
+}
+function GetAutocommitReq(w, msg) {
+    w.int32(1, msg.streamId);
+}

node_modules/@libsql/hrana-client/lib-cjs/ws/stream.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsStream = void 0;
+const errors_js_1 = require("../errors.js");
+const queue_js_1 = require("../queue.js");
+const stream_js_1 = require("../stream.js");
+const cursor_js_1 = require("./cursor.js");
+class WsStream extends stream_js_1.Stream {
+    #client;
+    #streamId;
+    #queue;
+    #cursor;
+    #closing;
+    #closed;
+    /** @private */
+    static open(client) {
+        const streamId = client._streamIdAlloc.alloc();
+        const stream = new WsStream(client, streamId);
+        const responseCallback = () => undefined;
+        const errorCallback = (e) => stream.#setClosed(e);
+        const request = { type: "open_stream", streamId };
+        client._sendRequest(request, { responseCallback, errorCallback });
+        return stream;
+    }
+    /** @private */
+    constructor(client, streamId) {
+        super(client.intMode);
+        this.#client = client;
+        this.#streamId = streamId;
+        this.#queue = new queue_js_1.Queue();
+        this.#cursor = undefined;
+        this.#closing = false;
+        this.#closed = undefined;
+    }
+    /** Get the {@link WsClient} object that this stream belongs to. */
+    client() {
+        return this.#client;
+    }
+    /** @private */
+    _sqlOwner() {
+        return this.#client;
+    }
+    /** @private */
+    _execute(stmt) {
+        return this.#sendStreamRequest({
+            type: "execute",
+            streamId: this.#streamId,
+            stmt,
+        }).then((response) => {
+            return response.result;
+        });
+    }
+    /** @private */
+    _batch(batch) {
+        return this.#sendStreamRequest({
+            type: "batch",
+            streamId: this.#streamId,
+            batch,
+        }).then((response) => {
+            return response.result;
+        });
+    }
+    /** @private */
+    _describe(protoSql) {
+        this.#client._ensureVersion(2, "describe()");
+        return this.#sendStreamRequest({
+            type: "describe",
+            streamId: this.#streamId,
+            sql: protoSql.sql,
+            sqlId: protoSql.sqlId,
+        }).then((response) => {
+            return response.result;
+        });
+    }
+    /** @private */
+    _sequence(protoSql) {
+        this.#client._ensureVersion(2, "sequence()");
+        return this.#sendStreamRequest({
+            type: "sequence",
+            streamId: this.#streamId,
+            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",
+            streamId: this.#streamId,
+        }).then((response) => {
+            return response.isAutocommit;
+        });
+    }
+    #sendStreamRequest(request) {
+        return new Promise((responseCallback, errorCallback) => {
+            this.#pushToQueue({ type: "request", request, responseCallback, errorCallback });
+        });
+    }
+    /** @private */
+    _openCursor(batch) {
+        this.#client._ensureVersion(3, "cursor");
+        return new Promise((cursorCallback, errorCallback) => {
+            this.#pushToQueue({ type: "cursor", batch, cursorCallback, errorCallback });
+        });
+    }
+    /** @private */
+    _sendCursorRequest(cursor, request) {
+        if (cursor !== this.#cursor) {
+            throw new errors_js_1.InternalError("Cursor not associated with the stream attempted to execute a request");
+        }
+        return new Promise((responseCallback, errorCallback) => {
+            if (this.#closed !== undefined) {
+                errorCallback(new errors_js_1.ClosedError("Stream is closed", this.#closed));
+            }
+            else {
+                this.#client._sendRequest(request, { responseCallback, errorCallback });
+            }
+        });
+    }
+    /** @private */
+    _cursorClosed(cursor) {
+        if (cursor !== this.#cursor) {
+            throw new errors_js_1.InternalError("Cursor was closed, but it was not associated with the stream");
+        }
+        this.#cursor = undefined;
+        this.#flushQueue();
+    }
+    #pushToQueue(entry) {
+        if (this.#closed !== undefined) {
+            entry.errorCallback(new errors_js_1.ClosedError("Stream is closed", this.#closed));
+        }
+        else if (this.#closing) {
+            entry.errorCallback(new errors_js_1.ClosedError("Stream is closing", undefined));
+        }
+        else {
+            this.#queue.push(entry);
+            this.#flushQueue();
+        }
+    }
+    #flushQueue() {
+        for (;;) {
+            const entry = this.#queue.first();
+            if (entry === undefined && this.#cursor === undefined && this.#closing) {
+                this.#setClosed(new errors_js_1.ClientError("Stream was gracefully closed"));
+                break;
+            }
+            else if (entry?.type === "request" && this.#cursor === undefined) {
+                const { request, responseCallback, errorCallback } = entry;
+                this.#queue.shift();
+                this.#client._sendRequest(request, { responseCallback, errorCallback });
+            }
+            else if (entry?.type === "cursor" && this.#cursor === undefined) {
+                const { batch, cursorCallback } = entry;
+                this.#queue.shift();
+                const cursorId = this.#client._cursorIdAlloc.alloc();
+                const cursor = new cursor_js_1.WsCursor(this.#client, this, cursorId);
+                const request = {
+                    type: "open_cursor",
+                    streamId: this.#streamId,
+                    cursorId,
+                    batch,
+                };
+                const responseCallback = () => undefined;
+                const errorCallback = (e) => cursor._setClosed(e);
+                this.#client._sendRequest(request, { responseCallback, errorCallback });
+                this.#cursor = cursor;
+                cursorCallback(cursor);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    #setClosed(error) {
+        if (this.#closed !== undefined) {
+            return;
+        }
+        this.#closed = error;
+        if (this.#cursor !== undefined) {
+            this.#cursor._setClosed(error);
+        }
+        for (;;) {
+            const entry = this.#queue.shift();
+            if (entry !== undefined) {
+                entry.errorCallback(error);
+            }
+            else {
+                break;
+            }
+        }
+        const request = { type: "close_stream", streamId: this.#streamId };
+        const responseCallback = () => this.#client._streamIdAlloc.free(this.#streamId);
+        const errorCallback = () => undefined;
+        this.#client._sendRequest(request, { responseCallback, errorCallback });
+    }
+    /** Immediately close the stream. */
+    close() {
+        this.#setClosed(new errors_js_1.ClientError("Stream was manually closed"));
+    }
+    /** Gracefully close the stream. */
+    closeGracefully() {
+        this.#closing = true;
+        this.#flushQueue();
+    }
+    /** True if the stream is closed or closing. */
+    get closed() {
+        return this.#closed !== undefined || this.#closing;
+    }
+}
+exports.WsStream = WsStream;