@minimalcorp/tsunagi 0.0.4 → 0.1.0

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/value.js

@@ -1,83 +0,0 @@
-import { ProtoError, MisuseError } from "./errors.js";
-import { impossible } from "./util.js";
-export function valueToProto(value) {
-    if (value === null) {
-        return null;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    else if (typeof value === "number") {
-        if (!Number.isFinite(value)) {
-            throw new RangeError("Only finite numbers (not Infinity or NaN) can be passed as arguments");
-        }
-        return value;
-    }
-    else if (typeof value === "bigint") {
-        if (value < minInteger || value > maxInteger) {
-            throw new RangeError("This bigint value is too large to be represented as a 64-bit integer and passed as argument");
-        }
-        return value;
-    }
-    else if (typeof value === "boolean") {
-        return value ? 1n : 0n;
-    }
-    else if (value instanceof ArrayBuffer) {
-        return new Uint8Array(value);
-    }
-    else if (value instanceof Uint8Array) {
-        return value;
-    }
-    else if (value instanceof Date) {
-        return +value.valueOf();
-    }
-    else if (typeof value === "object") {
-        return "" + value.toString();
-    }
-    else {
-        throw new TypeError("Unsupported type of value");
-    }
-}
-const minInteger = -9223372036854775808n;
-const maxInteger = 9223372036854775807n;
-export function valueFromProto(value, intMode) {
-    if (value === null) {
-        return null;
-    }
-    else if (typeof value === "number") {
-        return value;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    else if (typeof value === "bigint") {
-        if (intMode === "number") {
-            const num = Number(value);
-            if (!Number.isSafeInteger(num)) {
-                throw new RangeError("Received integer which is too large to be safely represented as a JavaScript number");
-            }
-            return num;
-        }
-        else if (intMode === "bigint") {
-            return value;
-        }
-        else if (intMode === "string") {
-            return "" + value;
-        }
-        else {
-            throw new MisuseError("Invalid value for IntMode");
-        }
-    }
-    else if (value instanceof Uint8Array) {
-        // TODO: we need to copy data from `Uint8Array` to return an `ArrayBuffer`. Perhaps we should add a
-        // `blobMode` parameter, similar to `intMode`, which would allow the user to choose between receiving
-        // `ArrayBuffer` (default, convenient) and `Uint8Array` (zero copy)?
-        return value.slice().buffer;
-    }
-    else if (value === undefined) {
-        throw new ProtoError("Received unrecognized type of Value");
-    }
-    else {
-        throw impossible(value, "Impossible type of Value");
-    }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/ws/client.js

@@ -1,318 +0,0 @@
-import { Client } from "../client.js";
-import { readJsonObject, writeJsonObject, readProtobufMessage, writeProtobufMessage, } from "../encoding/index.js";
-import { ClientError, ProtoError, ClosedError, WebSocketError, ProtocolVersionError, InternalError, } from "../errors.js";
-import { IdAlloc } from "../id_alloc.js";
-import { errorFromProto } from "../result.js";
-import { Sql } from "../sql.js";
-import { impossible } from "../util.js";
-import { WsStream } from "./stream.js";
-import { ClientMsg as json_ClientMsg } from "./json_encode.js";
-import { ClientMsg as protobuf_ClientMsg } from "./protobuf_encode.js";
-import { ServerMsg as json_ServerMsg } from "./json_decode.js";
-import { ServerMsg as protobuf_ServerMsg } from "./protobuf_decode.js";
-export const subprotocolsV2 = new Map([
-    ["hrana2", { version: 2, encoding: "json" }],
-    ["hrana1", { version: 1, encoding: "json" }],
-]);
-export const 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. */
-export class WsClient extends 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 IdAlloc();
-        this._streamIdAlloc = new IdAlloc();
-        this._cursorIdAlloc = new IdAlloc();
-        this.#sqlIdAlloc = new 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 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 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 = subprotocolsV3.get(protocol);
-            if (this.#subprotocol === undefined) {
-                this.#setClosed(new 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 = writeJsonObject(msg, json_ClientMsg);
-            this.#socket.send(jsonMsg);
-        }
-        else if (encoding === "protobuf") {
-            const protobufMsg = writeProtobufMessage(msg, protobuf_ClientMsg);
-            this.#socket.send(protobufMsg);
-        }
-        else {
-            throw 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 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 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 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 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 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 ProtoError("Received non-text message from server with JSON encoding"));
-                    return;
-                }
-                msg = readJsonObject(JSON.parse(event.data), json_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 ProtoError("Received non-binary message from server with Protobuf encoding"));
-                    return;
-                }
-                msg = readProtobufMessage(new Uint8Array(event.data), protobuf_ServerMsg);
-            }
-            else {
-                throw 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 ProtoError("Received an unrecognized ServerMsg");
-        }
-        else if (msg.type === "hello_ok" || msg.type === "hello_error") {
-            if (this.#recvdHello) {
-                throw new ProtoError("Received a duplicated hello response");
-            }
-            this.#recvdHello = true;
-            if (msg.type === "hello_error") {
-                throw errorFromProto(msg.error);
-            }
-            return;
-        }
-        else if (!this.#recvdHello) {
-            throw new 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 ProtoError("Received unexpected OK response");
-            }
-            this.#requestIdAlloc.free(requestId);
-            try {
-                if (responseState.type !== msg.response.type) {
-                    console.dir({ responseState, msg });
-                    throw new 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 ProtoError("Received unexpected error response");
-            }
-            this.#requestIdAlloc.free(requestId);
-            responseState.errorCallback(errorFromProto(msg.error));
-        }
-        else {
-            throw impossible(msg, "Impossible ServerMsg type");
-        }
-    }
-    /** Open a {@link WsStream}, a stream for executing SQL statements. */
-    openStream() {
-        return 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(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 ClientError("Client was manually closed"));
-    }
-    /** True if the client is closed. */
-    get closed() {
-        return this.#closed !== undefined;
-    }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/ws/cursor.js

@@ -1,80 +0,0 @@
-import { ClientError, ClosedError } from "../errors.js";
-import { Cursor } from "../cursor.js";
-import { Queue } from "../queue.js";
-const fetchChunkSize = 1000;
-const fetchQueueSize = 10;
-export class WsCursor extends 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();
-        this.#fetchQueue = new Queue();
-        this.#closed = undefined;
-        this.#done = false;
-    }
-    /** Fetch the next entry from the cursor. */
-    async next() {
-        for (;;) {
-            if (this.#closed !== undefined) {
-                throw new 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 ClientError("Cursor was manually closed"));
-    }
-    /** True if the cursor is closed. */
-    get closed() {
-        return this.#closed !== undefined;
-    }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/ws/json_decode.js

@@ -1,74 +0,0 @@
-import { ProtoError } from "../errors.js";
-import * as d from "../encoding/json/decode.js";
-import { Error, StmtResult, BatchResult, CursorEntry, DescribeResult } from "../shared/json_decode.js";
-export function ServerMsg(obj) {
-    const type = d.string(obj["type"]);
-    if (type === "hello_ok") {
-        return { type: "hello_ok" };
-    }
-    else if (type === "hello_error") {
-        const error = 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 = Error(d.object(obj["error"]));
-        return { type: "response_error", requestId, error };
-    }
-    else {
-        throw new ProtoError("Unexpected type of 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 = 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 === "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"], 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 = 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 Response");
-    }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/ws/json_encode.js

@@ -1,77 +0,0 @@
-import { Stmt, Batch } from "../shared/json_encode.js";
-import { impossible } from "../util.js";
-export 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 impossible(msg, "Impossible type of 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, Stmt);
-    }
-    else if (msg.type === "batch") {
-        w.number("stream_id", msg.streamId);
-        w.object("batch", msg.batch, Batch);
-    }
-    else if (msg.type === "open_cursor") {
-        w.number("stream_id", msg.streamId);
-        w.number("cursor_id", msg.cursorId);
-        w.object("batch", msg.batch, 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 impossible(msg, "Impossible type of Request");
-    }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/ws/proto.js

@@ -1,2 +0,0 @@
-// Types for the structures specific to Hrana over WebSockets.
-export * from "../shared/proto.js";