@richardmcquiston01/error-log-adapter 0.3.0 → 0.4.0

package/dist/index.d.cts

@@ -492,6 +492,11 @@ interface S3PutObjectInput {
  * it is, and so does anything else that follows the S3 API, including
  * DigitalOcean Spaces, Cloudflare R2 and MinIO when you point the client at
  * their endpoint.
+ *
+ * Some S3-compatible providers reject the checksum headers that recent AWS SDK
+ * v3 versions add by default. If uploads fail with a checksum or header error,
+ * create the client with `requestChecksumCalculation: 'WHEN_REQUIRED'` and
+ * `responseChecksumValidation: 'WHEN_REQUIRED'`.
  */
 interface S3ClientLike {
     putObject(input: S3PutObjectInput): Promise<unknown>;
@@ -559,4 +564,167 @@ declare class S3ErrorAdapter<TCode extends string = string> implements ErrorLogA
     private fail;
 }
 
-export { type CollectionLike, CompositeErrorAdapter, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };
+/** The fields stored for each entry, in Firestore and in the Realtime Database. */
+interface FirebaseErrorRecord {
+    /** UUID. In Firestore it is also the document id. */
+    id: string;
+    code: string;
+    message: string;
+    /** ISO 8601 timestamp of the entry. */
+    timestamp: string;
+    source?: string;
+    /**
+     * The entry's cause as a JSON string. Plain text avoids Firestore's limits on
+     * custom objects and nested arrays, and the Realtime Database's limits on key
+     * characters, so an odd cause can never make the write fail.
+     */
+    cause?: string;
+}
+/**
+ * The only thing the Firestore adapter needs from a collection: `doc(id).set(data)`.
+ * A `firebase-admin` collection (`getFirestore().collection('error_log')`) fits
+ * as it is. With the web SDK, wrap it:
+ *
+ * ```ts
+ * const collectionLike: FirestoreCollectionLike = {
+ *   doc: (id) => ({ set: (data) => setDoc(doc(db, 'error_log', id), data) }),
+ * };
+ * ```
+ */
+interface FirestoreCollectionLike {
+    doc(documentId: string): {
+        set(data: FirebaseErrorRecord): Promise<unknown>;
+    };
+}
+/**
+ * The only thing the Realtime Database adapter needs from a reference:
+ * `push(value)`, which resolves once the write is saved. A `firebase-admin`
+ * reference (`getDatabase().ref('error_log')`) fits as it is. With the web SDK, wrap it:
+ *
+ * ```ts
+ * const refLike: RealtimeDatabaseRefLike = {
+ *   push: (value) => push(ref(db, 'error_log'), value),
+ * };
+ * ```
+ */
+interface RealtimeDatabaseRefLike {
+    push(value: FirebaseErrorRecord): PromiseLike<unknown>;
+}
+interface FirebaseErrorOptions {
+    /**
+     * How long `log` waits for the write to be saved before giving up, in
+     * milliseconds. Defaults to 10000. Pass `Infinity` to wait without limit.
+     *
+     * The Firebase SDKs keep writes queued while the connection is down, and
+     * their promises stay pending until it returns, so without a limit `log`
+     * could hang for as long as an outage lasts. A write that timed out is still
+     * queued by the SDK and may be saved later.
+     */
+    timeoutMs?: number;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Writes each entry as a document in a Firestore collection. The document id is
+ * the entry's UUID, so retrying a write never creates a duplicate.
+ */
+declare class FirestoreErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly collection;
+    private readonly prefix;
+    private readonly timeoutMs;
+    /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
+    constructor(collection: FirestoreCollectionLike, options?: FirebaseErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+/**
+ * Writes each entry under a Realtime Database reference with `push`, which
+ * generates a chronologically ordered key.
+ */
+declare class RealtimeDatabaseErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly reference;
+    private readonly prefix;
+    private readonly timeoutMs;
+    /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
+    constructor(reference: RealtimeDatabaseRefLike, options?: FirebaseErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+/** The row inserted for each entry. The columns match the Postgres adapter's table. */
+interface SupabaseErrorRow {
+    /** UUID primary key. */
+    id: string;
+    code: string;
+    message: string;
+    /** The cause as JSON, or `null` when the entry has none. */
+    cause: unknown;
+    source: string | null;
+    /** ISO 8601 timestamp of the entry. */
+    occurred_at: string;
+}
+/** The error object `supabase-js` returns (a `PostgrestError`) instead of throwing. */
+interface SupabaseErrorLike {
+    message: string;
+    code?: string;
+    details?: string | null;
+    hint?: string | null;
+}
+/** What `insert` resolves to. The status fields are used when the error has no message. */
+interface SupabaseInsertResult {
+    error: SupabaseErrorLike | null;
+    status?: number;
+    statusText?: string;
+}
+/**
+ * The only thing the Supabase adapter needs from a client: `from(table).insert(row)`.
+ * A `supabase-js` client (`createClient(url, key)`) fits as it is.
+ */
+interface SupabaseClientLike {
+    from(table: string): {
+        insert(row: SupabaseErrorRow): PromiseLike<SupabaseInsertResult>;
+    };
+}
+interface SupabaseErrorOptions {
+    /** Table to write to. Defaults to `error_log`. */
+    tableName?: string;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+interface SupabaseSetupOptions {
+    /**
+     * Postgres roles allowed to insert, for example `['anon', 'authenticated']`
+     * when the browser logs with the public key. Leave empty when only a server
+     * using the service role key logs: that role bypasses row level security.
+     */
+    insertRoles?: string[];
+}
+/**
+ * Returns the SQL to run once in the Supabase SQL editor: the error log table,
+ * with row level security turned on (as Supabase recommends for every table in
+ * an exposed schema) and, optionally, an insert-only policy for the given roles.
+ * Nobody but the service role can read the log through the API.
+ *
+ * @throws {RangeError} if the table name or a role is not a plain identifier.
+ */
+declare function buildSupabaseSetupSql(tableName?: string, options?: SupabaseSetupOptions): string[];
+/**
+ * Writes entries to a Supabase table through `supabase-js`. Create the table
+ * first with `buildSupabaseSetupSql` (or `buildErrorLogTableDdl('postgres')`).
+ *
+ * ```ts
+ * const adapter = new SupabaseErrorAdapter(createClient(url, serviceRoleKey));
+ * ```
+ *
+ * `supabase-js` reports failures in a returned `error` field rather than
+ * throwing; the adapter turns both that and a thrown error into `{ ok: false }`.
+ */
+declare class SupabaseErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly client;
+    private readonly tableName;
+    private readonly prefix;
+    /** @throws {RangeError} if `options.tableName` is empty. */
+    constructor(client: SupabaseClientLike, options?: SupabaseErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    private fail;
+}
+
+export { type CollectionLike, CompositeErrorAdapter, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };

package/dist/index.d.ts

@@ -492,6 +492,11 @@ interface S3PutObjectInput {
  * it is, and so does anything else that follows the S3 API, including
  * DigitalOcean Spaces, Cloudflare R2 and MinIO when you point the client at
  * their endpoint.
+ *
+ * Some S3-compatible providers reject the checksum headers that recent AWS SDK
+ * v3 versions add by default. If uploads fail with a checksum or header error,
+ * create the client with `requestChecksumCalculation: 'WHEN_REQUIRED'` and
+ * `responseChecksumValidation: 'WHEN_REQUIRED'`.
  */
 interface S3ClientLike {
     putObject(input: S3PutObjectInput): Promise<unknown>;
@@ -559,4 +564,167 @@ declare class S3ErrorAdapter<TCode extends string = string> implements ErrorLogA
     private fail;
 }
 
-export { type CollectionLike, CompositeErrorAdapter, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };
+/** The fields stored for each entry, in Firestore and in the Realtime Database. */
+interface FirebaseErrorRecord {
+    /** UUID. In Firestore it is also the document id. */
+    id: string;
+    code: string;
+    message: string;
+    /** ISO 8601 timestamp of the entry. */
+    timestamp: string;
+    source?: string;
+    /**
+     * The entry's cause as a JSON string. Plain text avoids Firestore's limits on
+     * custom objects and nested arrays, and the Realtime Database's limits on key
+     * characters, so an odd cause can never make the write fail.
+     */
+    cause?: string;
+}
+/**
+ * The only thing the Firestore adapter needs from a collection: `doc(id).set(data)`.
+ * A `firebase-admin` collection (`getFirestore().collection('error_log')`) fits
+ * as it is. With the web SDK, wrap it:
+ *
+ * ```ts
+ * const collectionLike: FirestoreCollectionLike = {
+ *   doc: (id) => ({ set: (data) => setDoc(doc(db, 'error_log', id), data) }),
+ * };
+ * ```
+ */
+interface FirestoreCollectionLike {
+    doc(documentId: string): {
+        set(data: FirebaseErrorRecord): Promise<unknown>;
+    };
+}
+/**
+ * The only thing the Realtime Database adapter needs from a reference:
+ * `push(value)`, which resolves once the write is saved. A `firebase-admin`
+ * reference (`getDatabase().ref('error_log')`) fits as it is. With the web SDK, wrap it:
+ *
+ * ```ts
+ * const refLike: RealtimeDatabaseRefLike = {
+ *   push: (value) => push(ref(db, 'error_log'), value),
+ * };
+ * ```
+ */
+interface RealtimeDatabaseRefLike {
+    push(value: FirebaseErrorRecord): PromiseLike<unknown>;
+}
+interface FirebaseErrorOptions {
+    /**
+     * How long `log` waits for the write to be saved before giving up, in
+     * milliseconds. Defaults to 10000. Pass `Infinity` to wait without limit.
+     *
+     * The Firebase SDKs keep writes queued while the connection is down, and
+     * their promises stay pending until it returns, so without a limit `log`
+     * could hang for as long as an outage lasts. A write that timed out is still
+     * queued by the SDK and may be saved later.
+     */
+    timeoutMs?: number;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Writes each entry as a document in a Firestore collection. The document id is
+ * the entry's UUID, so retrying a write never creates a duplicate.
+ */
+declare class FirestoreErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly collection;
+    private readonly prefix;
+    private readonly timeoutMs;
+    /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
+    constructor(collection: FirestoreCollectionLike, options?: FirebaseErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+/**
+ * Writes each entry under a Realtime Database reference with `push`, which
+ * generates a chronologically ordered key.
+ */
+declare class RealtimeDatabaseErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly reference;
+    private readonly prefix;
+    private readonly timeoutMs;
+    /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
+    constructor(reference: RealtimeDatabaseRefLike, options?: FirebaseErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+/** The row inserted for each entry. The columns match the Postgres adapter's table. */
+interface SupabaseErrorRow {
+    /** UUID primary key. */
+    id: string;
+    code: string;
+    message: string;
+    /** The cause as JSON, or `null` when the entry has none. */
+    cause: unknown;
+    source: string | null;
+    /** ISO 8601 timestamp of the entry. */
+    occurred_at: string;
+}
+/** The error object `supabase-js` returns (a `PostgrestError`) instead of throwing. */
+interface SupabaseErrorLike {
+    message: string;
+    code?: string;
+    details?: string | null;
+    hint?: string | null;
+}
+/** What `insert` resolves to. The status fields are used when the error has no message. */
+interface SupabaseInsertResult {
+    error: SupabaseErrorLike | null;
+    status?: number;
+    statusText?: string;
+}
+/**
+ * The only thing the Supabase adapter needs from a client: `from(table).insert(row)`.
+ * A `supabase-js` client (`createClient(url, key)`) fits as it is.
+ */
+interface SupabaseClientLike {
+    from(table: string): {
+        insert(row: SupabaseErrorRow): PromiseLike<SupabaseInsertResult>;
+    };
+}
+interface SupabaseErrorOptions {
+    /** Table to write to. Defaults to `error_log`. */
+    tableName?: string;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+interface SupabaseSetupOptions {
+    /**
+     * Postgres roles allowed to insert, for example `['anon', 'authenticated']`
+     * when the browser logs with the public key. Leave empty when only a server
+     * using the service role key logs: that role bypasses row level security.
+     */
+    insertRoles?: string[];
+}
+/**
+ * Returns the SQL to run once in the Supabase SQL editor: the error log table,
+ * with row level security turned on (as Supabase recommends for every table in
+ * an exposed schema) and, optionally, an insert-only policy for the given roles.
+ * Nobody but the service role can read the log through the API.
+ *
+ * @throws {RangeError} if the table name or a role is not a plain identifier.
+ */
+declare function buildSupabaseSetupSql(tableName?: string, options?: SupabaseSetupOptions): string[];
+/**
+ * Writes entries to a Supabase table through `supabase-js`. Create the table
+ * first with `buildSupabaseSetupSql` (or `buildErrorLogTableDdl('postgres')`).
+ *
+ * ```ts
+ * const adapter = new SupabaseErrorAdapter(createClient(url, serviceRoleKey));
+ * ```
+ *
+ * `supabase-js` reports failures in a returned `error` field rather than
+ * throwing; the adapter turns both that and a thrown error into `{ ok: false }`.
+ */
+declare class SupabaseErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly client;
+    private readonly tableName;
+    private readonly prefix;
+    /** @throws {RangeError} if `options.tableName` is empty. */
+    constructor(client: SupabaseClientLike, options?: SupabaseErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    private fail;
+}
+
+export { type CollectionLike, CompositeErrorAdapter, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };

package/dist/index.mjs

@@ -985,22 +985,217 @@ var S3ErrorAdapter = class {
     };
   }
 };
+
+// src/adapters/firebase-error-adapter.ts
+var DEFAULT_WRITE_TIMEOUT_MS = 1e4;
+function resolveTimeout(options, adapter) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_WRITE_TIMEOUT_MS;
+  if (Number.isNaN(timeoutMs) || timeoutMs <= 0) {
+    throw new RangeError(
+      `${adapter}: timeoutMs must be a positive number or Infinity, received ${String(options.timeoutMs)}.`
+    );
+  }
+  return timeoutMs;
+}
+function waitForWrite(write, timeoutMs) {
+  if (timeoutMs === Infinity) {
+    return Promise.resolve(write);
+  }
+  return new Promise(
+    (resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(
+          new Error(
+            `the write was not saved within ${timeoutMs} ms (the connection may be down; the SDK keeps the write queued and may still save it later)`
+          )
+        );
+      }, timeoutMs);
+      write.then(
+        (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (reason) => {
+          clearTimeout(timer);
+          reject(reason);
+        }
+      );
+    }
+  );
+}
+function buildRecord(entry) {
+  const serialized = serializeEntry(entry);
+  const record = {
+    id: crypto.randomUUID(),
+    code: serialized.code,
+    message: serialized.message,
+    timestamp: serialized.timestamp
+  };
+  if (serialized.source !== void 0) {
+    record.source = serialized.source;
+  }
+  if (serialized.cause !== void 0) {
+    record.cause = JSON.stringify(serialized.cause);
+  }
+  return record;
+}
+var FirestoreErrorAdapter = class {
+  /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
+  constructor(collection, options = {}) {
+    this.collection = collection;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.timeoutMs = resolveTimeout(options, "FirestoreErrorAdapter");
+  }
+  async log(entry) {
+    try {
+      const record = buildRecord(entry);
+      await waitForWrite(
+        this.collection.doc(record.id).set(record),
+        this.timeoutMs
+      );
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} FirestoreErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `FirestoreErrorAdapter failed to write the document: ${describeError(error)}`
+      };
+    }
+  }
+};
+var RealtimeDatabaseErrorAdapter = class {
+  /** @throws {RangeError} if `options.timeoutMs` is not a positive number or `Infinity`. */
+  constructor(reference, options = {}) {
+    this.reference = reference;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+    this.timeoutMs = resolveTimeout(options, "RealtimeDatabaseErrorAdapter");
+  }
+  async log(entry) {
+    try {
+      await waitForWrite(
+        this.reference.push(buildRecord(entry)),
+        this.timeoutMs
+      );
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} RealtimeDatabaseErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `RealtimeDatabaseErrorAdapter failed to write the entry: ${describeError(error)}`
+      };
+    }
+  }
+};
+
+// src/adapters/supabase-error-adapter.ts
+var IDENTIFIER_PATTERN3 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function buildSupabaseSetupSql(tableName = DEFAULT_TABLE_NAME2, options = {}) {
+  const insertRoles = options.insertRoles ?? [];
+  for (const role of insertRoles) {
+    if (!IDENTIFIER_PATTERN3.test(role)) {
+      throw new RangeError(
+        `buildSupabaseSetupSql: invalid role name "${role}". Use only letters, digits and underscores, and do not start with a digit.`
+      );
+    }
+  }
+  const statements = [
+    ...buildErrorLogTableDdl("postgres", tableName),
+    `ALTER TABLE "${tableName}" ENABLE ROW LEVEL SECURITY`
+  ];
+  if (insertRoles.length > 0) {
+    const policy = `${tableName}_insert_only`;
+    statements.push(
+      `DROP POLICY IF EXISTS "${policy}" ON "${tableName}"`,
+      `CREATE POLICY "${policy}" ON "${tableName}" FOR INSERT TO ${insertRoles.map((role) => `"${role}"`).join(", ")} WITH CHECK (true)`
+    );
+  }
+  return statements;
+}
+function describeSupabaseError(result) {
+  const error = result.error ?? { message: "" };
+  const parts = [];
+  if (error.message) {
+    parts.push(error.message);
+  } else if (result.status) {
+    parts.push(
+      `HTTP ${result.status}${result.statusText ? ` ${result.statusText}` : ""} with no error message (a 404 usually means the table does not exist or is not exposed by the API)`
+    );
+  } else {
+    parts.push("unknown error with no message");
+  }
+  if (error.code) {
+    parts.push(`code ${error.code}`);
+  }
+  const detailsLine = (error.details ?? "").split("\n")[0].trim();
+  if (detailsLine && detailsLine !== error.message) {
+    parts.push(`details: ${detailsLine}`);
+  }
+  if (error.hint) {
+    parts.push(`hint: ${error.hint}`);
+  }
+  return parts.join("; ");
+}
+var SupabaseErrorAdapter = class {
+  /** @throws {RangeError} if `options.tableName` is empty. */
+  constructor(client, options = {}) {
+    this.client = client;
+    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME2;
+    if (this.tableName.trim() === "") {
+      throw new RangeError(
+        "SupabaseErrorAdapter: tableName must not be empty."
+      );
+    }
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+  }
+  async log(entry) {
+    try {
+      const serialized = serializeEntry(entry);
+      const row = {
+        id: crypto.randomUUID(),
+        code: serialized.code,
+        message: serialized.message,
+        cause: serialized.cause === void 0 ? null : serialized.cause,
+        source: serialized.source ?? null,
+        occurred_at: serialized.timestamp
+      };
+      const result = await this.client.from(this.tableName).insert(row);
+      if (result.error) {
+        console.error(`${this.prefix} SupabaseErrorAdapter:`, result);
+        return this.fail(describeSupabaseError(result));
+      }
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} SupabaseErrorAdapter:`, error);
+      return this.fail(describeError(error));
+    }
+  }
+  fail(reason) {
+    return {
+      ok: false,
+      error: `SupabaseErrorAdapter failed to insert into table "${this.tableName}": ${reason}`
+    };
+  }
+};
 export {
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
+  FirestoreErrorAdapter,
   FlatFileErrorAdapter,
   IndexedDbErrorAdapter,
   JsonFileErrorAdapter,
   MongoDbErrorAdapter,
   MySqlErrorAdapter,
   PostgresErrorAdapter,
+  RealtimeDatabaseErrorAdapter,
   RedisErrorAdapter,
   S3ErrorAdapter,
   SqliteErrorAdapter,
+  SupabaseErrorAdapter,
   WebStorageErrorAdapter,
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,
   buildErrorLogTableDdl,
+  buildSupabaseSetupSql,
   createErrorLogStore,
   formatErrorLogLine,
   serializeCause,