@richardmcquiston01/error-log-adapter 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -22,19 +22,23 @@ var index_exports = {};
 __export(index_exports, {
   CompositeErrorAdapter: () => CompositeErrorAdapter,
   ConsoleErrorAdapter: () => ConsoleErrorAdapter,
+  FirestoreErrorAdapter: () => FirestoreErrorAdapter,
   FlatFileErrorAdapter: () => FlatFileErrorAdapter,
   IndexedDbErrorAdapter: () => IndexedDbErrorAdapter,
   JsonFileErrorAdapter: () => JsonFileErrorAdapter,
   MongoDbErrorAdapter: () => MongoDbErrorAdapter,
   MySqlErrorAdapter: () => MySqlErrorAdapter,
   PostgresErrorAdapter: () => PostgresErrorAdapter,
+  RealtimeDatabaseErrorAdapter: () => RealtimeDatabaseErrorAdapter,
   RedisErrorAdapter: () => RedisErrorAdapter,
   S3ErrorAdapter: () => S3ErrorAdapter,
   SqliteErrorAdapter: () => SqliteErrorAdapter,
+  SupabaseErrorAdapter: () => SupabaseErrorAdapter,
   WebStorageErrorAdapter: () => WebStorageErrorAdapter,
   WebhookErrorAdapter: () => WebhookErrorAdapter,
   buildCreateErrorLogTableSql: () => buildCreateErrorLogTableSql,
   buildErrorLogTableDdl: () => buildErrorLogTableDdl,
+  buildSupabaseSetupSql: () => buildSupabaseSetupSql,
   createErrorLogStore: () => createErrorLogStore,
   formatErrorLogLine: () => formatErrorLogLine,
   serializeCause: () => serializeCause,
@@ -1029,23 +1033,218 @@ 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}`
+    };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
+  FirestoreErrorAdapter,
   FlatFileErrorAdapter,
   IndexedDbErrorAdapter,
   JsonFileErrorAdapter,
   MongoDbErrorAdapter,
   MySqlErrorAdapter,
   PostgresErrorAdapter,
+  RealtimeDatabaseErrorAdapter,
   RedisErrorAdapter,
   S3ErrorAdapter,
   SqliteErrorAdapter,
+  SupabaseErrorAdapter,
   WebStorageErrorAdapter,
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,
   buildErrorLogTableDdl,
+  buildSupabaseSetupSql,
   createErrorLogStore,
   formatErrorLogLine,
   serializeCause,