orcaq 1.1.1 → 1.1.3

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

@@ -0,0 +1,48 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/shared/json_decode.js

@@ -0,0 +1,106 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/shared/json_encode.js

@@ -0,0 +1,71 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/shared/protobuf_decode.js

@@ -0,0 +1,115 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/shared/protobuf_encode.js

@@ -0,0 +1,85 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/sql.js

@@ -0,0 +1,46 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/stmt.js

@@ -0,0 +1,76 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/stream.js

@@ -0,0 +1,57 @@
+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/.output/server/node_modules/@libsql/hrana-client/lib-esm/util.js

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

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

@@ -0,0 +1,83 @@
+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");
+    }
+}