orcaq 1.1.1 → 1.1.2

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,150 @@
+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;
+}