@minimalcorp/tsunagi 0.0.4 → 0.1.0

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/libsql/index.js

@@ -1,441 +0,0 @@
-"use strict";
-
-const { load, currentTarget } = require("@neon-rs/load");
-const { familySync, GLIBC, MUSL } = require("detect-libc");
-
-function requireNative() {
-  if (process.env.LIBSQL_JS_DEV) {
-    return load(__dirname)
-  }
-  let target = currentTarget();
-  // Workaround for Bun, which reports a musl target, but really wants glibc...
-  if (familySync() == GLIBC) {
-    switch (target) {
-      case "linux-x64-musl":
-        target = "linux-x64-gnu";
-        break;
-      case "linux-arm64-musl":
-        target = "linux-arm64-gnu";
-        break;
-    }
-  }
-  // @neon-rs/load doesn't detect arm musl
-  if (target === "linux-arm-gnueabihf" && familySync() == MUSL) {
-      target = "linux-arm-musleabihf";
-  }
-  return require(`@libsql/${target}`);
-}
-
-const {
-  databaseOpen,
-  databaseOpenWithSync,
-  databaseInTransaction,
-  databaseInterrupt,
-  databaseClose,
-  databaseSyncSync,
-  databaseSyncUntilSync,
-  databaseExecSync,
-  databasePrepareSync,
-  databaseDefaultSafeIntegers,
-  databaseAuthorizer,
-  databaseLoadExtension,
-  databaseMaxWriteReplicationIndex,
-  statementRaw,
-  statementIsReader,
-  statementGet,
-  statementRun,
-  statementInterrupt,
-  statementRowsSync,
-  statementColumns,
-  statementSafeIntegers,
-  rowsNext,
-} = requireNative();
-
-const Authorization = require("./auth");
-const SqliteError = require("./sqlite-error");
-
-function convertError(err) {
-  if (err.libsqlError) {
-    return new SqliteError(err.message, err.code, err.rawCode);
-  }
-  return err;
-}
-
-/**
- * Database represents a connection that can prepare and execute SQL statements.
- */
-class Database {
-  /**
-   * Creates a new database connection. If the database file pointed to by `path` does not exists, it will be created.
-   *
-   * @constructor
-   * @param {string} path - Path to the database file.
-   */
-  constructor(path, opts) {
-    const encryptionCipher = opts?.encryptionCipher ?? "aes256cbc";
-    if (opts && opts.syncUrl) {
-      var authToken = "";
-      if (opts.syncAuth) {
-          console.warn("Warning: The `syncAuth` option is deprecated, please use `authToken` option instead.");
-          authToken = opts.syncAuth;
-      } else if (opts.authToken) {
-          authToken = opts.authToken;
-      }
-      const encryptionKey = opts?.encryptionKey ?? "";
-      const syncPeriod = opts?.syncPeriod ?? 0.0;
-      const readYourWrites = opts?.readYourWrites ?? true;
-      const offline = opts?.offline ?? false;
-      const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
-      this.db = databaseOpenWithSync(path, opts.syncUrl, authToken, encryptionCipher, encryptionKey, syncPeriod, readYourWrites, offline, remoteEncryptionKey);
-    } else {
-      const authToken = opts?.authToken ?? "";
-      const encryptionKey = opts?.encryptionKey ?? "";
-      const timeout = opts?.timeout ?? 0.0;
-      const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
-      this.db = databaseOpen(path, authToken, encryptionCipher, encryptionKey, timeout, remoteEncryptionKey);
-    }
-    // TODO: Use a libSQL API for this?
-    this.memory = path === ":memory:";
-    this.readonly = false;
-    this.name = "";
-    this.open = true;
-
-    const db = this.db;
-    Object.defineProperties(this, {
-      inTransaction: {
-        get() {
-          return databaseInTransaction(db);
-        }
-      },
-    });
-  }
-
-  sync() {
-    return databaseSyncSync.call(this.db);
-  }
-
-  syncUntil(replicationIndex) {
-    return databaseSyncUntilSync.call(this.db, replicationIndex);
-  }
-
-  /**
-   * Prepares a SQL statement for execution.
-   *
-   * @param {string} sql - The SQL statement string to prepare.
-   */
-  prepare(sql) {
-    try {
-      const stmt = databasePrepareSync.call(this.db, sql);
-      return new Statement(stmt);
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Returns a function that executes the given function in a transaction.
-   *
-   * @param {function} fn - The function to wrap in a transaction.
-   */
-  transaction(fn) {
-    if (typeof fn !== "function")
-      throw new TypeError("Expected first argument to be a function");
-
-    const db = this;
-    const wrapTxn = (mode) => {
-      return (...bindParameters) => {
-        db.exec("BEGIN " + mode);
-        try {
-          const result = fn(...bindParameters);
-          db.exec("COMMIT");
-          return result;
-        } catch (err) {
-          db.exec("ROLLBACK");
-          throw err;
-        }
-      };
-    };
-    const properties = {
-      default: { value: wrapTxn("") },
-      deferred: { value: wrapTxn("DEFERRED") },
-      immediate: { value: wrapTxn("IMMEDIATE") },
-      exclusive: { value: wrapTxn("EXCLUSIVE") },
-      database: { value: this, enumerable: true },
-    };
-    Object.defineProperties(properties.default.value, properties);
-    Object.defineProperties(properties.deferred.value, properties);
-    Object.defineProperties(properties.immediate.value, properties);
-    Object.defineProperties(properties.exclusive.value, properties);
-    return properties.default.value;
-  }
-
-  pragma(source, options) {
-    if (options == null) options = {};
-    if (typeof source !== 'string') throw new TypeError('Expected first argument to be a string');
-    if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
-    const simple = options['simple'];
-    const stmt = this.prepare(`PRAGMA ${source}`, this, true);
-    return simple ? stmt.pluck().get() : stmt.all();
-  }
-
-  backup(filename, options) {
-    throw new Error("not implemented");
-  }
-
-  serialize(options) {
-    throw new Error("not implemented");
-  }
-
-  function(name, options, fn) {
-    // Apply defaults
-    if (options == null) options = {};
-    if (typeof options === "function") {
-      fn = options;
-      options = {};
-    }
-
-    // Validate arguments
-    if (typeof name !== "string")
-      throw new TypeError("Expected first argument to be a string");
-    if (typeof fn !== "function")
-      throw new TypeError("Expected last argument to be a function");
-    if (typeof options !== "object")
-      throw new TypeError("Expected second argument to be an options object");
-    if (!name)
-      throw new TypeError(
-        "User-defined function name cannot be an empty string"
-      );
-
-    throw new Error("not implemented");
-  }
-
-  aggregate(name, options) {
-    // Validate arguments
-    if (typeof name !== "string")
-      throw new TypeError("Expected first argument to be a string");
-    if (typeof options !== "object" || options === null)
-      throw new TypeError("Expected second argument to be an options object");
-    if (!name)
-      throw new TypeError(
-        "User-defined function name cannot be an empty string"
-      );
-
-    throw new Error("not implemented");
-  }
-
-  table(name, factory) {
-    // Validate arguments
-    if (typeof name !== "string")
-      throw new TypeError("Expected first argument to be a string");
-    if (!name)
-      throw new TypeError(
-        "Virtual table module name cannot be an empty string"
-      );
-
-    throw new Error("not implemented");
-  }
-
-  authorizer(rules) {
-    databaseAuthorizer.call(this.db, rules);
-  }
-
-  loadExtension(...args) {
-    databaseLoadExtension.call(this.db, ...args);
-  }
-
-  maxWriteReplicationIndex() {
-    return databaseMaxWriteReplicationIndex.call(this.db)
-  }
-
-  /**
-   * Executes a SQL statement.
-   *
-   * @param {string} sql - The SQL statement string to execute.
-   */
-  exec(sql) {
-    try {
-      databaseExecSync.call(this.db, sql);
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Interrupts the database connection.
-   */
-  interrupt() {
-    databaseInterrupt.call(this.db);
-  }
-
-  /**
-   * Closes the database connection.
-   */
-  close() {
-    databaseClose.call(this.db);
-    this.open = false;
-  }
-
-  /**
-   * Toggle 64-bit integer support.
-   */
-  defaultSafeIntegers(toggle) {
-    databaseDefaultSafeIntegers.call(this.db, toggle ?? true);
-    return this;
-  }
-
-  unsafeMode(...args) {
-    throw new Error("not implemented");
-  }
-}
-
-/**
- * Statement represents a prepared SQL statement that can be executed.
- */
-class Statement {
-  constructor(stmt) {
-    this.stmt = stmt;
-    this.pluckMode = false;
-  }
-
-  /**
-   * Toggle raw mode.
-   *
-   * @param raw Enable or disable raw mode. If you don't pass the parameter, raw mode is enabled.
-   */
-  raw(raw) {
-    statementRaw.call(this.stmt, raw ?? true);
-    return this;
-  }
-
-  /**
-   * Toggle pluck mode.
-   *
-   * @param pluckMode Enable or disable pluck mode. If you don't pass the parameter, pluck mode is enabled.
-   */
-  pluck(pluckMode) {
-    this.pluckMode = pluckMode ?? true;
-    return this;
-  }
-
-  get reader() {
-    return statementIsReader.call(this.stmt);
-  }
-
-  /**
-   * Executes the SQL statement and returns an info object.
-   */
-  run(...bindParameters) {
-    try {
-      if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
-        return statementRun.call(this.stmt, bindParameters[0]);
-      } else {
-        return statementRun.call(this.stmt, bindParameters.flat());
-      }
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Executes the SQL statement and returns the first row.
-   *
-   * @param bindParameters - The bind parameters for executing the statement.
-   */
-  get(...bindParameters) {
-    try {
-      if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
-        return statementGet.call(this.stmt, bindParameters[0]);
-      } else {
-        return statementGet.call(this.stmt, bindParameters.flat());
-      }
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Executes the SQL statement and returns an iterator to the resulting rows.
-   *
-   * @param bindParameters - The bind parameters for executing the statement.
-   */
-  iterate(...bindParameters) {
-    var rows = undefined;
-    if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
-      rows = statementRowsSync.call(this.stmt, bindParameters[0]);
-    } else {
-      rows = statementRowsSync.call(this.stmt, bindParameters.flat());
-    }
-    const iter = {
-      nextRows: Array(100),
-      nextRowIndex: 100,
-      next() {
-        try {
-          if (this.nextRowIndex === 100) {
-            rowsNext.call(rows, this.nextRows);
-            this.nextRowIndex = 0;
-          }
-          const row = this.nextRows[this.nextRowIndex];
-          this.nextRows[this.nextRowIndex] = undefined;
-          if (!row) {
-            return { done: true };
-          }
-        this.nextRowIndex++;
-          return { value: row, done: false };
-        } catch (err) {
-          throw convertError(err);
-        }
-      },
-      [Symbol.iterator]() {
-        return this;
-      },
-    };
-    return iter;
-  }
-
-  /**
-   * Executes the SQL statement and returns an array of the resulting rows.
-   *
-   * @param bindParameters - The bind parameters for executing the statement.
-   */
-  all(...bindParameters) {
-    try {
-      const result = [];
-      for (const row of this.iterate(...bindParameters)) {
-        if (this.pluckMode) {
-          result.push(row[Object.keys(row)[0]]);
-        } else {
-          result.push(row);
-        }
-      }
-      return result;
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Interrupts the statement.
-   */
-  interrupt() {
-    statementInterrupt.call(this.stmt);
-  }
-
-  /**
-   * Returns the columns in the result set returned by this prepared statement.
-   */
-  columns() {
-    return statementColumns.call(this.stmt);
-  }
-
-  /**
-   * Toggle 64-bit integer support.
-   */
-  safeIntegers(toggle) {
-    statementSafeIntegers.call(this.stmt, toggle ?? true);
-    return this;
-  }
-}
-
-module.exports = Database;
-module.exports.Authorization = Authorization;
-module.exports.SqliteError = SqliteError;

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/libsql/package.json

@@ -1,90 +0,0 @@
-{
-  "name": "libsql",
-  "version": "0.5.29",
-  "description": "A better-sqlite3 compatible API for libSQL that supports Bun, Deno, and Node",
-  "os": [
-    "darwin",
-    "linux",
-    "win32"
-  ],
-  "cpu": [
-    "x64",
-    "arm64",
-    "wasm32",
-    "arm"
-  ],
-  "main": "index.js",
-  "types": "types/index.d.ts",
-  "files": [
-    "auth.js",
-    "index.js",
-    "sqlite-error.js",
-    "promise.js",
-    "types/index.d.ts",
-    "types/promise.d.ts"
-  ],
-  "exports": {
-    ".": {
-      "types": "./types/index.d.ts",
-      "default": "./index.js"
-    },
-    "./promise": {
-      "types": "./types/promise.d.ts",
-      "default": "./promise.js"
-    }
-  },
-  "scripts": {
-    "test": "cargo test",
-    "debug": "cargo build --message-format=json | npm exec neon dist",
-    "build": "npx tsc && cargo build --message-format=json --release | npm exec neon dist -- --name libsql-js",
-    "cross": "cross build --message-format=json --release | npm exec neon dist -- --name libsql-js -m /target",
-    "pack-build": "neon pack-build",
-    "prepack": "neon install-builds",
-    "postversion": "git push --follow-tags"
-  },
-  "author": "Pekka Enberg <penberg@iki.fi>",
-  "license": "MIT",
-  "neon": {
-    "targets": {
-      "aarch64-apple-darwin": "@libsql/darwin-arm64",
-      "aarch64-unknown-linux-gnu": "@libsql/linux-arm64-gnu",
-      "aarch64-unknown-linux-musl": "@libsql/linux-arm64-musl",
-      "x86_64-apple-darwin": "@libsql/darwin-x64",
-      "x86_64-pc-windows-msvc": "@libsql/win32-x64-msvc",
-      "x86_64-unknown-linux-gnu": "@libsql/linux-x64-gnu",
-      "x86_64-unknown-linux-musl": "@libsql/linux-x64-musl",
-      "arm-unknown-linux-gnueabihf": "@libsql/linux-arm-gnueabihf",
-      "arm-unknown-linux-musleabihf": "@libsql/linux-arm-musleabihf"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tursodatabase/libsql-js.git"
-  },
-  "keywords": [
-    "libsql"
-  ],
-  "bugs": {
-    "url": "https://github.com/tursodatabase/libsql-js/issues"
-  },
-  "homepage": "https://github.com/tursodatabase/libsql-js",
-  "devDependencies": {
-    "@neon-rs/cli": "^0.0.165",
-    "typescript": "^5.4.5"
-  },
-  "dependencies": {
-    "@neon-rs/load": "^0.0.4",
-    "detect-libc": "2.0.2"
-  },
-  "optionalDependencies": {
-    "@libsql/darwin-arm64": "0.5.29",
-    "@libsql/linux-arm64-gnu": "0.5.29",
-    "@libsql/linux-arm64-musl": "0.5.29",
-    "@libsql/darwin-x64": "0.5.29",
-    "@libsql/win32-x64-msvc": "0.5.29",
-    "@libsql/linux-x64-gnu": "0.5.29",
-    "@libsql/linux-x64-musl": "0.5.29",
-    "@libsql/linux-arm-gnueabihf": "0.5.29",
-    "@libsql/linux-arm-musleabihf": "0.5.29"
-  }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/libsql/sqlite-error.js

@@ -1,21 +0,0 @@
-'use strict';
-const descriptor = { value: 'SqliteError', writable: true, enumerable: false, configurable: true };
-
-function SqliteError(message, code, rawCode) {
-        if (new.target !== SqliteError) {
-                return new SqliteError(message, code);
-        }
-        if (typeof code !== 'string') {
-                throw new TypeError('Expected second argument to be a string');
-        }
-        Error.call(this, message);
-        descriptor.value = '' + message;
-        Object.defineProperty(this, 'message', descriptor);
-        Error.captureStackTrace(this, SqliteError);
-        this.code = code;
-        this.rawCode = rawCode
-}
-Object.setPrototypeOf(SqliteError, Error);
-Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
-Object.defineProperty(SqliteError.prototype, 'name', descriptor);
-module.exports = SqliteError;