@usebetterdev/audit-drizzle 0.5.0-beta.1 → 0.6.0

package/dist/index.js

@@ -454,6 +454,455 @@ function assembleStats(summaryRows, eventsPerDayRows, topActorsRows, topTablesRo
   };
 }
 
+// src/sqlite-adapter.ts
+import { and as and4, eq as eq4, gte as gte4, lt as lt4, isNotNull as isNotNull2, sql as sql4, desc as desc4 } from "drizzle-orm";
+
+// src/sqlite-schema.ts
+import {
+  sqliteTable,
+  text as text2,
+  integer,
+  index as index2
+} from "drizzle-orm/sqlite-core";
+var sqliteAuditLogs = sqliteTable(
+  "audit_logs",
+  {
+    id: text2().primaryKey(),
+    timestamp: integer({ mode: "timestamp" }).notNull(),
+    tableName: text2("table_name").notNull(),
+    operation: text2().notNull(),
+    recordId: text2("record_id").notNull(),
+    actorId: text2("actor_id"),
+    beforeData: text2("before_data", { mode: "json" }),
+    afterData: text2("after_data", { mode: "json" }),
+    diff: text2({ mode: "json" }),
+    label: text2(),
+    description: text2(),
+    severity: text2(),
+    compliance: text2({ mode: "json" }),
+    notify: integer({ mode: "boolean" }),
+    reason: text2(),
+    metadata: text2({ mode: "json" }),
+    redactedFields: text2("redacted_fields", { mode: "json" })
+  },
+  (table) => ({
+    tableNameTimestampIdx: index2("audit_logs_table_name_timestamp_idx").on(
+      table.tableName,
+      table.timestamp
+    ),
+    actorIdIdx: index2("audit_logs_actor_id_idx").on(table.actorId),
+    recordIdIdx: index2("audit_logs_record_id_idx").on(table.recordId),
+    tableNameRecordIdIdx: index2("audit_logs_table_name_record_id_idx").on(
+      table.tableName,
+      table.recordId
+    ),
+    operationIdx: index2("audit_logs_operation_idx").on(table.operation),
+    timestampIdx: index2("audit_logs_timestamp_idx").on(table.timestamp),
+    timestampIdIdx: index2("audit_logs_timestamp_id_idx").on(table.timestamp, table.id)
+  })
+);
+
+// src/sqlite-column-map.ts
+var VALID_OPERATIONS2 = /* @__PURE__ */ new Set([
+  "INSERT",
+  "UPDATE",
+  "DELETE"
+]);
+var VALID_SEVERITIES2 = /* @__PURE__ */ new Set([
+  "low",
+  "medium",
+  "high",
+  "critical"
+]);
+function isAuditOperation2(value) {
+  return VALID_OPERATIONS2.has(value);
+}
+function isAuditSeverity2(value) {
+  return VALID_SEVERITIES2.has(value);
+}
+function sqliteAuditLogToRow(log) {
+  const row = {
+    id: log.id,
+    timestamp: log.timestamp,
+    tableName: log.tableName,
+    operation: log.operation,
+    recordId: log.recordId
+  };
+  if (log.actorId !== void 0) {
+    row.actorId = log.actorId;
+  }
+  if (log.beforeData !== void 0) {
+    row.beforeData = log.beforeData;
+  }
+  if (log.afterData !== void 0) {
+    row.afterData = log.afterData;
+  }
+  if (log.diff !== void 0) {
+    row.diff = log.diff;
+  }
+  if (log.label !== void 0) {
+    row.label = log.label;
+  }
+  if (log.description !== void 0) {
+    row.description = log.description;
+  }
+  if (log.severity !== void 0) {
+    row.severity = log.severity;
+  }
+  if (log.compliance !== void 0) {
+    row.compliance = log.compliance;
+  }
+  if (log.notify !== void 0) {
+    row.notify = log.notify;
+  }
+  if (log.reason !== void 0) {
+    row.reason = log.reason;
+  }
+  if (log.metadata !== void 0) {
+    row.metadata = log.metadata;
+  }
+  if (log.redactedFields !== void 0) {
+    row.redactedFields = log.redactedFields;
+  }
+  return row;
+}
+function sqliteRowToAuditLog(row) {
+  if (!isAuditOperation2(row.operation)) {
+    throw new Error(
+      `Invalid audit operation: "${row.operation}". Expected one of: INSERT, UPDATE, DELETE`
+    );
+  }
+  const log = {
+    id: row.id,
+    timestamp: row.timestamp,
+    tableName: row.tableName,
+    operation: row.operation,
+    recordId: row.recordId
+  };
+  if (row.actorId !== null) {
+    log.actorId = row.actorId;
+  }
+  if (row.beforeData !== null) {
+    log.beforeData = row.beforeData;
+  }
+  if (row.afterData !== null) {
+    log.afterData = row.afterData;
+  }
+  if (row.diff !== null) {
+    log.diff = row.diff;
+  }
+  if (row.label !== null) {
+    log.label = row.label;
+  }
+  if (row.description !== null) {
+    log.description = row.description;
+  }
+  if (row.severity !== null && row.severity !== void 0) {
+    if (!isAuditSeverity2(row.severity)) {
+      throw new Error(
+        `Invalid audit severity: "${row.severity}". Expected one of: low, medium, high, critical`
+      );
+    }
+    log.severity = row.severity;
+  }
+  if (row.compliance !== null) {
+    log.compliance = row.compliance;
+  }
+  if (row.notify !== null) {
+    log.notify = row.notify;
+  }
+  if (row.reason !== null) {
+    log.reason = row.reason;
+  }
+  if (row.metadata !== null) {
+    log.metadata = row.metadata;
+  }
+  if (row.redactedFields !== null) {
+    log.redactedFields = row.redactedFields;
+  }
+  return log;
+}
+
+// src/sqlite-query.ts
+import { parseDuration as parseDuration2 } from "@usebetterdev/audit-core";
+import {
+  and as and3,
+  or as or2,
+  eq as eq3,
+  gt as gt2,
+  lt as lt3,
+  gte as gte3,
+  lte as lte2,
+  inArray as inArray2,
+  like,
+  asc as asc2,
+  desc as desc3,
+  sql as sql3
+} from "drizzle-orm";
+function escapeLikePattern2(input) {
+  return input.replace(/[%_\\]/g, "\\$&");
+}
+function resolveTimeFilter2(filter) {
+  if ("date" in filter && filter.date !== void 0) {
+    return filter.date;
+  }
+  if ("duration" in filter && filter.duration !== void 0) {
+    return parseDuration2(filter.duration);
+  }
+  throw new Error("TimeFilter must have either date or duration");
+}
+function buildSqliteWhereConditions(filters) {
+  const conditions = [];
+  if (filters.resource !== void 0) {
+    conditions.push(eq3(sqliteAuditLogs.tableName, filters.resource.tableName));
+    if (filters.resource.recordId !== void 0) {
+      conditions.push(eq3(sqliteAuditLogs.recordId, filters.resource.recordId));
+    }
+  }
+  if (filters.actorIds !== void 0 && filters.actorIds.length > 0) {
+    if (filters.actorIds.length === 1) {
+      conditions.push(eq3(sqliteAuditLogs.actorId, filters.actorIds[0]));
+    } else {
+      conditions.push(inArray2(sqliteAuditLogs.actorId, filters.actorIds));
+    }
+  }
+  if (filters.severities !== void 0 && filters.severities.length > 0) {
+    if (filters.severities.length === 1) {
+      conditions.push(eq3(sqliteAuditLogs.severity, filters.severities[0]));
+    } else {
+      conditions.push(inArray2(sqliteAuditLogs.severity, filters.severities));
+    }
+  }
+  if (filters.operations !== void 0 && filters.operations.length > 0) {
+    if (filters.operations.length === 1) {
+      conditions.push(eq3(sqliteAuditLogs.operation, filters.operations[0]));
+    } else {
+      conditions.push(inArray2(sqliteAuditLogs.operation, filters.operations));
+    }
+  }
+  if (filters.since !== void 0) {
+    conditions.push(gte3(sqliteAuditLogs.timestamp, resolveTimeFilter2(filters.since)));
+  }
+  if (filters.until !== void 0) {
+    conditions.push(lte2(sqliteAuditLogs.timestamp, resolveTimeFilter2(filters.until)));
+  }
+  if (filters.searchText !== void 0 && filters.searchText.length > 0) {
+    const escaped = escapeLikePattern2(filters.searchText);
+    const pattern = `%${escaped}%`;
+    const searchCondition = or2(
+      like(sqliteAuditLogs.label, pattern),
+      like(sqliteAuditLogs.description, pattern)
+    );
+    if (searchCondition !== void 0) {
+      conditions.push(searchCondition);
+    }
+  }
+  if (filters.compliance !== void 0 && filters.compliance.length > 0) {
+    for (const tag of filters.compliance) {
+      conditions.push(
+        sql3`EXISTS (SELECT 1 FROM json_each(${sqliteAuditLogs.compliance}) WHERE value = ${tag})`
+      );
+    }
+  }
+  if (conditions.length === 0) {
+    return void 0;
+  }
+  return and3(...conditions);
+}
+function buildSqliteCursorCondition(cursor, sortOrder) {
+  const decoded = decodeSqliteCursor(cursor);
+  const tsCompare = sortOrder === "asc" ? gt2 : lt3;
+  const idCompare = sortOrder === "asc" ? gt2 : lt3;
+  return or2(
+    tsCompare(sqliteAuditLogs.timestamp, decoded.timestamp),
+    and3(
+      eq3(sqliteAuditLogs.timestamp, decoded.timestamp),
+      idCompare(sqliteAuditLogs.id, decoded.id)
+    )
+  );
+}
+function buildSqliteOrderBy(sortOrder) {
+  if (sortOrder === "asc") {
+    return [asc2(sqliteAuditLogs.timestamp), asc2(sqliteAuditLogs.id)];
+  }
+  return [desc3(sqliteAuditLogs.timestamp), desc3(sqliteAuditLogs.id)];
+}
+function encodeSqliteCursor(timestamp2, id) {
+  const payload = JSON.stringify({ t: timestamp2.toISOString(), i: id });
+  return btoa(payload);
+}
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function decodeSqliteCursor(cursor) {
+  let parsed;
+  try {
+    parsed = JSON.parse(atob(cursor));
+  } catch {
+    throw new Error("Invalid cursor: failed to decode");
+  }
+  if (typeof parsed !== "object" || parsed === null || !("t" in parsed) || !("i" in parsed)) {
+    throw new Error("Invalid cursor: missing required fields");
+  }
+  const { t, i } = parsed;
+  if (typeof t !== "string" || typeof i !== "string") {
+    throw new Error("Invalid cursor: fields must be strings");
+  }
+  const timestamp2 = new Date(t);
+  if (isNaN(timestamp2.getTime())) {
+    throw new Error("Invalid cursor: invalid timestamp");
+  }
+  if (!UUID_PATTERN2.test(i)) {
+    throw new Error("Invalid cursor: id must be a valid UUID");
+  }
+  return { timestamp: timestamp2, id: i };
+}
+
+// src/sqlite-adapter.ts
+var DEFAULT_LIMIT2 = 50;
+var MAX_LIMIT2 = 250;
+function toCount2(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return Number(value);
+  }
+  return 0;
+}
+function drizzleSqliteAuditAdapter(db) {
+  return {
+    async writeLog(log) {
+      const row = sqliteAuditLogToRow(log);
+      await db.insert(sqliteAuditLogs).values(row).execute();
+    },
+    async queryLogs(spec) {
+      const sortOrder = spec.sortOrder ?? "desc";
+      const limit = Math.min(spec.limit ?? DEFAULT_LIMIT2, MAX_LIMIT2);
+      const whereCondition = buildSqliteWhereConditions(spec.filters);
+      const cursorCondition = spec.cursor !== void 0 ? buildSqliteCursorCondition(spec.cursor, sortOrder) : void 0;
+      const combined = and4(whereCondition, cursorCondition);
+      const fetchLimit = limit + 1;
+      const orderColumns = buildSqliteOrderBy(sortOrder);
+      const query = db.select().from(sqliteAuditLogs).where(combined).orderBy(...orderColumns).limit(fetchLimit);
+      const rows = await query;
+      const hasNextPage = rows.length > limit;
+      const resultRows = hasNextPage ? rows.slice(0, -1) : rows;
+      const entries = resultRows.map(sqliteRowToAuditLog);
+      const lastRow = resultRows[resultRows.length - 1];
+      if (hasNextPage && lastRow !== void 0) {
+        return { entries, nextCursor: encodeSqliteCursor(lastRow.timestamp, lastRow.id) };
+      }
+      return { entries };
+    },
+    async getLogById(id) {
+      const query = db.select().from(sqliteAuditLogs).where(eq4(sqliteAuditLogs.id, id)).limit(1);
+      const rows = await query;
+      const row = rows[0];
+      if (row === void 0) {
+        return null;
+      }
+      return sqliteRowToAuditLog(row);
+    },
+    async purgeLogs(options) {
+      if (options.tableName !== void 0 && options.tableName.trim().length === 0) {
+        throw new Error("purgeLogs: tableName must be a non-empty string when provided");
+      }
+      const conditions = [lt4(sqliteAuditLogs.timestamp, options.before)];
+      if (options.tableName !== void 0) {
+        conditions.push(eq4(sqliteAuditLogs.tableName, options.tableName));
+      }
+      await db.delete(sqliteAuditLogs).where(and4(...conditions));
+      const changesResult = await db.select({ count: sql4`changes()` }).from(sqliteAuditLogs);
+      const deletedCount = changesResult[0] !== void 0 ? toCount2(changesResult[0].count) : 0;
+      return { deletedCount };
+    },
+    async getStats(options) {
+      const sinceCondition = options?.since !== void 0 ? gte4(sqliteAuditLogs.timestamp, options.since) : void 0;
+      const summaryQuery = db.select({
+        totalLogs: sql4`count(*)`,
+        tablesAudited: sql4`count(DISTINCT ${sqliteAuditLogs.tableName})`
+      }).from(sqliteAuditLogs).where(sinceCondition);
+      const eventsPerDayQuery = db.select({
+        date: sql4`strftime('%Y-%m-%d', ${sqliteAuditLogs.timestamp}, 'unixepoch')`,
+        count: sql4`count(*)`
+      }).from(sqliteAuditLogs).where(sinceCondition).groupBy(sql4`strftime('%Y-%m-%d', ${sqliteAuditLogs.timestamp}, 'unixepoch')`).orderBy(sql4`strftime('%Y-%m-%d', ${sqliteAuditLogs.timestamp}, 'unixepoch')`).limit(365);
+      const topActorsQuery = db.select({
+        actorId: sqliteAuditLogs.actorId,
+        count: sql4`count(*)`
+      }).from(sqliteAuditLogs).where(and4(sinceCondition, isNotNull2(sqliteAuditLogs.actorId))).groupBy(sqliteAuditLogs.actorId).orderBy(desc4(sql4`count(*)`)).limit(10);
+      const topTablesQuery = db.select({
+        tableName: sqliteAuditLogs.tableName,
+        count: sql4`count(*)`
+      }).from(sqliteAuditLogs).where(sinceCondition).groupBy(sqliteAuditLogs.tableName).orderBy(desc4(sql4`count(*)`)).limit(10);
+      const operationQuery = db.select({
+        operation: sqliteAuditLogs.operation,
+        count: sql4`count(*)`
+      }).from(sqliteAuditLogs).where(sinceCondition).groupBy(sqliteAuditLogs.operation);
+      const severityQuery = db.select({
+        severity: sqliteAuditLogs.severity,
+        count: sql4`count(*)`
+      }).from(sqliteAuditLogs).where(and4(sinceCondition, isNotNull2(sqliteAuditLogs.severity))).groupBy(sqliteAuditLogs.severity);
+      const results = await Promise.all([
+        summaryQuery,
+        eventsPerDayQuery,
+        topActorsQuery,
+        topTablesQuery,
+        operationQuery,
+        severityQuery
+      ]);
+      const [
+        summaryRows,
+        eventsPerDayRows,
+        topActorsRows,
+        topTablesRows,
+        operationRows,
+        severityRows
+      ] = results;
+      return assembleStats2(
+        summaryRows,
+        eventsPerDayRows,
+        topActorsRows,
+        topTablesRows,
+        operationRows,
+        severityRows
+      );
+    }
+  };
+}
+function assembleStats2(summaryRows, eventsPerDayRows, topActorsRows, topTablesRows, operationRows, severityRows) {
+  const summary = summaryRows[0];
+  const totalLogs = summary !== void 0 ? toCount2(summary.totalLogs) : 0;
+  const tablesAudited = summary !== void 0 ? toCount2(summary.tablesAudited) : 0;
+  const eventsPerDay = eventsPerDayRows.map((row) => ({
+    date: String(row.date),
+    count: toCount2(row.count)
+  }));
+  const topActors = topActorsRows.map((row) => ({
+    actorId: String(row.actorId),
+    count: toCount2(row.count)
+  }));
+  const topTables = topTablesRows.map((row) => ({
+    tableName: String(row.tableName),
+    count: toCount2(row.count)
+  }));
+  const operationBreakdown = {};
+  for (const row of operationRows) {
+    operationBreakdown[String(row.operation)] = toCount2(row.count);
+  }
+  const severityBreakdown = {};
+  for (const row of severityRows) {
+    severityBreakdown[String(row.severity)] = toCount2(row.count);
+  }
+  return {
+    totalLogs,
+    tablesAudited,
+    eventsPerDay,
+    topActors,
+    topTables,
+    operationBreakdown,
+    severityBreakdown
+  };
+}
+
 // src/proxy.ts
 import { getTableName } from "drizzle-orm";
 
@@ -952,7 +1401,9 @@ export {
   buildWhereConditions,
   decodeCursor,
   drizzleAuditAdapter,
+  drizzleSqliteAuditAdapter,
   encodeCursor,
+  sqliteAuditLogs,
   withAuditProxy
 };
 //# sourceMappingURL=index.js.map