@richardmcquiston01/error-log-adapter 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -628,17 +628,574 @@ var JsonFileErrorAdapter = class {
     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}`
+    };
+  }
+};
+
+// 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,