@usebetterdev/audit-drizzle 0.6.1 → 0.8.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/adapter.ts
+import { encodeCursor, assembleStats } from "@usebetterdev/audit-core";
 import { and as and2, eq as eq2, gte as gte2, lt as lt2, isNotNull, sql as sql2, desc as desc2 } from "drizzle-orm";
 
 // src/schema.ts
@@ -50,23 +51,7 @@ var auditLogs = pgTable(
 );
 
 // src/column-map.ts
-var VALID_OPERATIONS = /* @__PURE__ */ new Set([
-  "INSERT",
-  "UPDATE",
-  "DELETE"
-]);
-var VALID_SEVERITIES = /* @__PURE__ */ new Set([
-  "low",
-  "medium",
-  "high",
-  "critical"
-]);
-function isAuditOperation(value) {
-  return VALID_OPERATIONS.has(value);
-}
-function isAuditSeverity(value) {
-  return VALID_SEVERITIES.has(value);
-}
+import { isAuditOperation, isAuditSeverity } from "@usebetterdev/audit-core";
 function auditLogToRow(log) {
   const row = {
     id: log.id,
@@ -171,7 +156,10 @@ function rowToAuditLog(row) {
 }
 
 // src/query.ts
-import { parseDuration } from "@usebetterdev/audit-core";
+import {
+  decodeCursor,
+  interpretFilters
+} from "@usebetterdev/audit-core";
 import {
   and,
   or,
@@ -186,85 +174,66 @@ import {
   desc,
   sql
 } from "drizzle-orm";
-function escapeLikePattern(input) {
-  return input.replace(/[%_\\]/g, "\\$&");
-}
-function resolveTimeFilter(filter) {
-  if ("date" in filter && filter.date !== void 0) {
-    return filter.date;
-  }
-  if ("duration" in filter && filter.duration !== void 0) {
-    return parseDuration(filter.duration);
-  }
-  throw new Error("TimeFilter must have either date or duration");
-}
-function buildWhereConditions(filters) {
-  const conditions = [];
-  if (filters.resource !== void 0) {
-    conditions.push(eq(auditLogs.tableName, filters.resource.tableName));
-    if (filters.resource.recordId !== void 0) {
-      conditions.push(eq(auditLogs.recordId, filters.resource.recordId));
+var FIELD_COLUMNS = {
+  tableName: auditLogs.tableName,
+  recordId: auditLogs.recordId,
+  actorId: auditLogs.actorId,
+  severity: auditLogs.severity,
+  operation: auditLogs.operation
+};
+function mapCondition(condition) {
+  switch (condition.kind) {
+    case "eq": {
+      return eq(FIELD_COLUMNS[condition.field], condition.value);
     }
-  }
-  if (filters.actorIds !== void 0 && filters.actorIds.length > 0) {
-    if (filters.actorIds.length === 1) {
-      conditions.push(eq(auditLogs.actorId, filters.actorIds[0]));
-    } else {
-      conditions.push(inArray(auditLogs.actorId, filters.actorIds));
+    case "in": {
+      return inArray(FIELD_COLUMNS[condition.field], condition.values);
     }
-  }
-  if (filters.severities !== void 0 && filters.severities.length > 0) {
-    if (filters.severities.length === 1) {
-      conditions.push(eq(auditLogs.severity, filters.severities[0]));
-    } else {
-      conditions.push(inArray(auditLogs.severity, filters.severities));
+    case "timestampGte": {
+      return gte(auditLogs.timestamp, condition.value);
     }
-  }
-  if (filters.operations !== void 0 && filters.operations.length > 0) {
-    if (filters.operations.length === 1) {
-      conditions.push(eq(auditLogs.operation, filters.operations[0]));
-    } else {
-      conditions.push(inArray(auditLogs.operation, filters.operations));
+    case "timestampLte": {
+      return lte(auditLogs.timestamp, condition.value);
     }
-  }
-  if (filters.since !== void 0) {
-    conditions.push(gte(auditLogs.timestamp, resolveTimeFilter(filters.since)));
-  }
-  if (filters.until !== void 0) {
-    conditions.push(lte(auditLogs.timestamp, resolveTimeFilter(filters.until)));
-  }
-  if (filters.searchText !== void 0 && filters.searchText.length > 0) {
-    const escaped = escapeLikePattern(filters.searchText);
-    const pattern = `%${escaped}%`;
-    const searchCondition = or(
-      ilike(auditLogs.label, pattern),
-      ilike(auditLogs.description, pattern)
-    );
-    if (searchCondition !== void 0) {
-      conditions.push(searchCondition);
+    case "search": {
+      return or(
+        ilike(auditLogs.label, condition.pattern),
+        ilike(auditLogs.description, condition.pattern)
+      );
+    }
+    case "compliance": {
+      return sql`${auditLogs.compliance} @> ${JSON.stringify(condition.tags)}::jsonb`;
+    }
+    case "cursor": {
+      const tsCompare = condition.sortOrder === "asc" ? gt : lt;
+      const idCompare = condition.sortOrder === "asc" ? gt : lt;
+      return or(
+        tsCompare(auditLogs.timestamp, condition.timestamp),
+        and(
+          eq(auditLogs.timestamp, condition.timestamp),
+          idCompare(auditLogs.id, condition.id)
+        )
+      );
     }
   }
-  if (filters.compliance !== void 0 && filters.compliance.length > 0) {
-    conditions.push(
-      sql`${auditLogs.compliance} @> ${JSON.stringify(filters.compliance)}::jsonb`
-    );
+}
+function buildWhereConditions(filters, cursor, sortOrder) {
+  const decoded = cursor !== void 0 ? decodeCursor(cursor) : void 0;
+  const irConditions = interpretFilters(filters, {
+    cursor: decoded,
+    sortOrder
+  });
+  const sqlConditions = [];
+  for (const c of irConditions) {
+    const mapped = mapCondition(c);
+    if (mapped !== void 0) {
+      sqlConditions.push(mapped);
+    }
   }
-  if (conditions.length === 0) {
+  if (sqlConditions.length === 0) {
     return void 0;
   }
-  return and(...conditions);
-}
-function buildCursorCondition(cursor, sortOrder) {
-  const decoded = decodeCursor(cursor);
-  const tsCompare = sortOrder === "asc" ? gt : lt;
-  const idCompare = sortOrder === "asc" ? gt : lt;
-  return or(
-    tsCompare(auditLogs.timestamp, decoded.timestamp),
-    and(
-      eq(auditLogs.timestamp, decoded.timestamp),
-      idCompare(auditLogs.id, decoded.id)
-    )
-  );
+  return and(...sqlConditions);
 }
 function buildOrderBy(sortOrder) {
   if (sortOrder === "asc") {
@@ -272,47 +241,10 @@ function buildOrderBy(sortOrder) {
   }
   return [desc(auditLogs.timestamp), desc(auditLogs.id)];
 }
-function encodeCursor(timestamp2, id) {
-  const payload = JSON.stringify({ t: timestamp2.toISOString(), i: id });
-  return btoa(payload);
-}
-var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function decodeCursor(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_PATTERN.test(i)) {
-    throw new Error("Invalid cursor: id must be a valid UUID");
-  }
-  return { timestamp: timestamp2, id: i };
-}
 
 // src/adapter.ts
 var DEFAULT_LIMIT = 50;
 var MAX_LIMIT = 250;
-function toCount(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string") {
-    return Number(value);
-  }
-  return 0;
-}
 function drizzleAuditAdapter(db) {
   return {
     async writeLog(log) {
@@ -322,9 +254,7 @@ function drizzleAuditAdapter(db) {
     async queryLogs(spec) {
       const sortOrder = spec.sortOrder ?? "desc";
       const limit = Math.min(spec.limit ?? DEFAULT_LIMIT, MAX_LIMIT);
-      const whereCondition = buildWhereConditions(spec.filters);
-      const cursorCondition = spec.cursor !== void 0 ? buildCursorCondition(spec.cursor, sortOrder) : void 0;
-      const combined = and2(whereCondition, cursorCondition);
+      const combined = buildWhereConditions(spec.filters, spec.cursor, sortOrder);
       const fetchLimit = limit + 1;
       const orderColumns = buildOrderBy(sortOrder);
       const query = db.select().from(auditLogs).where(combined).orderBy(...orderColumns).limit(fetchLimit);
@@ -368,30 +298,32 @@ function drizzleAuditAdapter(db) {
     },
     async getStats(options) {
       const sinceCondition = options?.since !== void 0 ? gte2(auditLogs.timestamp, options.since) : void 0;
+      const untilCondition = options?.until !== void 0 ? lt2(auditLogs.timestamp, options.until) : void 0;
+      const timeCondition = and2(sinceCondition, untilCondition);
       const summaryQuery = db.select({
         totalLogs: sql2`count(*)`,
         tablesAudited: sql2`count(DISTINCT ${auditLogs.tableName})`
-      }).from(auditLogs).where(sinceCondition);
+      }).from(auditLogs).where(timeCondition);
       const eventsPerDayQuery = db.select({
         date: sql2`date_trunc('day', ${auditLogs.timestamp})::date`,
         count: sql2`count(*)`
-      }).from(auditLogs).where(sinceCondition).groupBy(sql2`date_trunc('day', ${auditLogs.timestamp})`).orderBy(sql2`date_trunc('day', ${auditLogs.timestamp})`).limit(365);
+      }).from(auditLogs).where(timeCondition).groupBy(sql2`date_trunc('day', ${auditLogs.timestamp})`).orderBy(sql2`date_trunc('day', ${auditLogs.timestamp})`).limit(365);
       const topActorsQuery = db.select({
         actorId: auditLogs.actorId,
         count: sql2`count(*)`
-      }).from(auditLogs).where(and2(sinceCondition, isNotNull(auditLogs.actorId))).groupBy(auditLogs.actorId).orderBy(desc2(sql2`count(*)`)).limit(10);
+      }).from(auditLogs).where(and2(timeCondition, isNotNull(auditLogs.actorId))).groupBy(auditLogs.actorId).orderBy(desc2(sql2`count(*)`)).limit(10);
       const topTablesQuery = db.select({
         tableName: auditLogs.tableName,
         count: sql2`count(*)`
-      }).from(auditLogs).where(sinceCondition).groupBy(auditLogs.tableName).orderBy(desc2(sql2`count(*)`)).limit(10);
+      }).from(auditLogs).where(timeCondition).groupBy(auditLogs.tableName).orderBy(desc2(sql2`count(*)`)).limit(10);
       const operationQuery = db.select({
         operation: auditLogs.operation,
         count: sql2`count(*)`
-      }).from(auditLogs).where(sinceCondition).groupBy(auditLogs.operation);
+      }).from(auditLogs).where(timeCondition).groupBy(auditLogs.operation);
       const severityQuery = db.select({
         severity: auditLogs.severity,
         count: sql2`count(*)`
-      }).from(auditLogs).where(and2(sinceCondition, isNotNull(auditLogs.severity))).groupBy(auditLogs.severity);
+      }).from(auditLogs).where(and2(timeCondition, isNotNull(auditLogs.severity))).groupBy(auditLogs.severity);
       const results = await Promise.all([
         summaryQuery,
         eventsPerDayQuery,
@@ -419,42 +351,9 @@ function drizzleAuditAdapter(db) {
     }
   };
 }
-function assembleStats(summaryRows, eventsPerDayRows, topActorsRows, topTablesRows, operationRows, severityRows) {
-  const summary = summaryRows[0];
-  const totalLogs = summary !== void 0 ? toCount(summary.totalLogs) : 0;
-  const tablesAudited = summary !== void 0 ? toCount(summary.tablesAudited) : 0;
-  const eventsPerDay = eventsPerDayRows.map((row) => ({
-    date: row.date instanceof Date ? row.date.toISOString().split("T")[0] : String(row.date),
-    count: toCount(row.count)
-  }));
-  const topActors = topActorsRows.map((row) => ({
-    actorId: String(row.actorId),
-    count: toCount(row.count)
-  }));
-  const topTables = topTablesRows.map((row) => ({
-    tableName: String(row.tableName),
-    count: toCount(row.count)
-  }));
-  const operationBreakdown = {};
-  for (const row of operationRows) {
-    operationBreakdown[String(row.operation)] = toCount(row.count);
-  }
-  const severityBreakdown = {};
-  for (const row of severityRows) {
-    severityBreakdown[String(row.severity)] = toCount(row.count);
-  }
-  return {
-    totalLogs,
-    tablesAudited,
-    eventsPerDay,
-    topActors,
-    topTables,
-    operationBreakdown,
-    severityBreakdown
-  };
-}
 
 // src/sqlite-adapter.ts
+import { encodeCursor as encodeCursor2, toCount, assembleStats as assembleStats2 } from "@usebetterdev/audit-core";
 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
@@ -503,23 +402,7 @@ var sqliteAuditLogs = sqliteTable(
 );
 
 // 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);
-}
+import { isAuditOperation as isAuditOperation2, isAuditSeverity as isAuditSeverity2 } from "@usebetterdev/audit-core";
 function sqliteAuditLogToRow(log) {
   const row = {
     id: log.id,
@@ -624,7 +507,10 @@ function sqliteRowToAuditLog(row) {
 }
 
 // src/sqlite-query.ts
-import { parseDuration as parseDuration2 } from "@usebetterdev/audit-core";
+import {
+  decodeCursor as decodeCursor2,
+  interpretFilters as interpretFilters2
+} from "@usebetterdev/audit-core";
 import {
   and as and3,
   or as or2,
@@ -639,87 +525,72 @@ import {
   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));
+var FIELD_COLUMNS2 = {
+  tableName: sqliteAuditLogs.tableName,
+  recordId: sqliteAuditLogs.recordId,
+  actorId: sqliteAuditLogs.actorId,
+  severity: sqliteAuditLogs.severity,
+  operation: sqliteAuditLogs.operation
+};
+function mapCondition2(condition) {
+  switch (condition.kind) {
+    case "eq": {
+      return eq3(FIELD_COLUMNS2[condition.field], condition.value);
     }
-  }
-  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));
+    case "in": {
+      return inArray2(FIELD_COLUMNS2[condition.field], condition.values);
     }
-  }
-  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));
+    case "timestampGte": {
+      return gte3(sqliteAuditLogs.timestamp, condition.value);
     }
-  }
-  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));
+    case "timestampLte": {
+      return lte2(sqliteAuditLogs.timestamp, condition.value);
     }
-  }
-  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);
+    case "search": {
+      return or2(
+        like(sqliteAuditLogs.label, condition.pattern),
+        like(sqliteAuditLogs.description, condition.pattern)
+      );
     }
-  }
-  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})`
+    case "compliance": {
+      const tagConditions = [];
+      for (const tag of condition.tags) {
+        tagConditions.push(
+          sql3`EXISTS (SELECT 1 FROM json_each(${sqliteAuditLogs.compliance}) WHERE value = ${tag})`
+        );
+      }
+      return and3(...tagConditions);
+    }
+    case "cursor": {
+      const tsCompare = condition.sortOrder === "asc" ? gt2 : lt3;
+      const idCompare = condition.sortOrder === "asc" ? gt2 : lt3;
+      return or2(
+        tsCompare(sqliteAuditLogs.timestamp, condition.timestamp),
+        and3(
+          eq3(sqliteAuditLogs.timestamp, condition.timestamp),
+          idCompare(sqliteAuditLogs.id, condition.id)
+        )
       );
     }
   }
-  if (conditions.length === 0) {
+}
+function buildSqliteWhereConditions(filters, cursor, sortOrder) {
+  const decoded = cursor !== void 0 ? decodeCursor2(cursor) : void 0;
+  const irConditions = interpretFilters2(filters, {
+    cursor: decoded,
+    sortOrder
+  });
+  const sqlConditions = [];
+  for (const c of irConditions) {
+    const mapped = mapCondition2(c);
+    if (mapped !== void 0) {
+      sqlConditions.push(mapped);
+    }
+  }
+  if (sqlConditions.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)
-    )
-  );
+  return and3(...sqlConditions);
 }
 function buildSqliteOrderBy(sortOrder) {
   if (sortOrder === "asc") {
@@ -727,47 +598,10 @@ function buildSqliteOrderBy(sortOrder) {
   }
   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) {
@@ -777,9 +611,7 @@ function drizzleSqliteAuditAdapter(db) {
     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 combined = buildSqliteWhereConditions(spec.filters, spec.cursor, sortOrder);
       const fetchLimit = limit + 1;
       const orderColumns = buildSqliteOrderBy(sortOrder);
       const query = db.select().from(sqliteAuditLogs).where(combined).orderBy(...orderColumns).limit(fetchLimit);
@@ -789,7 +621,7 @@ function drizzleSqliteAuditAdapter(db) {
       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, nextCursor: encodeCursor2(lastRow.timestamp, lastRow.id) };
       }
       return { entries };
     },
@@ -812,35 +644,37 @@ function drizzleSqliteAuditAdapter(db) {
       }
       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;
+      const deletedCount = changesResult[0] !== void 0 ? toCount(changesResult[0].count) : 0;
       return { deletedCount };
     },
     async getStats(options) {
       const sinceCondition = options?.since !== void 0 ? gte4(sqliteAuditLogs.timestamp, options.since) : void 0;
+      const untilCondition = options?.until !== void 0 ? lt4(sqliteAuditLogs.timestamp, options.until) : void 0;
+      const timeCondition = and4(sinceCondition, untilCondition);
       const summaryQuery = db.select({
         totalLogs: sql4`count(*)`,
         tablesAudited: sql4`count(DISTINCT ${sqliteAuditLogs.tableName})`
-      }).from(sqliteAuditLogs).where(sinceCondition);
+      }).from(sqliteAuditLogs).where(timeCondition);
       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);
+      }).from(sqliteAuditLogs).where(timeCondition).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);
+      }).from(sqliteAuditLogs).where(and4(timeCondition, 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);
+      }).from(sqliteAuditLogs).where(timeCondition).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);
+      }).from(sqliteAuditLogs).where(timeCondition).groupBy(sqliteAuditLogs.operation);
       const severityQuery = db.select({
         severity: sqliteAuditLogs.severity,
         count: sql4`count(*)`
-      }).from(sqliteAuditLogs).where(and4(sinceCondition, isNotNull2(sqliteAuditLogs.severity))).groupBy(sqliteAuditLogs.severity);
+      }).from(sqliteAuditLogs).where(and4(timeCondition, isNotNull2(sqliteAuditLogs.severity))).groupBy(sqliteAuditLogs.severity);
       const results = await Promise.all([
         summaryQuery,
         eventsPerDayQuery,
@@ -868,40 +702,6 @@ function drizzleSqliteAuditAdapter(db) {
     }
   };
 }
-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";
@@ -1394,15 +1194,17 @@ async function fireCaptureLog(result, ctx, state) {
     }
   }
 }
+
+// src/index.ts
+import { encodeCursor as encodeCursor3, decodeCursor as decodeCursor3 } from "@usebetterdev/audit-core";
 export {
   auditLogs,
-  buildCursorCondition,
   buildOrderBy,
   buildWhereConditions,
-  decodeCursor,
+  decodeCursor3 as decodeCursor,
   drizzleAuditAdapter,
   drizzleSqliteAuditAdapter,
-  encodeCursor,
+  encodeCursor3 as encodeCursor,
   sqliteAuditLogs,
   withAuditProxy
 };