@minimalcorp/tsunagi 0.0.4 → 0.1.0

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

@@ -1,271 +0,0 @@
-import { ProtoError, MisuseError } from "./errors.js";
-import { stmtResultFromProto, rowsResultFromProto, rowResultFromProto, valueResultFromProto, errorFromProto, } from "./result.js";
-import { stmtToProto } from "./stmt.js";
-import { impossible } from "./util.js";
-/** A builder for creating a batch and executing it on the server. */
-export class Batch {
-    /** @private */
-    _stream;
-    #useCursor;
-    /** @private */
-    _steps;
-    #executed;
-    /** @private */
-    constructor(stream, useCursor) {
-        this._stream = stream;
-        this.#useCursor = useCursor;
-        this._steps = [];
-        this.#executed = false;
-    }
-    /** Return a builder for adding a step to the batch. */
-    step() {
-        return new BatchStep(this);
-    }
-    /** Execute the batch. */
-    execute() {
-        if (this.#executed) {
-            throw new MisuseError("This batch has already been executed");
-        }
-        this.#executed = true;
-        const batch = {
-            steps: this._steps.map((step) => step.proto),
-        };
-        if (this.#useCursor) {
-            return executeCursor(this._stream, this._steps, batch);
-        }
-        else {
-            return executeRegular(this._stream, this._steps, batch);
-        }
-    }
-}
-function executeRegular(stream, steps, batch) {
-    return stream._batch(batch).then((result) => {
-        for (let step = 0; step < steps.length; ++step) {
-            const stepResult = result.stepResults.get(step);
-            const stepError = result.stepErrors.get(step);
-            steps[step].callback(stepResult, stepError);
-        }
-    });
-}
-async function executeCursor(stream, steps, batch) {
-    const cursor = await stream._openCursor(batch);
-    try {
-        let nextStep = 0;
-        let beginEntry = undefined;
-        let rows = [];
-        for (;;) {
-            const entry = await cursor.next();
-            if (entry === undefined) {
-                break;
-            }
-            if (entry.type === "step_begin") {
-                if (entry.step < nextStep || entry.step >= steps.length) {
-                    throw new ProtoError("Server produced StepBeginEntry for unexpected step");
-                }
-                else if (beginEntry !== undefined) {
-                    throw new ProtoError("Server produced StepBeginEntry before terminating previous step");
-                }
-                for (let step = nextStep; step < entry.step; ++step) {
-                    steps[step].callback(undefined, undefined);
-                }
-                nextStep = entry.step + 1;
-                beginEntry = entry;
-                rows = [];
-            }
-            else if (entry.type === "step_end") {
-                if (beginEntry === undefined) {
-                    throw new ProtoError("Server produced StepEndEntry but no step is active");
-                }
-                const stmtResult = {
-                    cols: beginEntry.cols,
-                    rows,
-                    affectedRowCount: entry.affectedRowCount,
-                    lastInsertRowid: entry.lastInsertRowid,
-                };
-                steps[beginEntry.step].callback(stmtResult, undefined);
-                beginEntry = undefined;
-                rows = [];
-            }
-            else if (entry.type === "step_error") {
-                if (beginEntry === undefined) {
-                    if (entry.step >= steps.length) {
-                        throw new ProtoError("Server produced StepErrorEntry for unexpected step");
-                    }
-                    for (let step = nextStep; step < entry.step; ++step) {
-                        steps[step].callback(undefined, undefined);
-                    }
-                }
-                else {
-                    if (entry.step !== beginEntry.step) {
-                        throw new ProtoError("Server produced StepErrorEntry for unexpected step");
-                    }
-                    beginEntry = undefined;
-                    rows = [];
-                }
-                steps[entry.step].callback(undefined, entry.error);
-                nextStep = entry.step + 1;
-            }
-            else if (entry.type === "row") {
-                if (beginEntry === undefined) {
-                    throw new ProtoError("Server produced RowEntry but no step is active");
-                }
-                rows.push(entry.row);
-            }
-            else if (entry.type === "error") {
-                throw errorFromProto(entry.error);
-            }
-            else if (entry.type === "none") {
-                throw new ProtoError("Server produced unrecognized CursorEntry");
-            }
-            else {
-                throw impossible(entry, "Impossible CursorEntry");
-            }
-        }
-        if (beginEntry !== undefined) {
-            throw new ProtoError("Server closed Cursor before terminating active step");
-        }
-        for (let step = nextStep; step < steps.length; ++step) {
-            steps[step].callback(undefined, undefined);
-        }
-    }
-    finally {
-        cursor.close();
-    }
-}
-/** A builder for adding a step to the batch. */
-export class BatchStep {
-    /** @private */
-    _batch;
-    #conds;
-    /** @private */
-    _index;
-    /** @private */
-    constructor(batch) {
-        this._batch = batch;
-        this.#conds = [];
-        this._index = undefined;
-    }
-    /** Add the condition that needs to be satisfied to execute the statement. If you use this method multiple
-     * times, we join the conditions with a logical AND. */
-    condition(cond) {
-        this.#conds.push(cond._proto);
-        return this;
-    }
-    /** Add a statement that returns rows. */
-    query(stmt) {
-        return this.#add(stmt, true, rowsResultFromProto);
-    }
-    /** Add a statement that returns at most a single row. */
-    queryRow(stmt) {
-        return this.#add(stmt, true, rowResultFromProto);
-    }
-    /** Add a statement that returns at most a single value. */
-    queryValue(stmt) {
-        return this.#add(stmt, true, valueResultFromProto);
-    }
-    /** Add a statement without returning rows. */
-    run(stmt) {
-        return this.#add(stmt, false, stmtResultFromProto);
-    }
-    #add(inStmt, wantRows, fromProto) {
-        if (this._index !== undefined) {
-            throw new MisuseError("This BatchStep has already been added to the batch");
-        }
-        const stmt = stmtToProto(this._batch._stream._sqlOwner(), inStmt, wantRows);
-        let condition;
-        if (this.#conds.length === 0) {
-            condition = undefined;
-        }
-        else if (this.#conds.length === 1) {
-            condition = this.#conds[0];
-        }
-        else {
-            condition = { type: "and", conds: this.#conds.slice() };
-        }
-        const proto = { stmt, condition };
-        return new Promise((outputCallback, errorCallback) => {
-            const callback = (stepResult, stepError) => {
-                if (stepResult !== undefined && stepError !== undefined) {
-                    errorCallback(new ProtoError("Server returned both result and error"));
-                }
-                else if (stepError !== undefined) {
-                    errorCallback(errorFromProto(stepError));
-                }
-                else if (stepResult !== undefined) {
-                    outputCallback(fromProto(stepResult, this._batch._stream.intMode));
-                }
-                else {
-                    outputCallback(undefined);
-                }
-            };
-            this._index = this._batch._steps.length;
-            this._batch._steps.push({ proto, callback });
-        });
-    }
-}
-export class BatchCond {
-    /** @private */
-    _batch;
-    /** @private */
-    _proto;
-    /** @private */
-    constructor(batch, proto) {
-        this._batch = batch;
-        this._proto = proto;
-    }
-    /** Create a condition that evaluates to true when the given step executes successfully.
-     *
-     * If the given step fails error or is skipped because its condition evaluated to false, this
-     * condition evaluates to false.
-     */
-    static ok(step) {
-        return new BatchCond(step._batch, { type: "ok", step: stepIndex(step) });
-    }
-    /** Create a condition that evaluates to true when the given step fails.
-     *
-     * If the given step succeeds or is skipped because its condition evaluated to false, this condition
-     * evaluates to false.
-     */
-    static error(step) {
-        return new BatchCond(step._batch, { type: "error", step: stepIndex(step) });
-    }
-    /** Create a condition that is a logical negation of another condition.
-     */
-    static not(cond) {
-        return new BatchCond(cond._batch, { type: "not", cond: cond._proto });
-    }
-    /** Create a condition that is a logical AND of other conditions.
-     */
-    static and(batch, conds) {
-        for (const cond of conds) {
-            checkCondBatch(batch, cond);
-        }
-        return new BatchCond(batch, { type: "and", conds: conds.map(e => e._proto) });
-    }
-    /** Create a condition that is a logical OR of other conditions.
-     */
-    static or(batch, conds) {
-        for (const cond of conds) {
-            checkCondBatch(batch, cond);
-        }
-        return new BatchCond(batch, { type: "or", conds: conds.map(e => e._proto) });
-    }
-    /** Create a condition that evaluates to true when the SQL connection is in autocommit mode (not inside an
-     * explicit transaction). This requires protocol version 3 or higher.
-     */
-    static isAutocommit(batch) {
-        batch._stream.client()._ensureVersion(3, "BatchCond.isAutocommit()");
-        return new BatchCond(batch, { type: "is_autocommit" });
-    }
-}
-function stepIndex(step) {
-    if (step._index === undefined) {
-        throw new MisuseError("Cannot add a condition referencing a step that has not been added to the batch");
-    }
-    return step._index;
-}
-function checkCondBatch(expectedBatch, cond) {
-    if (cond._batch !== expectedBatch) {
-        throw new MisuseError("Cannot mix BatchCond objects for different Batch objects");
-    }
-}

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

@@ -1,45 +0,0 @@
-export class ByteQueue {
-    #array;
-    #shiftPos;
-    #pushPos;
-    constructor(initialCap) {
-        this.#array = new Uint8Array(new ArrayBuffer(initialCap));
-        this.#shiftPos = 0;
-        this.#pushPos = 0;
-    }
-    get length() {
-        return this.#pushPos - this.#shiftPos;
-    }
-    data() {
-        return this.#array.slice(this.#shiftPos, this.#pushPos);
-    }
-    push(chunk) {
-        this.#ensurePush(chunk.byteLength);
-        this.#array.set(chunk, this.#pushPos);
-        this.#pushPos += chunk.byteLength;
-    }
-    #ensurePush(pushLength) {
-        if (this.#pushPos + pushLength <= this.#array.byteLength) {
-            return;
-        }
-        const filledLength = this.#pushPos - this.#shiftPos;
-        if (filledLength + pushLength <= this.#array.byteLength &&
-            2 * this.#pushPos >= this.#array.byteLength) {
-            this.#array.copyWithin(0, this.#shiftPos, this.#pushPos);
-        }
-        else {
-            let newCap = this.#array.byteLength;
-            do {
-                newCap *= 2;
-            } while (filledLength + pushLength > newCap);
-            const newArray = new Uint8Array(new ArrayBuffer(newCap));
-            newArray.set(this.#array.slice(this.#shiftPos, this.#pushPos), 0);
-            this.#array = newArray;
-        }
-        this.#pushPos = filledLength;
-        this.#shiftPos = 0;
-    }
-    shift(length) {
-        this.#shiftPos += length;
-    }
-}

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

@@ -1,13 +0,0 @@
-/** A client for the Hrana protocol (a "database connection pool"). */
-export class Client {
-    /** @private */
-    constructor() {
-        this.intMode = "number";
-    }
-    /** Representation of integers returned from the database. See {@link IntMode}.
-     *
-     * This value is inherited by {@link Stream} objects created with {@link openStream}, but you can
-     * override the integer mode for every stream by setting {@link Stream.intMode} on the stream.
-     */
-    intMode;
-}

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

@@ -1,2 +0,0 @@
-export class Cursor {
-}

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

@@ -1,8 +0,0 @@
-export function describeResultFromProto(result) {
-    return {
-        paramNames: result.params.map((p) => p.name),
-        columns: result.cols,
-        isExplain: result.isExplain,
-        isReadonly: result.isReadonly,
-    };
-}

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

@@ -1,4 +0,0 @@
-export { readJsonObject } from "./json/decode.js";
-export { writeJsonObject } from "./json/encode.js";
-export { readProtobufMessage } from "./protobuf/decode.js";
-export { writeProtobufMessage } from "./protobuf/encode.js";

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

@@ -1,59 +0,0 @@
-import { ProtoError } from "../../errors.js";
-export function string(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    throw typeError(value, "string");
-}
-export function stringOpt(value) {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    throw typeError(value, "string or null");
-}
-export function number(value) {
-    if (typeof value === "number") {
-        return value;
-    }
-    throw typeError(value, "number");
-}
-export function boolean(value) {
-    if (typeof value === "boolean") {
-        return value;
-    }
-    throw typeError(value, "boolean");
-}
-export function array(value) {
-    if (Array.isArray(value)) {
-        return value;
-    }
-    throw typeError(value, "array");
-}
-export function object(value) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    throw typeError(value, "object");
-}
-export function arrayObjectsMap(value, fun) {
-    return array(value).map((elemValue) => fun(object(elemValue)));
-}
-function typeError(value, expected) {
-    if (value === undefined) {
-        return new ProtoError(`Expected ${expected}, but the property was missing`);
-    }
-    let received = typeof value;
-    if (value === null) {
-        received = "null";
-    }
-    else if (Array.isArray(value)) {
-        received = "array";
-    }
-    return new ProtoError(`Expected ${expected}, received ${received}`);
-}
-export function readJsonObject(value, fun) {
-    return fun(object(value));
-}

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

@@ -1,72 +0,0 @@
-export class ObjectWriter {
-    #output;
-    #isFirst;
-    constructor(output) {
-        this.#output = output;
-        this.#isFirst = false;
-    }
-    begin() {
-        this.#output.push('{');
-        this.#isFirst = true;
-    }
-    end() {
-        this.#output.push('}');
-        this.#isFirst = false;
-    }
-    #key(name) {
-        if (this.#isFirst) {
-            this.#output.push('"');
-            this.#isFirst = false;
-        }
-        else {
-            this.#output.push(',"');
-        }
-        this.#output.push(name);
-        this.#output.push('":');
-    }
-    string(name, value) {
-        this.#key(name);
-        this.#output.push(JSON.stringify(value));
-    }
-    stringRaw(name, value) {
-        this.#key(name);
-        this.#output.push('"');
-        this.#output.push(value);
-        this.#output.push('"');
-    }
-    number(name, value) {
-        this.#key(name);
-        this.#output.push("" + value);
-    }
-    boolean(name, value) {
-        this.#key(name);
-        this.#output.push(value ? "true" : "false");
-    }
-    object(name, value, valueFun) {
-        this.#key(name);
-        this.begin();
-        valueFun(this, value);
-        this.end();
-    }
-    arrayObjects(name, values, valueFun) {
-        this.#key(name);
-        this.#output.push('[');
-        for (let i = 0; i < values.length; ++i) {
-            if (i !== 0) {
-                this.#output.push(',');
-            }
-            this.begin();
-            valueFun(this, values[i]);
-            this.end();
-        }
-        this.#output.push(']');
-    }
-}
-export function writeJsonObject(value, fun) {
-    const output = [];
-    const writer = new ObjectWriter(output);
-    writer.begin();
-    fun(writer, value);
-    writer.end();
-    return output.join("");
-}

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

@@ -1,150 +0,0 @@
-import { ProtoError } from "../../errors.js";
-import { VARINT, FIXED_64, LENGTH_DELIMITED, FIXED_32 } from "./util.js";
-class MessageReader {
-    #array;
-    #view;
-    #pos;
-    constructor(array) {
-        this.#array = array;
-        this.#view = new DataView(array.buffer, array.byteOffset, array.byteLength);
-        this.#pos = 0;
-    }
-    varint() {
-        let value = 0;
-        for (let shift = 0;; shift += 7) {
-            const byte = this.#array[this.#pos++];
-            value |= (byte & 0x7f) << shift;
-            if (!(byte & 0x80)) {
-                break;
-            }
-        }
-        return value;
-    }
-    varintBig() {
-        let value = 0n;
-        for (let shift = 0n;; shift += 7n) {
-            const byte = this.#array[this.#pos++];
-            value |= BigInt(byte & 0x7f) << shift;
-            if (!(byte & 0x80)) {
-                break;
-            }
-        }
-        return value;
-    }
-    bytes(length) {
-        const array = new Uint8Array(this.#array.buffer, this.#array.byteOffset + this.#pos, length);
-        this.#pos += length;
-        return array;
-    }
-    double() {
-        const value = this.#view.getFloat64(this.#pos, true);
-        this.#pos += 8;
-        return value;
-    }
-    skipVarint() {
-        for (;;) {
-            const byte = this.#array[this.#pos++];
-            if (!(byte & 0x80)) {
-                break;
-            }
-        }
-    }
-    skip(count) {
-        this.#pos += count;
-    }
-    eof() {
-        return this.#pos >= this.#array.byteLength;
-    }
-}
-export class FieldReader {
-    #reader;
-    #wireType;
-    constructor(reader) {
-        this.#reader = reader;
-        this.#wireType = -1;
-    }
-    setup(wireType) {
-        this.#wireType = wireType;
-    }
-    #expect(expectedWireType) {
-        if (this.#wireType !== expectedWireType) {
-            throw new ProtoError(`Expected wire type ${expectedWireType}, got ${this.#wireType}`);
-        }
-        this.#wireType = -1;
-    }
-    bytes() {
-        this.#expect(LENGTH_DELIMITED);
-        const length = this.#reader.varint();
-        return this.#reader.bytes(length);
-    }
-    string() {
-        return new TextDecoder().decode(this.bytes());
-    }
-    message(def) {
-        return readProtobufMessage(this.bytes(), def);
-    }
-    int32() {
-        this.#expect(VARINT);
-        return this.#reader.varint();
-    }
-    uint32() {
-        return this.int32();
-    }
-    bool() {
-        return this.int32() !== 0;
-    }
-    uint64() {
-        this.#expect(VARINT);
-        return this.#reader.varintBig();
-    }
-    sint64() {
-        const value = this.uint64();
-        return (value >> 1n) ^ (-(value & 1n));
-    }
-    double() {
-        this.#expect(FIXED_64);
-        return this.#reader.double();
-    }
-    maybeSkip() {
-        if (this.#wireType < 0) {
-            return;
-        }
-        else if (this.#wireType === VARINT) {
-            this.#reader.skipVarint();
-        }
-        else if (this.#wireType === FIXED_64) {
-            this.#reader.skip(8);
-        }
-        else if (this.#wireType === LENGTH_DELIMITED) {
-            const length = this.#reader.varint();
-            this.#reader.skip(length);
-        }
-        else if (this.#wireType === FIXED_32) {
-            this.#reader.skip(4);
-        }
-        else {
-            throw new ProtoError(`Unexpected wire type ${this.#wireType}`);
-        }
-        this.#wireType = -1;
-    }
-}
-export function readProtobufMessage(data, def) {
-    const msgReader = new MessageReader(data);
-    const fieldReader = new FieldReader(msgReader);
-    let value = def.default();
-    while (!msgReader.eof()) {
-        const key = msgReader.varint();
-        const tag = key >> 3;
-        const wireType = key & 0x7;
-        fieldReader.setup(wireType);
-        const tagFun = def[tag];
-        if (tagFun !== undefined) {
-            const returnedValue = tagFun(fieldReader, value);
-            if (returnedValue !== undefined) {
-                value = returnedValue;
-            }
-        }
-        fieldReader.maybeSkip();
-    }
-    return value;
-}