@richardmcquiston01/error-log-adapter 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -22,8 +22,21 @@ var index_exports = {};
 __export(index_exports, {
   CompositeErrorAdapter: () => CompositeErrorAdapter,
   ConsoleErrorAdapter: () => ConsoleErrorAdapter,
+  FlatFileErrorAdapter: () => FlatFileErrorAdapter,
+  IndexedDbErrorAdapter: () => IndexedDbErrorAdapter,
+  JsonFileErrorAdapter: () => JsonFileErrorAdapter,
   MongoDbErrorAdapter: () => MongoDbErrorAdapter,
+  MySqlErrorAdapter: () => MySqlErrorAdapter,
+  PostgresErrorAdapter: () => PostgresErrorAdapter,
+  RedisErrorAdapter: () => RedisErrorAdapter,
+  S3ErrorAdapter: () => S3ErrorAdapter,
+  SqliteErrorAdapter: () => SqliteErrorAdapter,
+  WebStorageErrorAdapter: () => WebStorageErrorAdapter,
   WebhookErrorAdapter: () => WebhookErrorAdapter,
+  buildCreateErrorLogTableSql: () => buildCreateErrorLogTableSql,
+  buildErrorLogTableDdl: () => buildErrorLogTableDdl,
+  createErrorLogStore: () => createErrorLogStore,
+  formatErrorLogLine: () => formatErrorLogLine,
   serializeCause: () => serializeCause,
   serializeEntry: () => serializeEntry
 });
@@ -159,12 +172,882 @@ var CompositeErrorAdapter = class {
     };
   }
 };
+
+// src/adapters/indexeddb-error-adapter.ts
+var DEFAULT_STORE_NAME = "error_log";
+function createErrorLogStore(database, storeName = DEFAULT_STORE_NAME) {
+  if (database.objectStoreNames.contains(storeName)) {
+    return;
+  }
+  database.createObjectStore(storeName, { keyPath: "id" }).createIndex("timestamp", "timestamp");
+}
+var IndexedDbErrorAdapter = class {
+  constructor(database, options = {}) {
+    this.database = database;
+    this.storeName = options.storeName ?? DEFAULT_STORE_NAME;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+  }
+  async log(entry) {
+    try {
+      const record = {
+        id: crypto.randomUUID(),
+        ...serializeEntry(entry)
+      };
+      await this.write(record);
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} IndexedDbErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `IndexedDbErrorAdapter failed to write to object store "${this.storeName}": ${describeError(error)}`
+      };
+    }
+  }
+  /** Resolves once the transaction commits; rejects if it errors or aborts. */
+  write(record) {
+    return new Promise(
+      (resolve, reject) => {
+        const transaction = this.database.transaction(
+          this.storeName,
+          "readwrite"
+        );
+        const fail = (action) => () => reject(
+          new Error(
+            `transaction ${action}: ${transaction.error?.message ?? "no details provided"}`
+          )
+        );
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = fail("failed");
+        transaction.onabort = fail("aborted");
+        transaction.objectStore(this.storeName).add(record);
+      }
+    );
+  }
+};
+
+// src/adapters/sqlite-error-adapter.ts
+var DEFAULT_TABLE_NAME = "error_log";
+var IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertValidTableName(tableName) {
+  if (!IDENTIFIER_PATTERN.test(tableName)) {
+    throw new RangeError(
+      `SqliteErrorAdapter: invalid table name "${tableName}". Use only letters, digits and underscores, and do not start with a digit.`
+    );
+  }
+}
+function buildCreateErrorLogTableSql(tableName = DEFAULT_TABLE_NAME) {
+  assertValidTableName(tableName);
+  return [
+    `CREATE TABLE IF NOT EXISTS ${tableName} (id TEXT PRIMARY KEY NOT NULL, code TEXT NOT NULL, message TEXT NOT NULL, cause TEXT, source TEXT, occurred_at TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')))`,
+    `CREATE INDEX IF NOT EXISTS ${tableName}_occurred_at_idx ON ${tableName} (occurred_at)`
+  ];
+}
+var SqliteErrorAdapter = class {
+  /** @throws {RangeError} if `options.tableName` is not a plain identifier. */
+  constructor(client, options = {}) {
+    this.client = client;
+    this.tableReady = null;
+    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME;
+    assertValidTableName(this.tableName);
+    this.createTable = options.createTable ?? true;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+  }
+  async log(entry) {
+    try {
+      await this.ensureTable();
+      const serialized = serializeEntry(entry);
+      await this.client.run(
+        `INSERT INTO ${this.tableName} (id, code, message, cause, source, occurred_at) VALUES (?, ?, ?, ?, ?, ?)`,
+        [
+          crypto.randomUUID(),
+          serialized.code,
+          serialized.message,
+          serialized.cause === void 0 ? null : JSON.stringify(serialized.cause),
+          serialized.source ?? null,
+          serialized.timestamp
+        ]
+      );
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} SqliteErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `SqliteErrorAdapter failed to write to table "${this.tableName}": ${describeError(error)}`
+      };
+    }
+  }
+  /** Creates the table once. A failed attempt is retried on the next log call. */
+  ensureTable() {
+    if (!this.createTable) {
+      return Promise.resolve();
+    }
+    if (this.tableReady === null) {
+      this.tableReady = this.runCreateStatements().catch(
+        (error) => {
+          this.tableReady = null;
+          throw error;
+        }
+      );
+    }
+    return this.tableReady;
+  }
+  async runCreateStatements() {
+    for (const sql of buildCreateErrorLogTableSql(this.tableName)) {
+      await this.client.run(sql, []);
+    }
+  }
+};
+
+// src/adapters/web-storage-error-adapter.ts
+var DEFAULT_STORAGE_KEY = "error_log";
+var DEFAULT_MAX_ENTRIES = 100;
+function isQuotaError(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const { name, code } = error;
+  return typeof name === "string" && name.toLowerCase().includes("quota") || code === 22 || code === 1014;
+}
+var WebStorageErrorAdapter = class {
+  /** @throws {RangeError} if `options.maxEntries` is not a positive integer. */
+  constructor(storage, options = {}) {
+    this.storage = storage;
+    this.key = options.key ?? DEFAULT_STORAGE_KEY;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+    if (!Number.isInteger(this.maxEntries) || this.maxEntries < 1) {
+      throw new RangeError(
+        `WebStorageErrorAdapter: maxEntries must be a positive integer, received ${String(options.maxEntries)}.`
+      );
+    }
+  }
+  async log(entry) {
+    try {
+      const record = {
+        id: crypto.randomUUID(),
+        ...serializeEntry(entry)
+      };
+      this.append(record);
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} WebStorageErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `WebStorageErrorAdapter failed to write to storage key "${this.key}": ${describeError(error)}`
+      };
+    }
+  }
+  /** Reads, appends, trims, and writes back. Runs without awaiting, so calls never interleave. */
+  append(record) {
+    const records = [
+      ...this.readRecords(),
+      record
+    ].slice(-this.maxEntries);
+    for (; ; ) {
+      try {
+        this.storage.setItem(this.key, JSON.stringify(records));
+        return;
+      } catch (error) {
+        if (!isQuotaError(error) || records.length <= 1) {
+          throw error;
+        }
+        records.shift();
+      }
+    }
+  }
+  /** Returns the stored records, or none if the value is missing or unreadable. */
+  readRecords() {
+    const stored = this.storage.getItem(this.key);
+    if (stored === null) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(stored);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+      console.error(
+        `${this.prefix} WebStorageErrorAdapter: storage key "${this.key}" did not hold an array, so it was replaced.`
+      );
+    } catch (error) {
+      console.error(
+        `${this.prefix} WebStorageErrorAdapter: storage key "${this.key}" held invalid JSON (${describeError(error)}), so it was replaced.`
+      );
+    }
+    return [];
+  }
+};
+
+// src/file-system.ts
+async function loadNodeFileSystem() {
+  const moduleName = "node:fs/promises";
+  return await import(moduleName);
+}
+function parentDirectory(filePath) {
+  const lastSeparator = Math.max(
+    filePath.lastIndexOf("/"),
+    filePath.lastIndexOf("\\")
+  );
+  if (lastSeparator < 0) {
+    return null;
+  }
+  return lastSeparator === 0 ? "/" : filePath.slice(0, lastSeparator);
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+
+// src/adapters/flat-file-error-adapter.ts
+var DEFAULT_MAX_FILES = 3;
+function escapeLineBreaks(text) {
+  return text.replace(/\r?\n/g, "\\n");
+}
+function describeCause(cause) {
+  if (typeof cause === "string") {
+    return cause;
+  }
+  if (typeof cause === "object" && cause !== null) {
+    const { name, message } = cause;
+    if (typeof name === "string" && typeof message === "string") {
+      return `${name}: ${message}`;
+    }
+  }
+  try {
+    return JSON.stringify(cause) ?? String(cause);
+  } catch {
+    return String(cause);
+  }
+}
+function formatErrorLogLine(entry) {
+  const source = entry.source === void 0 ? "" : `${entry.source}: `;
+  const cause = entry.cause === void 0 ? "" : ` (cause: ${describeCause(entry.cause)})`;
+  return escapeLineBreaks(
+    `${entry.timestamp} [${entry.code}] ${source}${entry.message}${cause}`
+  );
+}
+function assertPositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new RangeError(
+      `FlatFileErrorAdapter: ${name} must be a positive integer, received ${String(value)}.`
+    );
+  }
+}
+var FlatFileErrorAdapter = class {
+  /** @throws {RangeError} if `maxBytes` or `maxFiles` is not a positive integer. */
+  constructor(filePath, options = {}) {
+    this.filePath = filePath;
+    this.directoryReady = false;
+    this.queue = Promise.resolve();
+    this.fs = options.fs;
+    this.formatLine = options.formatLine ?? formatErrorLogLine;
+    this.maxBytes = options.maxBytes;
+    this.maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+    this.createDirectory = options.createDirectory ?? true;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+    if (this.maxBytes !== void 0) {
+      assertPositiveInteger(this.maxBytes, "maxBytes");
+    }
+    assertPositiveInteger(this.maxFiles, "maxFiles");
+  }
+  log(entry) {
+    const result = this.queue.then(
+      () => this.write(entry)
+    );
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async write(entry) {
+    try {
+      const fs = await this.getFileSystem();
+      const formatted = this.formatLine(serializeEntry(entry));
+      const line = formatted.endsWith("\n") ? formatted : `${formatted}
+`;
+      await this.prepareDirectory(fs);
+      await this.rotateIfNeeded(fs, new TextEncoder().encode(line).length);
+      await fs.appendFile(this.filePath, line);
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} FlatFileErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `FlatFileErrorAdapter failed to append to "${this.filePath}": ${describeError(error)}`
+      };
+    }
+  }
+  /** Uses the injected file system, or loads `node:fs/promises` on first use. */
+  async getFileSystem() {
+    if (this.fs === void 0) {
+      this.fs = await loadNodeFileSystem();
+    }
+    return this.fs;
+  }
+  async prepareDirectory(fs) {
+    if (!this.createDirectory || this.directoryReady) {
+      return;
+    }
+    const directory = parentDirectory(this.filePath);
+    if (directory !== null) {
+      await fs.mkdir(directory, { recursive: true });
+    }
+    this.directoryReady = true;
+  }
+  /**
+   * Moves `app.log` to `app.log.1` (shifting older files up, dropping the
+   * oldest) when the next line would push it past `maxBytes`. A failed rotation
+   * is reported, but the entry is still written so it is not lost.
+   */
+  async rotateIfNeeded(fs, lineBytes) {
+    if (this.maxBytes === void 0) {
+      return;
+    }
+    try {
+      let currentSize;
+      try {
+        currentSize = (await fs.stat(this.filePath)).size;
+      } catch (error) {
+        if (isMissingFileError(error)) {
+          return;
+        }
+        throw error;
+      }
+      if (currentSize === 0 || currentSize + lineBytes <= this.maxBytes) {
+        return;
+      }
+      await fs.rm(`${this.filePath}.${this.maxFiles}`, { force: true });
+      for (let index = this.maxFiles - 1; index >= 1; index -= 1) {
+        await this.renameIfPresent(
+          fs,
+          `${this.filePath}.${index}`,
+          `${this.filePath}.${index + 1}`
+        );
+      }
+      await fs.rename(this.filePath, `${this.filePath}.1`);
+    } catch (error) {
+      console.error(
+        `${this.prefix} FlatFileErrorAdapter: could not rotate "${this.filePath}", so it will keep growing: ${describeError(error)}`
+      );
+    }
+  }
+  async renameIfPresent(fs, from, to) {
+    try {
+      await fs.rename(from, to);
+    } catch (error) {
+      if (!isMissingFileError(error)) {
+        throw error;
+      }
+    }
+  }
+};
+
+// src/adapters/json-file-error-adapter.ts
+var DEFAULT_INDENT = 2;
+var JsonFileErrorAdapter = class {
+  /** @throws {RangeError} if `maxEntries` or `indent` is invalid, or `maxEntries` is used outside array mode. */
+  constructor(filePath, options = {}) {
+    this.filePath = filePath;
+    this.directoryReady = false;
+    this.queue = Promise.resolve();
+    this.mode = options.mode ?? "ndjson";
+    this.maxEntries = options.maxEntries;
+    this.indent = options.indent ?? DEFAULT_INDENT;
+    this.fs = options.fs;
+    this.createDirectory = options.createDirectory ?? true;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+    if (this.maxEntries !== void 0) {
+      if (this.mode !== "array") {
+        throw new RangeError(
+          `JsonFileErrorAdapter: maxEntries only applies to mode "array", but mode is "${this.mode}". Use mode "array" or remove maxEntries.`
+        );
+      }
+      if (!Number.isInteger(this.maxEntries) || this.maxEntries < 1) {
+        throw new RangeError(
+          `JsonFileErrorAdapter: maxEntries must be a positive integer, received ${String(this.maxEntries)}.`
+        );
+      }
+    }
+    if (!Number.isInteger(this.indent) || this.indent < 0) {
+      throw new RangeError(
+        `JsonFileErrorAdapter: indent must be a non-negative integer, received ${String(this.indent)}.`
+      );
+    }
+  }
+  log(entry) {
+    const result = this.queue.then(
+      () => this.write(entry)
+    );
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async write(entry) {
+    try {
+      const record = {
+        id: crypto.randomUUID(),
+        ...serializeEntry(entry)
+      };
+      const fs = await this.getFileSystem();
+      await this.prepareDirectory(fs);
+      if (this.mode === "ndjson") {
+        await fs.appendFile(this.filePath, `${JSON.stringify(record)}
+`);
+      } else {
+        await this.rewriteArray(fs, record);
+      }
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} JsonFileErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `JsonFileErrorAdapter failed to write "${this.filePath}" in ${this.mode} mode: ${describeError(error)}`
+      };
+    }
+  }
+  async getFileSystem() {
+    if (this.fs === void 0) {
+      this.fs = await loadNodeFileSystem();
+    }
+    return this.fs;
+  }
+  async prepareDirectory(fs) {
+    if (!this.createDirectory || this.directoryReady) {
+      return;
+    }
+    const directory = parentDirectory(this.filePath);
+    if (directory !== null) {
+      await fs.mkdir(directory, { recursive: true });
+    }
+    this.directoryReady = true;
+  }
+  /**
+   * Adds the record to the array and replaces the file. The new content is
+   * written to a temporary file first and renamed into place, so a crash
+   * mid-write cannot leave a half-written file.
+   */
+  async rewriteArray(fs, record) {
+    const records = [
+      ...await this.readRecords(fs),
+      record
+    ];
+    const kept = this.maxEntries === void 0 ? records : records.slice(-this.maxEntries);
+    const temporaryPath = `${this.filePath}.tmp`;
+    await fs.writeFile(
+      temporaryPath,
+      `${JSON.stringify(kept, null, this.indent)}
+`
+    );
+    await fs.rename(temporaryPath, this.filePath);
+  }
+  /**
+   * Returns the records already in the file. A missing or empty file has none.
+   * A file that is not a JSON array is moved to `<path>.corrupt` (so nothing is
+   * lost) and logging continues with a fresh file.
+   */
+  async readRecords(fs) {
+    let content;
+    try {
+      content = await fs.readFile(this.filePath, "utf8");
+    } catch (error) {
+      if (isMissingFileError(error)) {
+        return [];
+      }
+      throw error;
+    }
+    if (content.trim() === "") {
+      return [];
+    }
+    let problem;
+    try {
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+      problem = "did not hold a JSON array";
+    } catch (error) {
+      problem = `held invalid JSON (${describeError(error)})`;
+    }
+    const corruptPath = `${this.filePath}.corrupt`;
+    await fs.rename(this.filePath, corruptPath);
+    console.error(
+      `${this.prefix} JsonFileErrorAdapter: "${this.filePath}" ${problem}, so it was moved to "${corruptPath}" and a new file was started.`
+    );
+    return [];
+  }
+};
+
+// src/adapters/sql-error-adapter.ts
+var DEFAULT_TABLE_NAME2 = "error_log";
+var MAX_TABLE_NAME_LENGTH = 47;
+var IDENTIFIER_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertValidTableName2(tableName, adapterName) {
+  if (!IDENTIFIER_PATTERN2.test(tableName)) {
+    throw new RangeError(
+      `${adapterName}: invalid table name "${tableName}". Use only letters, digits and underscores, and do not start with a digit.`
+    );
+  }
+  if (tableName.length > MAX_TABLE_NAME_LENGTH) {
+    throw new RangeError(
+      `${adapterName}: table name "${tableName}" is ${tableName.length} characters long, but the limit is ${MAX_TABLE_NAME_LENGTH}.`
+    );
+  }
+}
+function quoteIdentifier(dialect, identifier) {
+  return dialect === "postgres" ? `"${identifier}"` : `\`${identifier}\``;
+}
+function buildErrorLogTableDdl(dialect, tableName = DEFAULT_TABLE_NAME2) {
+  assertValidTableName2(tableName, "buildErrorLogTableDdl");
+  const table = quoteIdentifier(dialect, tableName);
+  const index = quoteIdentifier(
+    dialect,
+    `${tableName}_occurred_at_idx`
+  );
+  if (dialect === "postgres") {
+    return [
+      `CREATE TABLE IF NOT EXISTS ${table} (id UUID PRIMARY KEY, code TEXT NOT NULL, message TEXT NOT NULL, cause JSONB, source TEXT, occurred_at TIMESTAMPTZ NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now())`,
+      `CREATE INDEX IF NOT EXISTS ${index} ON ${table} (occurred_at)`
+    ];
+  }
+  return [
+    `CREATE TABLE IF NOT EXISTS ${table} (id CHAR(36) NOT NULL PRIMARY KEY, code VARCHAR(255) NOT NULL, message TEXT NOT NULL, cause JSON NULL, source VARCHAR(255) NULL, occurred_at DATETIME(3) NOT NULL, created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3), INDEX ${index} (occurred_at))`
+  ];
+}
+function toMysqlDateTime(date) {
+  return date.toISOString().replace("T", " ").replace("Z", "");
+}
+var SqlErrorAdapter = class {
+  constructor(client, dialect, adapterName, options) {
+    this.client = client;
+    this.dialect = dialect;
+    this.adapterName = adapterName;
+    this.tableReady = null;
+    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME2;
+    assertValidTableName2(this.tableName, adapterName);
+    this.createTable = options.createTable ?? true;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+  }
+  async log(entry) {
+    try {
+      const serialized = serializeEntry(entry);
+      const occurredAt = new Date(serialized.timestamp);
+      if (Number.isNaN(occurredAt.getTime())) {
+        throw new RangeError(
+          `timestamp "${serialized.timestamp}" is not a valid ISO 8601 date`
+        );
+      }
+      const params = [
+        crypto.randomUUID(),
+        serialized.code,
+        serialized.message,
+        serialized.cause === void 0 ? null : JSON.stringify(serialized.cause),
+        serialized.source ?? null,
+        this.dialect === "postgres" ? occurredAt.toISOString() : toMysqlDateTime(occurredAt)
+      ];
+      await this.ensureTable();
+      await this.client.query(this.insertSql(), params);
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} ${this.adapterName}:`, error);
+      return {
+        ok: false,
+        error: `${this.adapterName} failed to write to table "${this.tableName}": ${describeError(error)}`
+      };
+    }
+  }
+  insertSql() {
+    const placeholders = this.dialect === "postgres" ? "$1, $2, $3, $4, $5, $6" : "?, ?, ?, ?, ?, ?";
+    return `INSERT INTO ${quoteIdentifier(this.dialect, this.tableName)} (id, code, message, cause, source, occurred_at) VALUES (${placeholders})`;
+  }
+  /** Creates the table once. A failed attempt is retried on the next log call. */
+  ensureTable() {
+    if (!this.createTable) {
+      return Promise.resolve();
+    }
+    if (this.tableReady === null) {
+      this.tableReady = this.runCreateStatements().catch(
+        (error) => {
+          this.tableReady = null;
+          throw error;
+        }
+      );
+    }
+    return this.tableReady;
+  }
+  async runCreateStatements() {
+    for (const sql of buildErrorLogTableDdl(this.dialect, this.tableName)) {
+      await this.client.query(sql, []);
+    }
+  }
+};
+var PostgresErrorAdapter = class extends SqlErrorAdapter {
+  /** @throws {RangeError} if `options.tableName` is not a plain identifier of 47 characters or fewer. */
+  constructor(client, options = {}) {
+    super(client, "postgres", "PostgresErrorAdapter", options);
+  }
+};
+var MySqlErrorAdapter = class extends SqlErrorAdapter {
+  /** @throws {RangeError} if `options.tableName` is not a plain identifier of 47 characters or fewer. */
+  constructor(client, options = {}) {
+    super(client, "mysql", "MySqlErrorAdapter", options);
+  }
+};
+
+// src/adapters/redis-error-adapter.ts
+var DEFAULT_REDIS_KEY = "error_log";
+var RedisErrorAdapter = class {
+  /** @throws {RangeError} if `key` is empty, `maxEntries` is not a positive integer, or `mode` / `side` is unknown. */
+  constructor(client, options = {}) {
+    this.client = client;
+    this.mode = options.mode ?? "list";
+    this.key = options.key ?? DEFAULT_REDIS_KEY;
+    this.maxEntries = options.maxEntries;
+    this.side = options.side ?? "right";
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+    if (this.mode !== "list" && this.mode !== "stream") {
+      throw new RangeError(
+        `RedisErrorAdapter: mode must be "list" or "stream", received "${String(options.mode)}".`
+      );
+    }
+    if (this.side !== "left" && this.side !== "right") {
+      throw new RangeError(
+        `RedisErrorAdapter: side must be "left" or "right", received "${String(options.side)}".`
+      );
+    }
+    if (this.key === "") {
+      throw new RangeError("RedisErrorAdapter: key must not be empty.");
+    }
+    if (this.maxEntries !== void 0 && (!Number.isInteger(this.maxEntries) || this.maxEntries < 1)) {
+      throw new RangeError(
+        `RedisErrorAdapter: maxEntries must be a positive integer, received ${String(this.maxEntries)}.`
+      );
+    }
+  }
+  async log(entry) {
+    try {
+      const record = { id: crypto.randomUUID(), ...serializeEntry(entry) };
+      if (this.mode === "stream") {
+        await this.client.sendCommand(this.buildStreamCommand(record));
+      } else {
+        await this.client.sendCommand([
+          this.side === "left" ? "LPUSH" : "RPUSH",
+          this.key,
+          JSON.stringify(record)
+        ]);
+        await this.trimList();
+      }
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} RedisErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `RedisErrorAdapter failed to write to ${this.mode} "${this.key}": ${describeError(error)}`
+      };
+    }
+  }
+  buildStreamCommand(record) {
+    const command = ["XADD", this.key];
+    if (this.maxEntries !== void 0) {
+      command.push("MAXLEN", "=", String(this.maxEntries));
+    }
+    command.push(
+      "*",
+      "id",
+      record.id,
+      "code",
+      record.code,
+      "message",
+      record.message,
+      "timestamp",
+      record.timestamp
+    );
+    if (record.cause !== void 0) {
+      command.push("cause", JSON.stringify(record.cause));
+    }
+    if (record.source !== void 0) {
+      command.push("source", record.source);
+    }
+    return command;
+  }
+  /**
+   * Drops the oldest list entries beyond `maxEntries`. The entry is already
+   * stored by now, so a trim failure is reported but does not fail the call;
+   * the next successful write trims the list again.
+   */
+  async trimList() {
+    if (this.maxEntries === void 0) {
+      return;
+    }
+    const keep = this.maxEntries;
+    const [start, stop] = this.side === "right" ? [String(-keep), "-1"] : ["0", String(keep - 1)];
+    try {
+      await this.client.sendCommand(["LTRIM", this.key, start, stop]);
+    } catch (error) {
+      console.error(
+        `${this.prefix} RedisErrorAdapter: stored the entry but could not trim list "${this.key}" to ${keep} entries: ${describeError(error)}`
+      );
+    }
+  }
+};
+
+// src/adapters/s3-error-adapter.ts
+var DEFAULT_S3_PREFIX = "error_log/";
+var BUFFER_LIMIT_MULTIPLIER = 10;
+function datePath(date) {
+  const compact = date.toISOString().replace(/[-:.]/g, "");
+  return `${compact.slice(0, 4)}/${compact.slice(4, 6)}/${compact.slice(6, 8)}/${compact}`;
+}
+function normalizePrefix(prefix) {
+  const trimmed = prefix.replace(/^\/+/, "");
+  return trimmed === "" || trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+var S3ErrorAdapter = class {
+  /** @throws {RangeError} if `bucket` is empty or the batch options are invalid. */
+  constructor(client, bucket, options = {}) {
+    this.client = client;
+    this.bucket = bucket;
+    this.buffer = [];
+    this.timer = null;
+    this.flushQueue = Promise.resolve();
+    this.keyPrefix = normalizePrefix(options.keyPrefix ?? DEFAULT_S3_PREFIX);
+    this.batch = options.batch;
+    this.contentType = options.contentType ?? (this.batch === void 0 ? "application/json" : "application/x-ndjson");
+    this.logPrefix = options.prefix ?? "[error-log-adapter]";
+    if (bucket === "") {
+      throw new RangeError("S3ErrorAdapter: bucket must not be empty.");
+    }
+    if (this.batch !== void 0) {
+      if (!Number.isInteger(this.batch.batchSize) || this.batch.batchSize < 1) {
+        throw new RangeError(
+          `S3ErrorAdapter: batch.batchSize must be a positive integer, received ${String(this.batch.batchSize)}.`
+        );
+      }
+      if (this.batch.maxWaitMs !== void 0 && (!Number.isFinite(this.batch.maxWaitMs) || this.batch.maxWaitMs <= 0)) {
+        throw new RangeError(
+          `S3ErrorAdapter: batch.maxWaitMs must be a positive number, received ${String(this.batch.maxWaitMs)}.`
+        );
+      }
+    }
+  }
+  async log(entry) {
+    try {
+      const record = {
+        id: crypto.randomUUID(),
+        ...serializeEntry(entry)
+      };
+      const occurredAt = new Date(record.timestamp);
+      if (Number.isNaN(occurredAt.getTime())) {
+        throw new RangeError(
+          `timestamp "${record.timestamp}" is not a valid ISO 8601 date`
+        );
+      }
+      if (this.batch === void 0) {
+        const key = `${this.keyPrefix}${datePath(occurredAt)}-${record.id}.json`;
+        await this.upload(key, `${JSON.stringify(record)}
+`);
+        return { ok: true };
+      }
+      return await this.addToBatch(record, this.batch);
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  /**
+   * Uploads any buffered entries now. Resolves ok when nothing is buffered.
+   * Entries from a failed upload stay buffered and are retried by the next flush.
+   */
+  flush() {
+    const result = this.flushQueue.then(
+      () => this.uploadBuffered()
+    );
+    this.flushQueue = result.catch(() => void 0);
+    return result;
+  }
+  async addToBatch(record, batch) {
+    this.buffer.push(record);
+    const limit = batch.batchSize * BUFFER_LIMIT_MULTIPLIER;
+    if (this.buffer.length > limit) {
+      const dropped = this.buffer.length - limit;
+      this.buffer = this.buffer.slice(dropped);
+      console.error(
+        `${this.logPrefix} S3ErrorAdapter: dropped the ${dropped} oldest buffered entries because uploads to bucket "${this.bucket}" keep failing and the buffer is full (${limit} entries).`
+      );
+    }
+    if (this.buffer.length >= batch.batchSize) {
+      return this.flush();
+    }
+    this.scheduleFlush(batch);
+    return { ok: true };
+  }
+  scheduleFlush(batch) {
+    if (batch.maxWaitMs === void 0 || this.timer !== null) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, batch.maxWaitMs);
+    timer.unref?.();
+    this.timer = timer;
+  }
+  async uploadBuffered() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const pending = this.buffer.slice();
+    if (pending.length === 0) {
+      return { ok: true };
+    }
+    try {
+      const key = `${this.keyPrefix}${datePath(/* @__PURE__ */ new Date())}-${crypto.randomUUID()}.ndjson`;
+      const body = pending.map((record) => JSON.stringify(record)).join("\n");
+      await this.upload(key, `${body}
+`);
+      const uploaded = new Set(pending);
+      this.buffer = this.buffer.filter(
+        (record) => !uploaded.has(record)
+      );
+      return { ok: true };
+    } catch (error) {
+      if (this.batch !== void 0) {
+        this.scheduleFlush(this.batch);
+      }
+      return this.fail(error, pending.length);
+    }
+  }
+  upload(key, body) {
+    return this.client.putObject({
+      Bucket: this.bucket,
+      Key: key,
+      Body: body,
+      ContentType: this.contentType
+    });
+  }
+  fail(error, bufferedCount) {
+    console.error(`${this.logPrefix} S3ErrorAdapter:`, error);
+    const retry = bufferedCount === void 0 ? "" : ` (${bufferedCount} buffered ${bufferedCount === 1 ? "entry was" : "entries were"} kept for the next flush)`;
+    return {
+      ok: false,
+      error: `S3ErrorAdapter failed to upload to bucket "${this.bucket}": ${describeError(error)}${retry}`
+    };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
+  FlatFileErrorAdapter,
+  IndexedDbErrorAdapter,
+  JsonFileErrorAdapter,
   MongoDbErrorAdapter,
+  MySqlErrorAdapter,
+  PostgresErrorAdapter,
+  RedisErrorAdapter,
+  S3ErrorAdapter,
+  SqliteErrorAdapter,
+  WebStorageErrorAdapter,
   WebhookErrorAdapter,
+  buildCreateErrorLogTableSql,
+  buildErrorLogTableDdl,
+  createErrorLogStore,
+  formatErrorLogLine,
   serializeCause,
   serializeEntry
 });