orcaq 1.1.1 → 1.1.2

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

@@ -0,0 +1,115 @@
+import { Stmt, Batch } from "../shared/protobuf_encode.js";
+import { impossible } from "../util.js";
+export 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 impossible(msg, "Impossible type of 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 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, Stmt);
+}
+function BatchReq(w, msg) {
+    w.int32(1, msg.streamId);
+    w.message(2, msg.batch, Batch);
+}
+function OpenCursorReq(w, msg) {
+    w.int32(1, msg.streamId);
+    w.int32(2, msg.cursorId);
+    w.message(3, msg.batch, 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);
+}

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

@@ -0,0 +1,211 @@
+import { ClientError, ClosedError, InternalError } from "../errors.js";
+import { Queue } from "../queue.js";
+import { Stream } from "../stream.js";
+import { WsCursor } from "./cursor.js";
+export class WsStream extends 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();
+        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 InternalError("Cursor not associated with the stream attempted to execute a request");
+        }
+        return new Promise((responseCallback, errorCallback) => {
+            if (this.#closed !== undefined) {
+                errorCallback(new ClosedError("Stream is closed", this.#closed));
+            }
+            else {
+                this.#client._sendRequest(request, { responseCallback, 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;
+        this.#flushQueue();
+    }
+    #pushToQueue(entry) {
+        if (this.#closed !== undefined) {
+            entry.errorCallback(new ClosedError("Stream is closed", this.#closed));
+        }
+        else if (this.#closing) {
+            entry.errorCallback(new 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 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 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 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;
+    }
+}

package/.output/server/node_modules/@libsql/hrana-client/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@libsql/hrana-client",
+  "version": "0.7.0",
+  "keywords": [
+    "hrana",
+    "libsql",
+    "sqld",
+    "database"
+  ],
+  "description": "Hrana client for connecting to sqld over HTTP or WebSocket",
+  "repository": {
+    "type": "git",
+    "url": "github:libsql/hrana-client-ts"
+  },
+  "homepage": "https://github.com/libsql/hrana-client-ts",
+  "authors": [
+    "Jan Špaček <honza@chiselstrike.com>"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "lib-cjs/index.js",
+  "types": "lib-esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib-esm/index.d.ts",
+      "import": "./lib-esm/index.js",
+      "require": "./lib-cjs/index.js"
+    }
+  },
+  "files": [
+    "lib-cjs/**",
+    "lib-esm/**"
+  ],
+  "scripts": {
+    "clean": "rm -rf ./lib-cjs ./lib-esm ./*.tsbuildinfo",
+    "prepublishOnly": "npm run clean-build",
+    "prebuild": "rm -rf ./lib-cjs ./lib-esm",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.build-cjs.json",
+    "build:esm": "tsc -p tsconfig.build-esm.json",
+    "postbuild": "cp package-cjs.json ./lib-cjs/package.json",
+    "clean-build": "npm run clean && npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "jest --runInBand",
+    "typedoc": "rm -rf ./docs && typedoc"
+  },
+  "dependencies": {
+    "@libsql/isomorphic-fetch": "^0.3.1",
+    "@libsql/isomorphic-ws": "^0.1.5",
+    "js-base64": "^3.7.5",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/jest": "^29",
+    "jest": "^29.6.2",
+    "ts-jest": "^29.1.1",
+    "typedoc": "^0.24.8",
+    "typescript": "^5.1.6"
+  }
+}

package/.output/server/node_modules/@libsql/isomorphic-fetch/node.js

@@ -0,0 +1,6 @@
+const _Request = Request;
+const _Headers = Headers;
+
+const _fetch = fetch;
+
+export { _fetch as fetch, _Request as Request, _Headers as Headers};

package/.output/server/node_modules/@libsql/isomorphic-fetch/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@libsql/isomorphic-fetch",
+  "version": "0.3.1",
+  "keywords": [
+    "fetch",
+    "isomorphic",
+    "node",
+    "deno",
+    "workers"
+  ],
+  "description": "Isomorphic fetch() in Node, Deno and Cloudflare Workers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/libsql/isomorphic-ts.git",
+    "directory": "isomorphic-fetch"
+  },
+  "homepage": "https://github.com/libsql/isomorphic-ts/tree/main/isomorphic-fetch",
+  "authors": [
+    "Jan Špaček <honza@chiselstrike.com>"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "node.cjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "bun": "./web.js",
+        "node": "./node.js",
+        "deno": "./web.js",
+        "workerd": "./web.js",
+        "default": "./web.js"
+      },
+      "require": {
+        "bun": "./web.cjs",
+        "node": "./node.cjs",
+        "workerd": "./web.cjs",
+        "default": "./web.cjs"
+      }
+    }
+  },
+  "files": [
+    "*.mjs",
+    "*.cjs",
+    "*.js",
+    "*.d.ts"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/.output/server/node_modules/@libsql/isomorphic-ws/node.mjs

@@ -0,0 +1,2 @@
+import { WebSocket } from "ws";
+export { WebSocket };

package/.output/server/node_modules/@libsql/isomorphic-ws/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@libsql/isomorphic-ws",
+  "version": "0.1.5",
+  "keywords": [
+    "ws",
+    "websocket",
+    "isomorphic",
+    "node",
+    "deno",
+    "workers"
+  ],
+  "description": "Isomorphic WebSockets in Node, Bun, Deno and Cloudflare Workers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/libsql/isomorphic-ts.git",
+    "directory": "isomorphic-ws"
+  },
+  "homepage": "https://github.com/libsql/isomorphic-ts/tree/main/isomorphic-ws",
+  "authors": [
+    "Jan Špaček <honza@chiselstrike.com>"
+  ],
+  "license": "MIT",
+  "main": "node.cjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "bun": "./web.mjs",
+        "deno": "./web.mjs",
+        "workerd": "./web.mjs",
+        "node": "./node.mjs",
+        "default": "./web.mjs"
+      },
+      "require": {
+        "bun": "./web.cjs",
+        "deno": "./web.cjs",
+        "workerd": "./web.cjs",
+        "node": "./node.cjs",
+        "default": "./web.cjs"
+      }
+    }
+  },
+  "files": [
+    "*.mjs",
+    "*.cjs",
+    "*.js",
+    "*.d.ts"
+  ],
+  "dependencies": {
+    "ws": "^8.13.0",
+    "@types/ws": "^8.5.4"
+  }
+}

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/ADD.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Adds an item to a Bloom Filter
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter
+     * @param item - The item to add to the filter
+     */
+    parseCommand(parser, key, item) {
+        parser.push('BF.ADD');
+        parser.pushKey(key);
+        parser.push(item);
+    },
+    transformReply: generic_transformers_1.transformBooleanReply
+};
+//# sourceMappingURL=ADD.js.map

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/CARD.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Returns the cardinality (number of items) in a Bloom Filter
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter to query
+     */
+    parseCommand(parser, key) {
+        parser.push('BF.CARD');
+        parser.pushKey(key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CARD.js.map

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/EXISTS.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Checks if an item exists in a Bloom Filter
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter
+     * @param item - The item to check for existence
+     */
+    parseCommand(parser, key, item) {
+        parser.push('BF.EXISTS');
+        parser.pushKey(key);
+        parser.push(item);
+    },
+    transformReply: generic_transformers_1.transformBooleanReply
+};
+//# sourceMappingURL=EXISTS.js.map

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/INFO.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Returns information about a Bloom Filter, including capacity, size, number of filters, items inserted, and expansion rate
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter to get information about
+     */
+    parseCommand(parser, key) {
+        parser.push('BF.INFO');
+        parser.pushKey(key);
+    },
+    transformReply: {
+        2: (reply, _, typeMapping) => {
+            return (0, helpers_1.transformInfoV2Reply)(reply, typeMapping);
+        },
+        3: undefined
+    }
+};
+//# sourceMappingURL=INFO.js.map

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/INSERT.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Adds one or more items to a Bloom Filter, creating it if it does not exist
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter
+     * @param items - One or more items to add to the filter
+     * @param options - Optional parameters for filter creation
+     * @param options.CAPACITY - Desired capacity for a new filter
+     * @param options.ERROR - Desired error rate for a new filter
+     * @param options.EXPANSION - Expansion rate for a new filter
+     * @param options.NOCREATE - If true, prevents automatic filter creation
+     * @param options.NONSCALING - Prevents the filter from creating additional sub-filters
+     */
+    parseCommand(parser, key, items, options) {
+        parser.push('BF.INSERT');
+        parser.pushKey(key);
+        if (options?.CAPACITY !== undefined) {
+            parser.push('CAPACITY', options.CAPACITY.toString());
+        }
+        if (options?.ERROR !== undefined) {
+            parser.push('ERROR', options.ERROR.toString());
+        }
+        if (options?.EXPANSION !== undefined) {
+            parser.push('EXPANSION', options.EXPANSION.toString());
+        }
+        if (options?.NOCREATE) {
+            parser.push('NOCREATE');
+        }
+        if (options?.NONSCALING) {
+            parser.push('NONSCALING');
+        }
+        parser.push('ITEMS');
+        parser.pushVariadic(items);
+    },
+    transformReply: generic_transformers_1.transformBooleanArrayReply
+};
+//# sourceMappingURL=INSERT.js.map

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/LOADCHUNK.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Restores a Bloom Filter chunk previously saved using SCANDUMP
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter to restore
+     * @param iterator - Iterator value from the SCANDUMP command
+     * @param chunk - Data chunk from the SCANDUMP command
+     */
+    parseCommand(parser, key, iterator, chunk) {
+        parser.push('BF.LOADCHUNK');
+        parser.pushKey(key);
+        parser.push(iterator.toString(), chunk);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=LOADCHUNK.js.map

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/MADD.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Adds multiple items to a Bloom Filter in a single call
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter
+     * @param items - One or more items to add to the filter
+     */
+    parseCommand(parser, key, items) {
+        parser.push('BF.MADD');
+        parser.pushKey(key);
+        parser.pushVariadic(items);
+    },
+    transformReply: generic_transformers_1.transformBooleanArrayReply
+};
+//# sourceMappingURL=MADD.js.map

package/.output/server/node_modules/@redis/bloom/dist/lib/commands/bloom/MEXISTS.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Checks if multiple items exist in a Bloom Filter in a single call
+     * @param parser - The command parser
+     * @param key - The name of the Bloom filter
+     * @param items - One or more items to check for existence
+     */
+    parseCommand(parser, key, items) {
+        parser.push('BF.MEXISTS');
+        parser.pushKey(key);
+        parser.pushVariadic(items);
+    },
+    transformReply: generic_transformers_1.transformBooleanArrayReply
+};
+//# sourceMappingURL=MEXISTS.js.map