@minimalcorp/tsunagi 0.0.4 → 0.0.6

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

@@ -1,48 +0,0 @@
-import { ResponseError } from "./errors.js";
-import { valueFromProto } from "./value.js";
-export function stmtResultFromProto(result) {
-    return {
-        affectedRowCount: result.affectedRowCount,
-        lastInsertRowid: result.lastInsertRowid,
-        columnNames: result.cols.map(col => col.name),
-        columnDecltypes: result.cols.map(col => col.decltype),
-    };
-}
-export function rowsResultFromProto(result, intMode) {
-    const stmtResult = stmtResultFromProto(result);
-    const rows = result.rows.map(row => rowFromProto(stmtResult.columnNames, row, intMode));
-    return { ...stmtResult, rows };
-}
-export function rowResultFromProto(result, intMode) {
-    const stmtResult = stmtResultFromProto(result);
-    let row;
-    if (result.rows.length > 0) {
-        row = rowFromProto(stmtResult.columnNames, result.rows[0], intMode);
-    }
-    return { ...stmtResult, row };
-}
-export function valueResultFromProto(result, intMode) {
-    const stmtResult = stmtResultFromProto(result);
-    let value;
-    if (result.rows.length > 0 && stmtResult.columnNames.length > 0) {
-        value = valueFromProto(result.rows[0][0], intMode);
-    }
-    return { ...stmtResult, value };
-}
-function rowFromProto(colNames, values, intMode) {
-    const row = {};
-    // make sure that the "length" property is not enumerable
-    Object.defineProperty(row, "length", { value: values.length });
-    for (let i = 0; i < values.length; ++i) {
-        const value = valueFromProto(values[i], intMode);
-        Object.defineProperty(row, i, { value });
-        const colName = colNames[i];
-        if (colName !== undefined && !Object.hasOwn(row, colName)) {
-            Object.defineProperty(row, colName, { value, enumerable: true, configurable: true, writable: true });
-        }
-    }
-    return row;
-}
-export function errorFromProto(error) {
-    return new ResponseError(error.message, error);
-}

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

@@ -1,106 +0,0 @@
-import { Base64 } from "js-base64";
-import { ProtoError } from "../errors.js";
-import * as d from "../encoding/json/decode.js";
-export function Error(obj) {
-    const message = d.string(obj["message"]);
-    const code = d.stringOpt(obj["code"]);
-    return { message, code };
-}
-export function StmtResult(obj) {
-    const cols = d.arrayObjectsMap(obj["cols"], Col);
-    const rows = d.array(obj["rows"]).map((rowObj) => d.arrayObjectsMap(rowObj, Value));
-    const affectedRowCount = d.number(obj["affected_row_count"]);
-    const lastInsertRowidStr = d.stringOpt(obj["last_insert_rowid"]);
-    const lastInsertRowid = lastInsertRowidStr !== undefined
-        ? BigInt(lastInsertRowidStr) : undefined;
-    return { cols, rows, affectedRowCount, lastInsertRowid };
-}
-function Col(obj) {
-    const name = d.stringOpt(obj["name"]);
-    const decltype = d.stringOpt(obj["decltype"]);
-    return { name, decltype };
-}
-export function BatchResult(obj) {
-    const stepResults = new Map();
-    d.array(obj["step_results"]).forEach((value, i) => {
-        if (value !== null) {
-            stepResults.set(i, StmtResult(d.object(value)));
-        }
-    });
-    const stepErrors = new Map();
-    d.array(obj["step_errors"]).forEach((value, i) => {
-        if (value !== null) {
-            stepErrors.set(i, Error(d.object(value)));
-        }
-    });
-    return { stepResults, stepErrors };
-}
-export function CursorEntry(obj) {
-    const type = d.string(obj["type"]);
-    if (type === "step_begin") {
-        const step = d.number(obj["step"]);
-        const cols = d.arrayObjectsMap(obj["cols"], Col);
-        return { type: "step_begin", step, cols };
-    }
-    else if (type === "step_end") {
-        const affectedRowCount = d.number(obj["affected_row_count"]);
-        const lastInsertRowidStr = d.stringOpt(obj["last_insert_rowid"]);
-        const lastInsertRowid = lastInsertRowidStr !== undefined
-            ? BigInt(lastInsertRowidStr) : undefined;
-        return { type: "step_end", affectedRowCount, lastInsertRowid };
-    }
-    else if (type === "step_error") {
-        const step = d.number(obj["step"]);
-        const error = Error(d.object(obj["error"]));
-        return { type: "step_error", step, error };
-    }
-    else if (type === "row") {
-        const row = d.arrayObjectsMap(obj["row"], Value);
-        return { type: "row", row };
-    }
-    else if (type === "error") {
-        const error = Error(d.object(obj["error"]));
-        return { type: "error", error };
-    }
-    else {
-        throw new ProtoError("Unexpected type of CursorEntry");
-    }
-}
-export function DescribeResult(obj) {
-    const params = d.arrayObjectsMap(obj["params"], DescribeParam);
-    const cols = d.arrayObjectsMap(obj["cols"], DescribeCol);
-    const isExplain = d.boolean(obj["is_explain"]);
-    const isReadonly = d.boolean(obj["is_readonly"]);
-    return { params, cols, isExplain, isReadonly };
-}
-function DescribeParam(obj) {
-    const name = d.stringOpt(obj["name"]);
-    return { name };
-}
-function DescribeCol(obj) {
-    const name = d.string(obj["name"]);
-    const decltype = d.stringOpt(obj["decltype"]);
-    return { name, decltype };
-}
-export function Value(obj) {
-    const type = d.string(obj["type"]);
-    if (type === "null") {
-        return null;
-    }
-    else if (type === "integer") {
-        const value = d.string(obj["value"]);
-        return BigInt(value);
-    }
-    else if (type === "float") {
-        return d.number(obj["value"]);
-    }
-    else if (type === "text") {
-        return d.string(obj["value"]);
-    }
-    else if (type === "blob") {
-        return Base64.toUint8Array(d.string(obj["base64"]));
-    }
-    else {
-        throw new ProtoError("Unexpected type of Value");
-    }
-}

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

@@ -1,71 +0,0 @@
-import { Base64 } from "js-base64";
-import { impossible } from "../util.js";
-export function Stmt(w, msg) {
-    if (msg.sql !== undefined) {
-        w.string("sql", msg.sql);
-    }
-    if (msg.sqlId !== undefined) {
-        w.number("sql_id", msg.sqlId);
-    }
-    w.arrayObjects("args", msg.args, Value);
-    w.arrayObjects("named_args", msg.namedArgs, NamedArg);
-    w.boolean("want_rows", msg.wantRows);
-}
-function NamedArg(w, msg) {
-    w.string("name", msg.name);
-    w.object("value", msg.value, Value);
-}
-export function Batch(w, msg) {
-    w.arrayObjects("steps", msg.steps, BatchStep);
-}
-function BatchStep(w, msg) {
-    if (msg.condition !== undefined) {
-        w.object("condition", msg.condition, BatchCond);
-    }
-    w.object("stmt", msg.stmt, Stmt);
-}
-function BatchCond(w, msg) {
-    w.stringRaw("type", msg.type);
-    if (msg.type === "ok" || msg.type === "error") {
-        w.number("step", msg.step);
-    }
-    else if (msg.type === "not") {
-        w.object("cond", msg.cond, BatchCond);
-    }
-    else if (msg.type === "and" || msg.type === "or") {
-        w.arrayObjects("conds", msg.conds, BatchCond);
-    }
-    else if (msg.type === "is_autocommit") {
-        // do nothing
-    }
-    else {
-        throw impossible(msg, "Impossible type of BatchCond");
-    }
-}
-function Value(w, msg) {
-    if (msg === null) {
-        w.stringRaw("type", "null");
-    }
-    else if (typeof msg === "bigint") {
-        w.stringRaw("type", "integer");
-        w.stringRaw("value", "" + msg);
-    }
-    else if (typeof msg === "number") {
-        w.stringRaw("type", "float");
-        w.number("value", msg);
-    }
-    else if (typeof msg === "string") {
-        w.stringRaw("type", "text");
-        w.string("value", msg);
-    }
-    else if (msg instanceof Uint8Array) {
-        w.stringRaw("type", "blob");
-        w.stringRaw("base64", Base64.fromUint8Array(msg));
-    }
-    else if (msg === undefined) {
-        // do nothing
-    }
-    else {
-        throw impossible(msg, "Impossible type of Value");
-    }
-}

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

@@ -1,2 +0,0 @@
-// Types for the protocol structures that are shared for WebSocket and HTTP
-export {};

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

@@ -1,115 +0,0 @@
-export const Error = {
-    default() { return { message: "", code: undefined }; },
-    1(r, msg) { msg.message = r.string(); },
-    2(r, msg) { msg.code = r.string(); },
-};
-export const StmtResult = {
-    default() {
-        return {
-            cols: [],
-            rows: [],
-            affectedRowCount: 0,
-            lastInsertRowid: undefined,
-        };
-    },
-    1(r, msg) { msg.cols.push(r.message(Col)); },
-    2(r, msg) { msg.rows.push(r.message(Row)); },
-    3(r, msg) { msg.affectedRowCount = Number(r.uint64()); },
-    4(r, msg) { msg.lastInsertRowid = r.sint64(); },
-};
-const Col = {
-    default() { return { name: undefined, decltype: undefined }; },
-    1(r, msg) { msg.name = r.string(); },
-    2(r, msg) { msg.decltype = r.string(); },
-};
-const Row = {
-    default() { return []; },
-    1(r, msg) { msg.push(r.message(Value)); },
-};
-export const BatchResult = {
-    default() { return { stepResults: new Map(), stepErrors: new Map() }; },
-    1(r, msg) {
-        const [key, value] = r.message(BatchResultStepResult);
-        msg.stepResults.set(key, value);
-    },
-    2(r, msg) {
-        const [key, value] = r.message(BatchResultStepError);
-        msg.stepErrors.set(key, value);
-    },
-};
-const BatchResultStepResult = {
-    default() { return [0, StmtResult.default()]; },
-    1(r, msg) { msg[0] = r.uint32(); },
-    2(r, msg) { msg[1] = r.message(StmtResult); },
-};
-const BatchResultStepError = {
-    default() { return [0, Error.default()]; },
-    1(r, msg) { msg[0] = r.uint32(); },
-    2(r, msg) { msg[1] = r.message(Error); },
-};
-export const CursorEntry = {
-    default() { return { type: "none" }; },
-    1(r) { return r.message(StepBeginEntry); },
-    2(r) { return r.message(StepEndEntry); },
-    3(r) { return r.message(StepErrorEntry); },
-    4(r) { return { type: "row", row: r.message(Row) }; },
-    5(r) { return { type: "error", error: r.message(Error) }; },
-};
-const StepBeginEntry = {
-    default() { return { type: "step_begin", step: 0, cols: [] }; },
-    1(r, msg) { msg.step = r.uint32(); },
-    2(r, msg) { msg.cols.push(r.message(Col)); },
-};
-const StepEndEntry = {
-    default() {
-        return {
-            type: "step_end",
-            affectedRowCount: 0,
-            lastInsertRowid: undefined,
-        };
-    },
-    1(r, msg) { msg.affectedRowCount = r.uint32(); },
-    2(r, msg) { msg.lastInsertRowid = r.uint64(); },
-};
-const StepErrorEntry = {
-    default() {
-        return {
-            type: "step_error",
-            step: 0,
-            error: Error.default(),
-        };
-    },
-    1(r, msg) { msg.step = r.uint32(); },
-    2(r, msg) { msg.error = r.message(Error); },
-};
-export const DescribeResult = {
-    default() {
-        return {
-            params: [],
-            cols: [],
-            isExplain: false,
-            isReadonly: false,
-        };
-    },
-    1(r, msg) { msg.params.push(r.message(DescribeParam)); },
-    2(r, msg) { msg.cols.push(r.message(DescribeCol)); },
-    3(r, msg) { msg.isExplain = r.bool(); },
-    4(r, msg) { msg.isReadonly = r.bool(); },
-};
-const DescribeParam = {
-    default() { return { name: undefined }; },
-    1(r, msg) { msg.name = r.string(); },
-};
-const DescribeCol = {
-    default() { return { name: "", decltype: undefined }; },
-    1(r, msg) { msg.name = r.string(); },
-    2(r, msg) { msg.decltype = r.string(); },
-};
-const Value = {
-    default() { return undefined; },
-    1(r) { return null; },
-    2(r) { return r.sint64(); },
-    3(r) { return r.double(); },
-    4(r) { return r.string(); },
-    5(r) { return r.bytes(); },
-};

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

@@ -1,85 +0,0 @@
-import { impossible } from "../util.js";
-export function Stmt(w, msg) {
-    if (msg.sql !== undefined) {
-        w.string(1, msg.sql);
-    }
-    if (msg.sqlId !== undefined) {
-        w.int32(2, msg.sqlId);
-    }
-    for (const arg of msg.args) {
-        w.message(3, arg, Value);
-    }
-    for (const arg of msg.namedArgs) {
-        w.message(4, arg, NamedArg);
-    }
-    w.bool(5, msg.wantRows);
-}
-function NamedArg(w, msg) {
-    w.string(1, msg.name);
-    w.message(2, msg.value, Value);
-}
-export function Batch(w, msg) {
-    for (const step of msg.steps) {
-        w.message(1, step, BatchStep);
-    }
-}
-function BatchStep(w, msg) {
-    if (msg.condition !== undefined) {
-        w.message(1, msg.condition, BatchCond);
-    }
-    w.message(2, msg.stmt, Stmt);
-}
-function BatchCond(w, msg) {
-    if (msg.type === "ok") {
-        w.uint32(1, msg.step);
-    }
-    else if (msg.type === "error") {
-        w.uint32(2, msg.step);
-    }
-    else if (msg.type === "not") {
-        w.message(3, msg.cond, BatchCond);
-    }
-    else if (msg.type === "and") {
-        w.message(4, msg.conds, BatchCondList);
-    }
-    else if (msg.type === "or") {
-        w.message(5, msg.conds, BatchCondList);
-    }
-    else if (msg.type === "is_autocommit") {
-        w.message(6, undefined, Empty);
-    }
-    else {
-        throw impossible(msg, "Impossible type of BatchCond");
-    }
-}
-function BatchCondList(w, msg) {
-    for (const cond of msg) {
-        w.message(1, cond, BatchCond);
-    }
-}
-function Value(w, msg) {
-    if (msg === null) {
-        w.message(1, undefined, Empty);
-    }
-    else if (typeof msg === "bigint") {
-        w.sint64(2, msg);
-    }
-    else if (typeof msg === "number") {
-        w.double(3, msg);
-    }
-    else if (typeof msg === "string") {
-        w.string(4, msg);
-    }
-    else if (msg instanceof Uint8Array) {
-        w.bytes(5, msg);
-    }
-    else if (msg === undefined) {
-        // do nothing
-    }
-    else {
-        throw impossible(msg, "Impossible type of Value");
-    }
-}
-function Empty(_w, _msg) {
-    // do nothing
-}

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

@@ -1,46 +0,0 @@
-import { ClientError, ClosedError, MisuseError } from "./errors.js";
-/** Text of an SQL statement cached on the server. */
-export class Sql {
-    #owner;
-    #sqlId;
-    #closed;
-    /** @private */
-    constructor(owner, sqlId) {
-        this.#owner = owner;
-        this.#sqlId = sqlId;
-        this.#closed = undefined;
-    }
-    /** @private */
-    _getSqlId(owner) {
-        if (this.#owner !== owner) {
-            throw new MisuseError("Attempted to use SQL text opened with other object");
-        }
-        else if (this.#closed !== undefined) {
-            throw new ClosedError("SQL text is closed", this.#closed);
-        }
-        return this.#sqlId;
-    }
-    /** Remove the SQL text from the server, releasing resouces. */
-    close() {
-        this._setClosed(new ClientError("SQL text was manually closed"));
-    }
-    /** @private */
-    _setClosed(error) {
-        if (this.#closed === undefined) {
-            this.#closed = error;
-            this.#owner._closeSql(this.#sqlId);
-        }
-    }
-    /** True if the SQL text is closed (removed from the server). */
-    get closed() {
-        return this.#closed !== undefined;
-    }
-}
-export function sqlToProto(owner, sql) {
-    if (sql instanceof Sql) {
-        return { sqlId: sql._getSqlId(owner) };
-    }
-    else {
-        return { sql: "" + sql };
-    }
-}

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

@@ -1,76 +0,0 @@
-import { sqlToProto } from "./sql.js";
-import { valueToProto } from "./value.js";
-/** A statement that can be evaluated by the database. Besides the SQL text, it also contains the positional
- * and named arguments. */
-export class Stmt {
-    /** The SQL statement text. */
-    sql;
-    /** @private */
-    _args;
-    /** @private */
-    _namedArgs;
-    /** Initialize the statement with given SQL text. */
-    constructor(sql) {
-        this.sql = sql;
-        this._args = [];
-        this._namedArgs = new Map();
-    }
-    /** Binds positional parameters from the given `values`. All previous positional bindings are cleared. */
-    bindIndexes(values) {
-        this._args.length = 0;
-        for (const value of values) {
-            this._args.push(valueToProto(value));
-        }
-        return this;
-    }
-    /** Binds a parameter by a 1-based index. */
-    bindIndex(index, value) {
-        if (index !== (index | 0) || index <= 0) {
-            throw new RangeError("Index of a positional argument must be positive integer");
-        }
-        while (this._args.length < index) {
-            this._args.push(null);
-        }
-        this._args[index - 1] = valueToProto(value);
-        return this;
-    }
-    /** Binds a parameter by name. */
-    bindName(name, value) {
-        this._namedArgs.set(name, valueToProto(value));
-        return this;
-    }
-    /** Clears all bindings. */
-    unbindAll() {
-        this._args.length = 0;
-        this._namedArgs.clear();
-        return this;
-    }
-}
-export function stmtToProto(sqlOwner, stmt, wantRows) {
-    let inSql;
-    let args = [];
-    let namedArgs = [];
-    if (stmt instanceof Stmt) {
-        inSql = stmt.sql;
-        args = stmt._args;
-        for (const [name, value] of stmt._namedArgs.entries()) {
-            namedArgs.push({ name, value });
-        }
-    }
-    else if (Array.isArray(stmt)) {
-        inSql = stmt[0];
-        if (Array.isArray(stmt[1])) {
-            args = stmt[1].map((arg) => valueToProto(arg));
-        }
-        else {
-            namedArgs = Object.entries(stmt[1]).map(([name, value]) => {
-                return { name, value: valueToProto(value) };
-            });
-        }
-    }
-    else {
-        inSql = stmt;
-    }
-    const { sql, sqlId } = sqlToProto(sqlOwner, inSql);
-    return { sql, sqlId, args, namedArgs, wantRows };
-}

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

@@ -1,57 +0,0 @@
-import { Batch } from "./batch.js";
-import { describeResultFromProto } from "./describe.js";
-import { stmtResultFromProto, rowsResultFromProto, rowResultFromProto, valueResultFromProto, } from "./result.js";
-import { sqlToProto } from "./sql.js";
-import { stmtToProto } from "./stmt.js";
-/** A stream for executing SQL statements (a "database connection"). */
-export class Stream {
-    /** @private */
-    constructor(intMode) {
-        this.intMode = intMode;
-    }
-    /** Execute a statement and return rows. */
-    query(stmt) {
-        return this.#execute(stmt, true, rowsResultFromProto);
-    }
-    /** Execute a statement and return at most a single row. */
-    queryRow(stmt) {
-        return this.#execute(stmt, true, rowResultFromProto);
-    }
-    /** Execute a statement and return at most a single value. */
-    queryValue(stmt) {
-        return this.#execute(stmt, true, valueResultFromProto);
-    }
-    /** Execute a statement without returning rows. */
-    run(stmt) {
-        return this.#execute(stmt, false, stmtResultFromProto);
-    }
-    #execute(inStmt, wantRows, fromProto) {
-        const stmt = stmtToProto(this._sqlOwner(), inStmt, wantRows);
-        return this._execute(stmt).then((r) => fromProto(r, this.intMode));
-    }
-    /** Return a builder for creating and executing a batch.
-     *
-     * If `useCursor` is true, the batch will be executed using a Hrana cursor, which will stream results from
-     * the server to the client, which consumes less memory on the server. This requires protocol version 3 or
-     * higher.
-     */
-    batch(useCursor = false) {
-        return new Batch(this, useCursor);
-    }
-    /** Parse and analyze a statement. This requires protocol version 2 or higher. */
-    describe(inSql) {
-        const protoSql = sqlToProto(this._sqlOwner(), inSql);
-        return this._describe(protoSql).then(describeResultFromProto);
-    }
-    /** Execute a sequence of statements separated by semicolons. This requires protocol version 2 or higher.
-     * */
-    sequence(inSql) {
-        const protoSql = sqlToProto(this._sqlOwner(), inSql);
-        return this._sequence(protoSql);
-    }
-    /** Representation of integers returned from the database. See {@link IntMode}.
-     *
-     * This value affects the results of all operations on this stream.
-     */
-    intMode;
-}

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

@@ -1,4 +0,0 @@
-import { InternalError } from "./errors.js";
-export function impossible(value, message) {
-    throw new InternalError(message);
-}