@event-driven-io/dumbo 0.13.0-beta.2 → 0.13.0-beta.20

package/dist/chunk-3B24ORM3.js

@@ -0,0 +1,34 @@
+import {
+  SQL,
+  exists
+} from "./chunk-ZH6YVE3B.js";
+
+// src/storage/sqlite/core/schema/schema.ts
+var defaultSQLiteDatabase = ":memory:";
+var tableExistsSQL = (tableName) => SQL`
+  SELECT EXISTS (
+    SELECT 1
+    FROM sqlite_master
+    WHERE type = 'table' AND name = ${tableName}
+  ) AS "exists"
+   `;
+var tableExists = async (execute, tableName) => exists(execute.query(tableExistsSQL(tableName)));
+
+// src/storage/sqlite/core/schema/sqliteMetadata.ts
+var sqliteMetadata = {
+  databaseType: "SQLite",
+  capabilities: {
+    supportsSchemas: false,
+    supportsFunctions: false,
+    supportsMultipleDatabases: false
+  },
+  tableExists
+};
+dumboDatabaseMetadataRegistry.register("SQLite", sqliteMetadata);
+
+export {
+  defaultSQLiteDatabase,
+  tableExists,
+  sqliteMetadata
+};
+//# sourceMappingURL=chunk-3B24ORM3.js.map

package/dist/chunk-3B24ORM3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/sqlite/core/schema/schema.ts","../src/storage/sqlite/core/schema/sqliteMetadata.ts"],"sourcesContent":["import { exists, SQL, type SQLExecutor } from '../../../../core';\nexport * from './schema';\n\nexport const defaultSQLiteDatabase = ':memory:';\n\nconst tableExistsSQL = (tableName: string): SQL =>\n  SQL`\n  SELECT EXISTS (\n    SELECT 1\n    FROM sqlite_master\n    WHERE type = 'table' AND name = ${tableName}\n  ) AS \"exists\"\n   `;\n\nexport const tableExists = async (\n  execute: SQLExecutor,\n  tableName: string,\n): Promise<boolean> => exists(execute.query(tableExistsSQL(tableName)));\n","import type { DatabaseMetadata } from '../../../../core';\nimport { tableExists } from './schema';\n\nexport const sqliteMetadata: DatabaseMetadata<false, false, false> = {\n  databaseType: 'SQLite',\n  capabilities: {\n    supportsSchemas: false,\n    supportsFunctions: false,\n    supportsMultipleDatabases: false,\n  },\n  tableExists,\n};\n\ndumboDatabaseMetadataRegistry.register('SQLite', sqliteMetadata);\n"],"mappings":";;;;;;AAGO,IAAM,wBAAwB;AAErC,IAAM,iBAAiB,CAAC,cACtB;AAAA;AAAA;AAAA;AAAA,sCAIoC,SAAS;AAAA;AAAA;AAIxC,IAAM,cAAc,OACzB,SACA,cACqB,OAAO,QAAQ,MAAM,eAAe,SAAS,CAAC,CAAC;;;ACd/D,IAAM,iBAAwD;AAAA,EACnE,cAAc;AAAA,EACd,cAAc;AAAA,IACZ,iBAAiB;AAAA,IACjB,mBAAmB;AAAA,IACnB,2BAA2B;AAAA,EAC7B;AAAA,EACA;AACF;AAEA,8BAA8B,SAAS,UAAU,cAAc;","names":[]}

package/dist/chunk-FXETEUW2.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkPYTHH6WOcjs = require('./chunk-PYTHH6WO.cjs');
+
+// src/storage/sqlite/core/schema/schema.ts
+var defaultSQLiteDatabase = ":memory:";
+var tableExistsSQL = (tableName) => _chunkPYTHH6WOcjs.SQL`
+  SELECT EXISTS (
+    SELECT 1
+    FROM sqlite_master
+    WHERE type = 'table' AND name = ${tableName}
+  ) AS "exists"
+   `;
+var tableExists = async (execute, tableName) => _chunkPYTHH6WOcjs.exists.call(void 0, execute.query(tableExistsSQL(tableName)));
+
+// src/storage/sqlite/core/schema/sqliteMetadata.ts
+var sqliteMetadata = {
+  databaseType: "SQLite",
+  capabilities: {
+    supportsSchemas: false,
+    supportsFunctions: false,
+    supportsMultipleDatabases: false
+  },
+  tableExists
+};
+dumboDatabaseMetadataRegistry.register("SQLite", sqliteMetadata);
+
+
+
+
+
+exports.defaultSQLiteDatabase = defaultSQLiteDatabase; exports.tableExists = tableExists; exports.sqliteMetadata = sqliteMetadata;
+//# sourceMappingURL=chunk-FXETEUW2.cjs.map

package/dist/chunk-FXETEUW2.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/Pongo/Pongo/src/packages/dumbo/dist/chunk-FXETEUW2.cjs","../src/storage/sqlite/core/schema/schema.ts","../src/storage/sqlite/core/schema/sqliteMetadata.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,wDAA6B;AAC7B;AACA;ACFO,IAAM,sBAAA,EAAwB,UAAA;AAErC,IAAM,eAAA,EAAiB,CAAC,SAAA,EAAA,GACtB,qBAAA,CAAA;AAAA;AAAA;AAAA;AAAA,oCAAA,EAIoC,SAAS,CAAA;AAAA;AAAA,GAAA,CAAA;AAIxC,IAAM,YAAA,EAAc,MAAA,CACzB,OAAA,EACA,SAAA,EAAA,GACqB,sCAAA,OAAO,CAAQ,KAAA,CAAM,cAAA,CAAe,SAAS,CAAC,CAAC,CAAA;ADFtE;AACA;AEbO,IAAM,eAAA,EAAwD;AAAA,EACnE,YAAA,EAAc,QAAA;AAAA,EACd,YAAA,EAAc;AAAA,IACZ,eAAA,EAAiB,KAAA;AAAA,IACjB,iBAAA,EAAmB,KAAA;AAAA,IACnB,yBAAA,EAA2B;AAAA,EAC7B,CAAA;AAAA,EACA;AACF,CAAA;AAEA,6BAAA,CAA8B,QAAA,CAAS,QAAA,EAAU,cAAc,CAAA;AFc/D;AACA;AACE;AACA;AACA;AACF,kIAAC","file":"/home/runner/work/Pongo/Pongo/src/packages/dumbo/dist/chunk-FXETEUW2.cjs","sourcesContent":[null,"import { exists, SQL, type SQLExecutor } from '../../../../core';\nexport * from './schema';\n\nexport const defaultSQLiteDatabase = ':memory:';\n\nconst tableExistsSQL = (tableName: string): SQL =>\n  SQL`\n  SELECT EXISTS (\n    SELECT 1\n    FROM sqlite_master\n    WHERE type = 'table' AND name = ${tableName}\n  ) AS \"exists\"\n   `;\n\nexport const tableExists = async (\n  execute: SQLExecutor,\n  tableName: string,\n): Promise<boolean> => exists(execute.query(tableExistsSQL(tableName)));\n","import type { DatabaseMetadata } from '../../../../core';\nimport { tableExists } from './schema';\n\nexport const sqliteMetadata: DatabaseMetadata<false, false, false> = {\n  databaseType: 'SQLite',\n  capabilities: {\n    supportsSchemas: false,\n    supportsFunctions: false,\n    supportsMultipleDatabases: false,\n  },\n  tableExists,\n};\n\ndumboDatabaseMetadataRegistry.register('SQLite', sqliteMetadata);\n"]}

package/dist/chunk-JDP6VMRY.cjs

@@ -0,0 +1,556 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPYTHH6WOcjs = require('./chunk-PYTHH6WO.cjs');
+
+// src/storage/sqlite/core/errors/errorMapper.ts
+var getSqliteErrorCode = (error) => {
+  if (error instanceof Error && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return void 0;
+};
+var getErrorMessage = (error) => error instanceof Error ? error.message : void 0;
+var asError = (error) => error instanceof Error ? error : void 0;
+var mapConstraintError = (message, innerError) => {
+  const upperMessage = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _ => _.toUpperCase, 'call', _2 => _2()]), () => ( ""));
+  if (upperMessage.includes("UNIQUE") || upperMessage.includes("PRIMARY KEY"))
+    return new (0, _chunkPYTHH6WOcjs.UniqueConstraintError)(message, innerError);
+  if (upperMessage.includes("FOREIGN KEY"))
+    return new (0, _chunkPYTHH6WOcjs.ForeignKeyViolationError)(message, innerError);
+  if (upperMessage.includes("NOT NULL"))
+    return new (0, _chunkPYTHH6WOcjs.NotNullViolationError)(message, innerError);
+  if (upperMessage.includes("CHECK"))
+    return new (0, _chunkPYTHH6WOcjs.CheckViolationError)(message, innerError);
+  return new (0, _chunkPYTHH6WOcjs.IntegrityConstraintViolationError)(message, innerError);
+};
+var mapSqliteError = (error) => {
+  if (_chunkPYTHH6WOcjs.DumboError.isInstanceOf(error)) return error;
+  const code = getSqliteErrorCode(error);
+  if (!code)
+    return new (0, _chunkPYTHH6WOcjs.DumboError)({
+      errorCode: 500,
+      message: getErrorMessage(error),
+      innerError: asError(error)
+    });
+  const message = getErrorMessage(error);
+  const innerError = asError(error);
+  switch (code) {
+    // ── Constraint violations (19) ──
+    // node-sqlite3 only exposes the primary code; subtype is in the message.
+    case "SQLITE_CONSTRAINT":
+      return mapConstraintError(message, innerError);
+    // ── Busy / lock contention ──
+    // SQLITE_BUSY (5): conflict with a separate database connection
+    case "SQLITE_BUSY":
+      return new (0, _chunkPYTHH6WOcjs.LockNotAvailableError)(message, innerError);
+    // SQLITE_LOCKED (6): conflict within the same connection or shared cache
+    case "SQLITE_LOCKED":
+      return new (0, _chunkPYTHH6WOcjs.DeadlockError)(message, innerError);
+    // SQLITE_PROTOCOL (15): WAL locking race condition
+    case "SQLITE_PROTOCOL":
+      return new (0, _chunkPYTHH6WOcjs.LockNotAvailableError)(message, innerError);
+    // ── Connection / open errors ──
+    // SQLITE_CANTOPEN (14): unable to open database file
+    case "SQLITE_CANTOPEN":
+      return new (0, _chunkPYTHH6WOcjs.ConnectionError)(message, innerError);
+    // SQLITE_NOTADB (26): file is not a database
+    case "SQLITE_NOTADB":
+      return new (0, _chunkPYTHH6WOcjs.ConnectionError)(message, innerError);
+    // ── Resource exhaustion ──
+    // SQLITE_NOMEM (7): out of memory
+    case "SQLITE_NOMEM":
+      return new (0, _chunkPYTHH6WOcjs.InsufficientResourcesError)(message, innerError);
+    // SQLITE_FULL (13): disk full
+    case "SQLITE_FULL":
+      return new (0, _chunkPYTHH6WOcjs.InsufficientResourcesError)(message, innerError);
+    // ── System / I/O errors ──
+    // SQLITE_IOERR (10): operating system I/O error
+    case "SQLITE_IOERR":
+      return new (0, _chunkPYTHH6WOcjs.SystemError)(message, innerError);
+    // SQLITE_CORRUPT (11): database file is corrupted
+    case "SQLITE_CORRUPT":
+      return new (0, _chunkPYTHH6WOcjs.SystemError)(message, innerError);
+    // SQLITE_INTERNAL (2): internal SQLite malfunction
+    case "SQLITE_INTERNAL":
+      return new (0, _chunkPYTHH6WOcjs.SystemError)(message, innerError);
+    // SQLITE_NOLFS (22): large file support unavailable
+    case "SQLITE_NOLFS":
+      return new (0, _chunkPYTHH6WOcjs.SystemError)(message, innerError);
+    // ── Data errors ──
+    // SQLITE_TOOBIG (18): string or BLOB too large
+    case "SQLITE_TOOBIG":
+      return new (0, _chunkPYTHH6WOcjs.DataError)(message, innerError);
+    // SQLITE_MISMATCH (20): datatype mismatch
+    case "SQLITE_MISMATCH":
+      return new (0, _chunkPYTHH6WOcjs.DataError)(message, innerError);
+    // SQLITE_RANGE (25): bind parameter index out of range
+    case "SQLITE_RANGE":
+      return new (0, _chunkPYTHH6WOcjs.DataError)(message, innerError);
+    // ── Invalid operations ──
+    // SQLITE_ERROR (1): generic SQL error (syntax errors, missing tables, etc.)
+    case "SQLITE_ERROR":
+      return new (0, _chunkPYTHH6WOcjs.InvalidOperationError)(message, innerError);
+    // SQLITE_READONLY (8): attempt to write to a read-only database
+    case "SQLITE_READONLY":
+      return new (0, _chunkPYTHH6WOcjs.InvalidOperationError)(message, innerError);
+    // SQLITE_MISUSE (21): API misuse
+    case "SQLITE_MISUSE":
+      return new (0, _chunkPYTHH6WOcjs.InvalidOperationError)(message, innerError);
+    // SQLITE_AUTH (23): authorization denied
+    case "SQLITE_AUTH":
+      return new (0, _chunkPYTHH6WOcjs.InvalidOperationError)(message, innerError);
+    // SQLITE_PERM (3): access permission denied
+    case "SQLITE_PERM":
+      return new (0, _chunkPYTHH6WOcjs.InvalidOperationError)(message, innerError);
+    // SQLITE_SCHEMA (17): schema changed, statement needs re-preparation
+    case "SQLITE_SCHEMA":
+      return new (0, _chunkPYTHH6WOcjs.InvalidOperationError)(message, innerError);
+    // ── Transaction / abort ──
+    // SQLITE_ABORT (4): operation aborted (e.g. by rollback)
+    case "SQLITE_ABORT":
+      return new (0, _chunkPYTHH6WOcjs.SerializationError)(message, innerError);
+    // SQLITE_INTERRUPT (9): operation interrupted
+    case "SQLITE_INTERRUPT":
+      return new (0, _chunkPYTHH6WOcjs.SerializationError)(message, innerError);
+  }
+  return new (0, _chunkPYTHH6WOcjs.DumboError)({
+    errorCode: 500,
+    message,
+    innerError
+  });
+};
+
+// src/storage/sqlite/core/sql/processors/columProcessors.ts
+var mapColumnType = (token, { builder }) => {
+  let columnSQL;
+  const { sqlTokenType } = token;
+  switch (sqlTokenType) {
+    case "SQL_COLUMN_AUTO_INCREMENT":
+      columnSQL = `INTEGER ${token.primaryKey ? "PRIMARY KEY" : ""} AUTOINCREMENT`;
+      break;
+    case "SQL_COLUMN_BIGINT":
+      columnSQL = "INTEGER";
+      break;
+    case "SQL_COLUMN_SERIAL":
+      columnSQL = "INTEGER";
+      break;
+    case "SQL_COLUMN_INTEGER":
+      columnSQL = "INTEGER";
+      break;
+    case "SQL_COLUMN_JSONB":
+      columnSQL = "BLOB";
+      break;
+    case "SQL_COLUMN_BIGSERIAL":
+      columnSQL = "INTEGER";
+      break;
+    case "SQL_COLUMN_TIMESTAMP":
+      columnSQL = "DATETIME";
+      break;
+    case "SQL_COLUMN_TIMESTAMPTZ":
+      columnSQL = "DATETIME";
+      break;
+    case "SQL_COLUMN_VARCHAR":
+      columnSQL = `VARCHAR ${Number.isNaN(token.length) ? "" : `(${token.length})`}`;
+      break;
+    default: {
+      const exhaustiveCheck = sqlTokenType;
+      throw new Error(`Unknown column type: ${exhaustiveCheck}`);
+    }
+  }
+  builder.addSQL(columnSQL);
+};
+var sqliteColumnProcessors = _chunkPYTHH6WOcjs.mapDefaultSQLColumnProcessors.call(void 0, mapColumnType);
+
+// src/storage/sqlite/core/sql/formatter/index.ts
+var sqliteSQLProcessorsRegistry = _chunkPYTHH6WOcjs.SQLProcessorsRegistry.call(void 0, {
+  from: _chunkPYTHH6WOcjs.defaultProcessorsRegistry
+}).register(sqliteColumnProcessors);
+var sqliteFormatter = _chunkPYTHH6WOcjs.SQLFormatter.call(void 0, {
+  processorsRegistry: sqliteSQLProcessorsRegistry
+});
+_chunkPYTHH6WOcjs.registerFormatter.call(void 0, "SQLite", sqliteFormatter);
+
+// src/storage/sqlite/core/execute/execute.ts
+var sqliteExecute = async (database, handle) => {
+  try {
+    return await handle(database);
+  } finally {
+    await database.close();
+  }
+};
+var sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
+  driverType,
+  query: async (client, sql, options) => {
+    if (_optionalChain([options, 'optionalAccess', _3 => _3.timeoutMs])) {
+      await client.query(_chunkPYTHH6WOcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
+    }
+    _chunkPYTHH6WOcjs.tracer.info("db:sql:query", {
+      query: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).query,
+      params: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).params,
+      debugSQL: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).describe(sql, { serializer })
+    });
+    try {
+      let result = await client.query(sql, options);
+      if (_optionalChain([options, 'optionalAccess', _4 => _4.mapping])) {
+        result = {
+          ...result,
+          rows: result.rows.map(
+            (row) => _chunkPYTHH6WOcjs.mapSQLQueryResult.call(void 0, row, options.mapping)
+          )
+        };
+      }
+      return result;
+    } catch (error) {
+      _chunkPYTHH6WOcjs.tracer.error("db:sql:query:execute:error", { error });
+      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
+    }
+  },
+  batchQuery: async (client, sqls, options) => {
+    if (_optionalChain([options, 'optionalAccess', _5 => _5.timeoutMs])) {
+      await client.query(_chunkPYTHH6WOcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
+    }
+    try {
+      const results = await client.batchQuery(sqls, options);
+      if (_optionalChain([options, 'optionalAccess', _6 => _6.mapping])) {
+        return results.map((result) => ({
+          ...result,
+          rows: result.rows.map(
+            (row) => _chunkPYTHH6WOcjs.mapSQLQueryResult.call(void 0, row, options.mapping)
+          )
+        }));
+      }
+      return results;
+    } catch (error) {
+      _chunkPYTHH6WOcjs.tracer.error("db:sql:batch_query:execute:error", { error });
+      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
+    }
+  },
+  command: async (client, sql, options) => {
+    if (_optionalChain([options, 'optionalAccess', _7 => _7.timeoutMs])) {
+      await client.query(_chunkPYTHH6WOcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
+    }
+    _chunkPYTHH6WOcjs.tracer.info("db:sql:command", {
+      query: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).query,
+      params: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).params,
+      debugSQL: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).describe(sql, { serializer })
+    });
+    try {
+      return await client.command(sql, options);
+    } catch (error) {
+      _chunkPYTHH6WOcjs.tracer.error("db:sql:command:execute:error", { error });
+      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
+    }
+  },
+  batchCommand: async (client, sqls, options) => {
+    if (_optionalChain([options, 'optionalAccess', _8 => _8.timeoutMs])) {
+      await client.query(_chunkPYTHH6WOcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
+    }
+    try {
+      return await client.batchCommand(sqls, options);
+    } catch (error) {
+      _chunkPYTHH6WOcjs.tracer.error("db:sql:batch_command:execute:error", { error });
+      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
+    }
+  },
+  formatter: _nullishCoalesce(formatter, () => ( sqliteFormatter))
+});
+
+// src/storage/sqlite/core/pool/pool.ts
+var isInMemoryDatabase = (options) => {
+  if ("fileName" in options) {
+    return options.fileName === InMemorySQLiteDatabase;
+  }
+  if ("connectionString" in options) {
+    return options.connectionString === InMemorySQLiteDatabase;
+  }
+  return false;
+};
+var sqliteAmbientConnectionPool = (options) => {
+  const { connection, driverType } = options;
+  return _chunkPYTHH6WOcjs.createAmbientConnectionPool.call(void 0, {
+    driverType,
+    connection
+  });
+};
+var sqliteSingletonConnectionPool = (options) => {
+  const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+  return _chunkPYTHH6WOcjs.createSingletonConnectionPool.call(void 0, {
+    driverType,
+    getConnection: () => sqliteConnectionFactory(connectionOptions)
+  });
+};
+var sqliteAlwaysNewConnectionPool = (options) => {
+  const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+  return _chunkPYTHH6WOcjs.createAlwaysNewConnectionPool.call(void 0, {
+    driverType,
+    getConnection: () => sqliteConnectionFactory(connectionOptions)
+  });
+};
+var toSqlitePoolOptions = (options) => {
+  const { singleton, ...rest } = options;
+  const useSingleton = _nullishCoalesce(singleton, () => ( isInMemoryDatabase(options)));
+  if (useSingleton) {
+    return { ...rest, singleton: true };
+  }
+  return { ...rest, singleton: false };
+};
+function sqlitePool(options) {
+  const { driverType } = options;
+  if (options.connection)
+    return _chunkPYTHH6WOcjs.createAmbientConnectionPool.call(void 0, {
+      driverType,
+      connection: options.connection
+    });
+  if (options.singleton === true && options.sqliteConnectionFactory) {
+    return _chunkPYTHH6WOcjs.createSingletonConnectionPool.call(void 0, {
+      driverType,
+      getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+    });
+  }
+  return _chunkPYTHH6WOcjs.createAlwaysNewConnectionPool.call(void 0, {
+    driverType,
+    getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+  });
+}
+
+// src/storage/sqlite/core/schema/migrations.ts
+var DefaultSQLiteMigratorOptions = {};
+_chunkPYTHH6WOcjs.registerDefaultMigratorOptions.call(void 0, "SQLite", DefaultSQLiteMigratorOptions);
+
+// src/storage/sqlite/core/index.ts
+var SQLiteDatabaseName = "SQLite";
+
+// src/storage/sqlite/core/connections/connectionString.ts
+var SQLiteConnectionString = (connectionString) => {
+  if (!connectionString.startsWith("file:") && connectionString !== ":memory:" && !connectionString.startsWith("/") && !connectionString.startsWith("./")) {
+    throw new Error(
+      `Invalid SQLite connection string: ${connectionString}. It should start with "file:", ":memory:", "/", or "./".`
+    );
+  }
+  return connectionString;
+};
+
+// src/storage/sqlite/core/connections/index.ts
+var isSQLiteError = (error) => {
+  if (error instanceof Error && "code" in error) {
+    return true;
+  }
+  return false;
+};
+var transactionNestingCounter = () => {
+  let transactionLevel = 0;
+  return {
+    reset: () => {
+      transactionLevel = 0;
+    },
+    increment: () => {
+      transactionLevel++;
+    },
+    decrement: () => {
+      transactionLevel--;
+      if (transactionLevel < 0) {
+        throw new Error("Transaction level is out of bounds");
+      }
+    },
+    get level() {
+      return transactionLevel;
+    }
+  };
+};
+var sqliteAmbientClientConnection = (options) => {
+  const {
+    client,
+    driverType,
+    initTransaction,
+    allowNestedTransactions,
+    serializer,
+    errorMapper
+  } = options;
+  return _chunkPYTHH6WOcjs.createAmbientConnection.call(void 0, {
+    driverType,
+    client,
+    initTransaction: _nullishCoalesce(initTransaction, () => ( ((connection) => sqliteTransaction(
+      driverType,
+      connection,
+      _nullishCoalesce(allowNestedTransactions, () => ( false)),
+      serializer
+    )))),
+    executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(driverType, serializer2, void 0, errorMapper),
+    serializer
+  });
+};
+var sqliteClientConnection = (options) => {
+  const { connectionOptions, sqliteClientFactory, serializer } = options;
+  let client = null;
+  const connect = async () => {
+    if (client) return Promise.resolve(client);
+    client = sqliteClientFactory(connectionOptions);
+    if (client && "connect" in client && typeof client.connect === "function")
+      await client.connect();
+    return client;
+  };
+  return _chunkPYTHH6WOcjs.createConnection.call(void 0, {
+    driverType: options.driverType,
+    connect,
+    close: async () => {
+      if (client && "close" in client && typeof client.close === "function")
+        await client.close();
+      else if (client && "release" in client && typeof client.release === "function")
+        client.release();
+    },
+    initTransaction: (connection) => sqliteTransaction(
+      options.driverType,
+      connection,
+      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _9 => _9.transactionOptions, 'optionalAccess', _10 => _10.allowNestedTransactions]), () => ( false)),
+      serializer
+    ),
+    executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(options.driverType, serializer2),
+    serializer
+  });
+};
+var sqlitePoolClientConnection = (options) => {
+  const { connectionOptions, sqliteClientFactory, serializer } = options;
+  let client = null;
+  const connect = async () => {
+    if (client) return Promise.resolve(client);
+    client = sqliteClientFactory(connectionOptions);
+    await client.connect();
+    return client;
+  };
+  return _chunkPYTHH6WOcjs.createConnection.call(void 0, {
+    driverType: options.driverType,
+    connect,
+    close: () => client !== null ? Promise.resolve(client.release()) : Promise.resolve(),
+    initTransaction: (connection) => sqliteTransaction(
+      options.driverType,
+      connection,
+      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _11 => _11.transactionOptions, 'optionalAccess', _12 => _12.allowNestedTransactions]), () => ( false)),
+      serializer
+    ),
+    executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(options.driverType, serializer2),
+    serializer
+  });
+};
+function sqliteConnection(options) {
+  return options.type === "Client" ? sqliteClientConnection(options) : sqlitePoolClientConnection(options);
+}
+var InMemorySQLiteDatabase = SQLiteConnectionString(":memory:");
+
+// src/storage/sqlite/core/transactions/index.ts
+var sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer) => (getClient, options) => {
+  const transactionCounter = transactionNestingCounter();
+  allowNestedTransactions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.allowNestedTransactions]), () => ( allowNestedTransactions));
+  return {
+    connection: connection(),
+    driverType,
+    begin: async function() {
+      const client = await getClient;
+      if (allowNestedTransactions) {
+        if (transactionCounter.level >= 1) {
+          transactionCounter.increment();
+          await client.query(
+            _chunkPYTHH6WOcjs.SQL`SAVEPOINT transaction${_chunkPYTHH6WOcjs.SQL.plain(transactionCounter.level.toString())}`
+          );
+          return;
+        }
+        transactionCounter.increment();
+      }
+      await client.query(_chunkPYTHH6WOcjs.SQL`BEGIN TRANSACTION`);
+    },
+    commit: async function() {
+      const client = await getClient;
+      try {
+        if (allowNestedTransactions) {
+          if (transactionCounter.level > 1) {
+            await client.query(
+              _chunkPYTHH6WOcjs.SQL`RELEASE transaction${_chunkPYTHH6WOcjs.SQL.plain(transactionCounter.level.toString())}`
+            );
+            transactionCounter.decrement();
+            return;
+          }
+          transactionCounter.reset();
+        }
+        await client.query(_chunkPYTHH6WOcjs.SQL`COMMIT`);
+      } finally {
+        if (_optionalChain([options, 'optionalAccess', _14 => _14.close]))
+          await _optionalChain([options, 'optionalAccess', _15 => _15.close, 'call', _16 => _16(
+            client
+          )]);
+      }
+    },
+    rollback: async function(error) {
+      const client = await getClient;
+      try {
+        if (allowNestedTransactions) {
+          if (transactionCounter.level > 1) {
+            transactionCounter.decrement();
+            return;
+          }
+        }
+        await client.query(_chunkPYTHH6WOcjs.SQL`ROLLBACK`);
+      } finally {
+        if (_optionalChain([options, 'optionalAccess', _17 => _17.close]))
+          await _optionalChain([options, 'optionalAccess', _18 => _18.close, 'call', _19 => _19(
+            client,
+            error
+          )]);
+      }
+    },
+    execute: _chunkPYTHH6WOcjs.sqlExecutor.call(void 0, sqliteSQLExecutor(driverType, serializer), {
+      connect: () => getClient
+    })
+  };
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.mapSqliteError = mapSqliteError; exports.sqliteFormatter = sqliteFormatter; exports.sqliteExecute = sqliteExecute; exports.sqliteSQLExecutor = sqliteSQLExecutor; exports.sqliteTransaction = sqliteTransaction; exports.SQLiteConnectionString = SQLiteConnectionString; exports.isSQLiteError = isSQLiteError; exports.transactionNestingCounter = transactionNestingCounter; exports.sqliteAmbientClientConnection = sqliteAmbientClientConnection; exports.sqliteClientConnection = sqliteClientConnection; exports.sqlitePoolClientConnection = sqlitePoolClientConnection; exports.sqliteConnection = sqliteConnection; exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; exports.isInMemoryDatabase = isInMemoryDatabase; exports.sqliteAmbientConnectionPool = sqliteAmbientConnectionPool; exports.sqliteSingletonConnectionPool = sqliteSingletonConnectionPool; exports.sqliteAlwaysNewConnectionPool = sqliteAlwaysNewConnectionPool; exports.toSqlitePoolOptions = toSqlitePoolOptions; exports.sqlitePool = sqlitePool; exports.DefaultSQLiteMigratorOptions = DefaultSQLiteMigratorOptions; exports.SQLiteDatabaseName = SQLiteDatabaseName;
+//# sourceMappingURL=chunk-JDP6VMRY.cjs.map