orcaq 1.1.1 → 1.1.2

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

@@ -0,0 +1,87 @@
+export class SqlCache {
+    #owner;
+    #sqls;
+    capacity;
+    constructor(owner, capacity) {
+        this.#owner = owner;
+        this.#sqls = new Lru();
+        this.capacity = capacity;
+    }
+    // Replaces SQL strings with cached `hrana.Sql` objects in the statements in `hranaStmts`. After this
+    // function returns, we guarantee that all `hranaStmts` refer to valid (not closed) `hrana.Sql` objects,
+    // but _we may invalidate any other `hrana.Sql` objects_ (by closing them, thus removing them from the
+    // server).
+    //
+    // In practice, this means that after calling this function, you can use the statements only up to the
+    // first `await`, because concurrent code may also use the cache and invalidate those statements.
+    apply(hranaStmts) {
+        if (this.capacity <= 0) {
+            return;
+        }
+        const usedSqlObjs = new Set();
+        for (const hranaStmt of hranaStmts) {
+            if (typeof hranaStmt.sql !== "string") {
+                continue;
+            }
+            const sqlText = hranaStmt.sql;
+            // Stored SQL cannot exceed 5kb.
+            // https://github.com/tursodatabase/libsql/blob/e9d637e051685f92b0da43849507b5ef4232fbeb/libsql-server/src/hrana/http/request.rs#L10
+            if (sqlText.length >= 5000) {
+                continue;
+            }
+            let sqlObj = this.#sqls.get(sqlText);
+            if (sqlObj === undefined) {
+                while (this.#sqls.size + 1 > this.capacity) {
+                    const [evictSqlText, evictSqlObj] = this.#sqls.peekLru();
+                    if (usedSqlObjs.has(evictSqlObj)) {
+                        // The SQL object that we are trying to evict is already in use in this batch, so we
+                        // must not evict and close it.
+                        break;
+                    }
+                    evictSqlObj.close();
+                    this.#sqls.delete(evictSqlText);
+                }
+                if (this.#sqls.size + 1 <= this.capacity) {
+                    sqlObj = this.#owner.storeSql(sqlText);
+                    this.#sqls.set(sqlText, sqlObj);
+                }
+            }
+            if (sqlObj !== undefined) {
+                hranaStmt.sql = sqlObj;
+                usedSqlObjs.add(sqlObj);
+            }
+        }
+    }
+}
+class Lru {
+    // This maps keys to the cache values. The entries are ordered by their last use (entires that were used
+    // most recently are at the end).
+    #cache;
+    constructor() {
+        this.#cache = new Map();
+    }
+    get(key) {
+        const value = this.#cache.get(key);
+        if (value !== undefined) {
+            // move the entry to the back of the Map
+            this.#cache.delete(key);
+            this.#cache.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        this.#cache.set(key, value);
+    }
+    peekLru() {
+        for (const entry of this.#cache.entries()) {
+            return entry;
+        }
+        return undefined;
+    }
+    delete(key) {
+        this.#cache.delete(key);
+    }
+    get size() {
+        return this.#cache.size;
+    }
+}

package/.output/server/node_modules/@libsql/client/package.json

@@ -0,0 +1,123 @@
+{
+  "name": "@libsql/client",
+  "version": "0.15.15",
+  "keywords": [
+    "libsql",
+    "database",
+    "sqlite",
+    "serverless",
+    "vercel",
+    "netlify",
+    "lambda"
+  ],
+  "description": "libSQL driver for TypeScript and JavaScript",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libsql/libsql-client-ts",
+    "directory": "packages/libsql-client"
+  },
+  "authors": [
+    "Jan Špaček <honza@chiselstrike.com>",
+    "Pekka Enberg <penberg@chiselstrike.com>",
+    "Jan Plhak <jp@chiselstrike.com>"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "lib-cjs/node.js",
+  "types": "lib-esm/node.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib-esm/node.d.ts",
+      "import": {
+        "workerd": "./lib-esm/web.js",
+        "deno": "./lib-esm/node.js",
+        "edge-light": "./lib-esm/web.js",
+        "netlify": "./lib-esm/web.js",
+        "node": "./lib-esm/node.js",
+        "browser": "./lib-esm/web.js",
+        "default": "./lib-esm/node.js"
+      },
+      "require": "./lib-cjs/node.js"
+    },
+    "./node": {
+      "types": "./lib-esm/node.d.ts",
+      "import": "./lib-esm/node.js",
+      "require": "./lib-cjs/node.js"
+    },
+    "./http": {
+      "types": "./lib-esm/http.d.ts",
+      "import": "./lib-esm/http.js",
+      "require": "./lib-cjs/http.js"
+    },
+    "./ws": {
+      "types": "./lib-esm/ws.d.ts",
+      "import": "./lib-esm/ws.js",
+      "require": "./lib-cjs/ws.js"
+    },
+    "./sqlite3": {
+      "types": "./lib-esm/sqlite3.d.ts",
+      "import": "./lib-esm/sqlite3.js",
+      "require": "./lib-cjs/sqlite3.js"
+    },
+    "./web": {
+      "types": "./lib-esm/web.d.ts",
+      "import": "./lib-esm/web.js",
+      "require": "./lib-cjs/web.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./lib-esm/node.d.ts"
+      ],
+      "http": [
+        "./lib-esm/http.d.ts"
+      ],
+      "hrana": [
+        "./lib-esm/hrana.d.ts"
+      ],
+      "sqlite3": [
+        "./lib-esm/sqlite3.d.ts"
+      ],
+      "web": [
+        "./lib-esm/web.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib-cjs/**",
+    "lib-esm/**",
+    "README.md"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "prebuild": "rm -rf ./lib-cjs ./lib-esm",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.build-cjs.json",
+    "build:esm": "tsc -p tsconfig.build-esm.json",
+    "format:check": "prettier --check .",
+    "postbuild": "cp package-cjs.json ./lib-cjs/package.json",
+    "test": "jest --runInBand",
+    "typecheck": "tsc --noEmit",
+    "typedoc": "rm -rf ./docs && typedoc",
+    "lint-staged": "lint-staged"
+  },
+  "dependencies": {
+    "@libsql/core": "^0.15.14",
+    "@libsql/hrana-client": "^0.7.0",
+    "js-base64": "^3.7.5",
+    "libsql": "^0.5.22",
+    "promise-limit": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.5",
+    "@types/node": "^18.15.5",
+    "jest": "^29.3.1",
+    "lint-staged": "^15.2.2",
+    "msw": "^2.3.0",
+    "prettier": "3.2.5",
+    "ts-jest": "^29.0.5",
+    "typedoc": "^0.23.28",
+    "typescript": "^4.9.4"
+  }
+}

package/.output/server/node_modules/@libsql/core/lib-esm/api.js

@@ -0,0 +1,16 @@
+/** Error thrown by the client. */
+export class LibsqlError extends Error {
+    /** Machine-readable error code. */
+    code;
+    /** Raw numeric error code */
+    rawCode;
+    constructor(message, code, rawCode, cause) {
+        if (code !== undefined) {
+            message = `${code}: ${message}`;
+        }
+        super(message, { cause });
+        this.code = code;
+        this.rawCode = rawCode;
+        this.name = "LibsqlError";
+    }
+}

package/.output/server/node_modules/@libsql/core/lib-esm/config.js

@@ -0,0 +1,136 @@
+import { LibsqlError } from "./api.js";
+import { parseUri } from "./uri.js";
+import { supportedUrlLink } from "./util.js";
+const inMemoryMode = ":memory:";
+export function isInMemoryConfig(config) {
+    return (config.scheme === "file" &&
+        (config.path === ":memory:" || config.path.startsWith(":memory:?")));
+}
+export function expandConfig(config, preferHttp) {
+    if (typeof config !== "object") {
+        // produce a reasonable error message in the common case where users type
+        // `createClient("libsql://...")` instead of `createClient({url: "libsql://..."})`
+        throw new TypeError(`Expected client configuration as object, got ${typeof config}`);
+    }
+    let { url, authToken, tls, intMode, concurrency } = config;
+    // fill simple defaults right here
+    concurrency = Math.max(0, concurrency || 20);
+    intMode ??= "number";
+    let connectionQueryParams = []; // recognized query parameters which we sanitize through white list of valid key-value pairs
+    // convert plain :memory: url to URI format to make logic more uniform
+    if (url === inMemoryMode) {
+        url = "file::memory:";
+    }
+    // parse url parameters first and override config with update values
+    const uri = parseUri(url);
+    const originalUriScheme = uri.scheme.toLowerCase();
+    const isInMemoryMode = originalUriScheme === "file" &&
+        uri.path === inMemoryMode &&
+        uri.authority === undefined;
+    let queryParamsDef;
+    if (isInMemoryMode) {
+        queryParamsDef = {
+            cache: {
+                values: ["shared", "private"],
+                update: (key, value) => connectionQueryParams.push(`${key}=${value}`),
+            },
+        };
+    }
+    else {
+        queryParamsDef = {
+            tls: {
+                values: ["0", "1"],
+                update: (_, value) => (tls = value === "1"),
+            },
+            authToken: {
+                update: (_, value) => (authToken = value),
+            },
+        };
+    }
+    for (const { key, value } of uri.query?.pairs ?? []) {
+        if (!Object.hasOwn(queryParamsDef, key)) {
+            throw new LibsqlError(`Unsupported URL query parameter ${JSON.stringify(key)}`, "URL_PARAM_NOT_SUPPORTED");
+        }
+        const queryParamDef = queryParamsDef[key];
+        if (queryParamDef.values !== undefined &&
+            !queryParamDef.values.includes(value)) {
+            throw new LibsqlError(`Unknown value for the "${key}" query argument: ${JSON.stringify(value)}. Supported values are: [${queryParamDef.values.map((x) => '"' + x + '"').join(", ")}]`, "URL_INVALID");
+        }
+        if (queryParamDef.update !== undefined) {
+            queryParamDef?.update(key, value);
+        }
+    }
+    // fill complex defaults & validate config
+    const connectionQueryParamsString = connectionQueryParams.length === 0
+        ? ""
+        : `?${connectionQueryParams.join("&")}`;
+    const path = uri.path + connectionQueryParamsString;
+    let scheme;
+    if (originalUriScheme === "libsql") {
+        if (tls === false) {
+            if (uri.authority?.port === undefined) {
+                throw new LibsqlError('A "libsql:" URL with ?tls=0 must specify an explicit port', "URL_INVALID");
+            }
+            scheme = preferHttp ? "http" : "ws";
+        }
+        else {
+            scheme = preferHttp ? "https" : "wss";
+        }
+    }
+    else {
+        scheme = originalUriScheme;
+    }
+    if (scheme === "http" || scheme === "ws") {
+        tls ??= false;
+    }
+    else {
+        tls ??= true;
+    }
+    if (scheme !== "http" &&
+        scheme !== "ws" &&
+        scheme !== "https" &&
+        scheme !== "wss" &&
+        scheme !== "file") {
+        throw new LibsqlError('The client supports only "libsql:", "wss:", "ws:", "https:", "http:" and "file:" URLs, ' +
+            `got ${JSON.stringify(uri.scheme + ":")}. ` +
+            `For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
+    }
+    if (intMode !== "number" && intMode !== "bigint" && intMode !== "string") {
+        throw new TypeError(`Invalid value for intMode, expected "number", "bigint" or "string", got ${JSON.stringify(intMode)}`);
+    }
+    if (uri.fragment !== undefined) {
+        throw new LibsqlError(`URL fragments are not supported: ${JSON.stringify("#" + uri.fragment)}`, "URL_INVALID");
+    }
+    if (isInMemoryMode) {
+        return {
+            scheme: "file",
+            tls: false,
+            path,
+            intMode,
+            concurrency,
+            syncUrl: config.syncUrl,
+            syncInterval: config.syncInterval,
+            readYourWrites: config.readYourWrites,
+            offline: config.offline,
+            fetch: config.fetch,
+            authToken: undefined,
+            encryptionKey: undefined,
+            authority: undefined,
+        };
+    }
+    return {
+        scheme,
+        tls,
+        authority: uri.authority,
+        path,
+        authToken,
+        intMode,
+        concurrency,
+        encryptionKey: config.encryptionKey,
+        syncUrl: config.syncUrl,
+        syncInterval: config.syncInterval,
+        readYourWrites: config.readYourWrites,
+        offline: config.offline,
+        fetch: config.fetch,
+    };
+}

package/.output/server/node_modules/@libsql/core/lib-esm/uri.js

@@ -0,0 +1,120 @@
+// URI parser based on RFC 3986
+// We can't use the standard `URL` object, because we want to support relative `file:` URLs like
+// `file:relative/path/database.db`, which are not correct according to RFC 8089, which standardizes the
+// `file` scheme.
+import { LibsqlError } from "./api.js";
+export function parseUri(text) {
+    const match = URI_RE.exec(text);
+    if (match === null) {
+        throw new LibsqlError(`The URL '${text}' is not in a valid format`, "URL_INVALID");
+    }
+    const groups = match.groups;
+    const scheme = groups["scheme"];
+    const authority = groups["authority"] !== undefined
+        ? parseAuthority(groups["authority"])
+        : undefined;
+    const path = percentDecode(groups["path"]);
+    const query = groups["query"] !== undefined ? parseQuery(groups["query"]) : undefined;
+    const fragment = groups["fragment"] !== undefined
+        ? percentDecode(groups["fragment"])
+        : undefined;
+    return { scheme, authority, path, query, fragment };
+}
+const URI_RE = (() => {
+    const SCHEME = "(?<scheme>[A-Za-z][A-Za-z.+-]*)";
+    const AUTHORITY = "(?<authority>[^/?#]*)";
+    const PATH = "(?<path>[^?#]*)";
+    const QUERY = "(?<query>[^#]*)";
+    const FRAGMENT = "(?<fragment>.*)";
+    return new RegExp(`^${SCHEME}:(//${AUTHORITY})?${PATH}(\\?${QUERY})?(#${FRAGMENT})?$`, "su");
+})();
+function parseAuthority(text) {
+    const match = AUTHORITY_RE.exec(text);
+    if (match === null) {
+        throw new LibsqlError("The authority part of the URL is not in a valid format", "URL_INVALID");
+    }
+    const groups = match.groups;
+    const host = percentDecode(groups["host_br"] ?? groups["host"]);
+    const port = groups["port"] ? parseInt(groups["port"], 10) : undefined;
+    const userinfo = groups["username"] !== undefined
+        ? {
+            username: percentDecode(groups["username"]),
+            password: groups["password"] !== undefined
+                ? percentDecode(groups["password"])
+                : undefined,
+        }
+        : undefined;
+    return { host, port, userinfo };
+}
+const AUTHORITY_RE = (() => {
+    return new RegExp(`^((?<username>[^:]*)(:(?<password>.*))?@)?((?<host>[^:\\[\\]]*)|(\\[(?<host_br>[^\\[\\]]*)\\]))(:(?<port>[0-9]*))?$`, "su");
+})();
+// Query string is parsed as application/x-www-form-urlencoded according to the Web URL standard:
+// https://url.spec.whatwg.org/#urlencoded-parsing
+function parseQuery(text) {
+    const sequences = text.split("&");
+    const pairs = [];
+    for (const sequence of sequences) {
+        if (sequence === "") {
+            continue;
+        }
+        let key;
+        let value;
+        const splitIdx = sequence.indexOf("=");
+        if (splitIdx < 0) {
+            key = sequence;
+            value = "";
+        }
+        else {
+            key = sequence.substring(0, splitIdx);
+            value = sequence.substring(splitIdx + 1);
+        }
+        pairs.push({
+            key: percentDecode(key.replaceAll("+", " ")),
+            value: percentDecode(value.replaceAll("+", " ")),
+        });
+    }
+    return { pairs };
+}
+function percentDecode(text) {
+    try {
+        return decodeURIComponent(text);
+    }
+    catch (e) {
+        if (e instanceof URIError) {
+            throw new LibsqlError(`URL component has invalid percent encoding: ${e}`, "URL_INVALID", undefined, e);
+        }
+        throw e;
+    }
+}
+export function encodeBaseUrl(scheme, authority, path) {
+    if (authority === undefined) {
+        throw new LibsqlError(`URL with scheme ${JSON.stringify(scheme + ":")} requires authority (the "//" part)`, "URL_INVALID");
+    }
+    const schemeText = `${scheme}:`;
+    const hostText = encodeHost(authority.host);
+    const portText = encodePort(authority.port);
+    const userinfoText = encodeUserinfo(authority.userinfo);
+    const authorityText = `//${userinfoText}${hostText}${portText}`;
+    let pathText = path.split("/").map(encodeURIComponent).join("/");
+    if (pathText !== "" && !pathText.startsWith("/")) {
+        pathText = "/" + pathText;
+    }
+    return new URL(`${schemeText}${authorityText}${pathText}`);
+}
+function encodeHost(host) {
+    return host.includes(":") ? `[${encodeURI(host)}]` : encodeURI(host);
+}
+function encodePort(port) {
+    return port !== undefined ? `:${port}` : "";
+}
+function encodeUserinfo(userinfo) {
+    if (userinfo === undefined) {
+        return "";
+    }
+    const usernameText = encodeURIComponent(userinfo.username);
+    const passwordText = userinfo.password !== undefined
+        ? `:${encodeURIComponent(userinfo.password)}`
+        : "";
+    return `${usernameText}${passwordText}@`;
+}

package/.output/server/node_modules/@libsql/core/lib-esm/util.js

@@ -0,0 +1,55 @@
+import { Base64 } from "js-base64";
+export const supportedUrlLink = "https://github.com/libsql/libsql-client-ts#supported-urls";
+export function transactionModeToBegin(mode) {
+    if (mode === "write") {
+        return "BEGIN IMMEDIATE";
+    }
+    else if (mode === "read") {
+        return "BEGIN TRANSACTION READONLY";
+    }
+    else if (mode === "deferred") {
+        return "BEGIN DEFERRED";
+    }
+    else {
+        throw RangeError('Unknown transaction mode, supported values are "write", "read" and "deferred"');
+    }
+}
+export class ResultSetImpl {
+    columns;
+    columnTypes;
+    rows;
+    rowsAffected;
+    lastInsertRowid;
+    constructor(columns, columnTypes, rows, rowsAffected, lastInsertRowid) {
+        this.columns = columns;
+        this.columnTypes = columnTypes;
+        this.rows = rows;
+        this.rowsAffected = rowsAffected;
+        this.lastInsertRowid = lastInsertRowid;
+    }
+    toJSON() {
+        return {
+            columns: this.columns,
+            columnTypes: this.columnTypes,
+            rows: this.rows.map(rowToJson),
+            rowsAffected: this.rowsAffected,
+            lastInsertRowid: this.lastInsertRowid !== undefined
+                ? "" + this.lastInsertRowid
+                : null,
+        };
+    }
+}
+function rowToJson(row) {
+    return Array.prototype.map.call(row, valueToJson);
+}
+function valueToJson(value) {
+    if (typeof value === "bigint") {
+        return "" + value;
+    }
+    else if (value instanceof ArrayBuffer) {
+        return Base64.fromUint8Array(new Uint8Array(value));
+    }
+    else {
+        return value;
+    }
+}

package/.output/server/node_modules/@libsql/core/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@libsql/core",
+  "version": "0.15.15",
+  "keywords": [
+    "libsql",
+    "database",
+    "sqlite",
+    "serverless",
+    "vercel",
+    "netlify",
+    "lambda"
+  ],
+  "description": "libSQL driver for TypeScript and JavaScript",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libsql/libsql-client-ts",
+    "directory": "packages/libsql-core"
+  },
+  "authors": [
+    "Jan Špaček <honza@chiselstrike.com>",
+    "Pekka Enberg <penberg@chiselstrike.com>",
+    "Jan Plhak <jp@chiselstrike.com>"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./api": {
+      "types": "./lib-esm/api.d.ts",
+      "import": "./lib-esm/api.js",
+      "require": "./lib-cjs/api.js"
+    },
+    "./config": {
+      "types": "./lib-esm/config.d.ts",
+      "import": "./lib-esm/config.js",
+      "require": "./lib-cjs/config.js"
+    },
+    "./uri": {
+      "types": "./lib-esm/uri.d.ts",
+      "import": "./lib-esm/uri.js",
+      "require": "./lib-cjs/uri.js"
+    },
+    "./util": {
+      "types": "./lib-esm/util.d.ts",
+      "import": "./lib-esm/util.js",
+      "require": "./lib-cjs/util.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "api": [
+        "./lib-esm/api.d.ts"
+      ],
+      "config": [
+        "./lib-esm/config.d.ts"
+      ],
+      "uri": [
+        "./lib-esm/uri.d.ts"
+      ],
+      "util": [
+        "./lib-esm/util.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib-cjs/**",
+    "lib-esm/**"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "prebuild": "rm -rf ./lib-cjs ./lib-esm",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.build-cjs.json",
+    "build:esm": "tsc -p tsconfig.build-esm.json",
+    "format:check": "prettier --check .",
+    "postbuild": "cp package-cjs.json ./lib-cjs/package.json",
+    "test": "jest --runInBand",
+    "typecheck": "tsc --noEmit",
+    "typedoc": "rm -rf ./docs && typedoc"
+  },
+  "dependencies": {
+    "js-base64": "^3.7.5"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.5",
+    "@types/node": "^18.15.5",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.5",
+    "typedoc": "^0.23.28",
+    "typescript": "^4.9.4"
+  }
+}