@minimalcorp/tsunagi 0.0.4 → 0.0.6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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