better-auth-studio 1.1.3-beta.9 → 1.1.3

package/dist/providers/events/helpers.js

@@ -1,3 +1,37 @@
+function isKyselyClient(client, clientType) {
+    const hasExecuteQuery = typeof client?.executeQuery === "function";
+    if (clientType === "kysely") {
+        return hasExecuteQuery;
+    }
+    return hasExecuteQuery && typeof client?.selectFrom === "function";
+}
+function createKyselyCompiledQuery(sql, parameters = []) {
+    return {
+        sql,
+        parameters,
+        queryId: { queryId: `bas_${Date.now()}_${Math.random().toString(36).slice(2)}` },
+    };
+}
+async function executeKyselyQuery(client, query, params = []) {
+    return await client.executeQuery(createKyselyCompiledQuery(query, params));
+}
+function getEventInsertParams(event) {
+    return [
+        event.id,
+        event.type,
+        event.timestamp,
+        event.status || "success",
+        event.userId || null,
+        event.sessionId || null,
+        event.organizationId || null,
+        JSON.stringify(event.metadata || {}),
+        event.ipAddress || null,
+        event.userAgent || null,
+        event.source,
+        event.display?.message || null,
+        event.display?.severity || null,
+    ];
+}
 export function createPostgresProvider(options) {
     const { client, tableName = "auth_events", schema = "public", clientType } = options;
     // Validate client is provided
@@ -18,12 +52,15 @@ export function createPostgresProvider(options) {
     const hasExecuteRaw = client?.$executeRaw;
     const hasExecute = client?.execute;
     const hasUnsafe = actualClient?.unsafe || client?.$client?.unsafe || client?.unsafe;
-    if (!hasQuery && !hasExecuteRaw && !hasExecute && !hasUnsafe) {
+    const hasKysely = isKyselyClient(client, clientType);
+    if (!hasQuery && !hasExecuteRaw && !hasExecute && !hasUnsafe && !hasKysely) {
         const errorMessage = clientType === "prisma"
             ? "Invalid Prisma client. Client must have a `$executeRaw` method."
             : clientType === "drizzle"
                 ? "Invalid Drizzle client. Drizzle instance must wrap a postgres-js (with `unsafe` method) or pg (with `query` method) client."
-                : "Invalid Postgres client. Client must have either a `query` method (pg Pool/Client) or `$executeRaw` method (Prisma client).";
+                : clientType === "kysely"
+                    ? "Invalid Kysely client. Client must have an `executeQuery` method."
+                    : "Invalid Postgres client. Client must have either a `query` method (pg Pool/Client), `$executeRaw` method (Prisma client), or `executeQuery` method (Kysely client).";
         throw new Error(errorMessage);
     }
     // Ensure table exists
@@ -39,6 +76,11 @@ export function createPostgresProvider(options) {
                     return await client.$executeRawUnsafe(query);
                 };
             }
+            else if (hasKysely) {
+                executeQuery = async (query) => {
+                    return await executeKyselyQuery(client, query);
+                };
+            }
             else if (clientType === "drizzle") {
                 // Drizzle client - use $client which exposes the underlying client
                 if (actualClient?.unsafe) {
@@ -69,7 +111,7 @@ export function createPostgresProvider(options) {
                 };
             }
             else {
-                throw new Error(`Postgres client doesn't support $executeRaw or query method. Available properties: ${Object.keys(client).join(", ")}`);
+                throw new Error(`Postgres client doesn't support $executeRaw, executeQuery, or query method. Available properties: ${Object.keys(client).join(", ")}`);
             }
             // Use CREATE TABLE IF NOT EXISTS (simpler and more reliable)
             const createTableQuery = `
@@ -141,7 +183,32 @@ export function createPostgresProvider(options) {
     return {
         async ingest(event) {
             await ensureTableSync();
-            if (clientType === "prisma" || client.$executeRaw) {
+            if (hasKysely) {
+                try {
+                    await executeKyselyQuery(client, `INSERT INTO ${schema}.${tableName}
+             (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, getEventInsertParams(event));
+                }
+                catch (error) {
+                    console.error(`Failed to insert event (${event.type}) into ${schema}.${tableName}:`, error);
+                    if (error.code === "42P01") {
+                        tableEnsured = false;
+                        await ensureTableSync();
+                        try {
+                            await executeKyselyQuery(client, `INSERT INTO ${schema}.${tableName}
+                 (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
+                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, getEventInsertParams(event));
+                            return;
+                        }
+                        catch (retryError) {
+                            console.error(`Retry after table creation also failed:`, retryError);
+                            throw retryError;
+                        }
+                    }
+                    throw error;
+                }
+            }
+            else if (clientType === "prisma" || client.$executeRaw) {
                 const query = `
           INSERT INTO ${schema}.${tableName} 
           (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
@@ -176,7 +243,7 @@ export function createPostgresProvider(options) {
                 if (useUnsafe) {
                     // postgres-js client - use unsafe() for raw SQL
                     const query = `
-            INSERT INTO ${schema}.${tableName} 
+            INSERT INTO ${schema}.${tableName}
             (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
             VALUES ('${event.id}'::uuid, '${event.type}', '${event.timestamp.toISOString()}', '${event.status || "success"}', ${event.userId ? `'${event.userId.replace(/'/g, "''")}'` : "NULL"}, ${event.sessionId ? `'${event.sessionId.replace(/'/g, "''")}'` : "NULL"}, ${event.organizationId ? `'${event.organizationId.replace(/'/g, "''")}'` : "NULL"}, '${JSON.stringify(event.metadata || {}).replace(/'/g, "''")}'::jsonb, ${event.ipAddress ? `'${event.ipAddress.replace(/'/g, "''")}'` : "NULL"}, ${event.userAgent ? `'${event.userAgent.replace(/'/g, "''")}'` : "NULL"}, '${event.source}', ${event.display?.message ? `'${event.display.message.replace(/'/g, "''")}'` : "NULL"}, ${event.display?.severity ? `'${event.display.severity}'` : "NULL"})
           `;
@@ -205,21 +272,7 @@ export function createPostgresProvider(options) {
                     try {
                         await queryClient.query(`INSERT INTO ${schema}.${tableName} 
                (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
-               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [
-                            event.id,
-                            event.type,
-                            event.timestamp,
-                            event.status || "success",
-                            event.userId || null,
-                            event.sessionId || null,
-                            event.organizationId || null,
-                            JSON.stringify(event.metadata || {}),
-                            event.ipAddress || null,
-                            event.userAgent || null,
-                            event.source,
-                            event.display?.message || null,
-                            event.display?.severity || null,
-                        ]);
+               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [...getEventInsertParams(event)]);
                     }
                     catch (error) {
                         console.error(`Failed to insert event (${event.type}) into ${schema}.${tableName}:`, error);
@@ -229,21 +282,7 @@ export function createPostgresProvider(options) {
                             try {
                                 await queryClient.query(`INSERT INTO ${schema}.${tableName} 
                    (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
-                   VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [
-                                    event.id,
-                                    event.type,
-                                    event.timestamp,
-                                    event.status || "success",
-                                    event.userId || null,
-                                    event.sessionId || null,
-                                    event.organizationId || null,
-                                    JSON.stringify(event.metadata || {}),
-                                    event.ipAddress || null,
-                                    event.userAgent || null,
-                                    event.source,
-                                    event.display?.message || null,
-                                    event.display?.severity || null,
-                                ]);
+                   VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`, [...getEventInsertParams(event)]);
                                 return;
                             }
                             catch (retryError) {
@@ -271,7 +310,34 @@ export function createPostgresProvider(options) {
                 return;
             await ensureTableSync();
             // Support Prisma client ($executeRaw), Drizzle instance, or standard pg client (query)
-            if (clientType === "prisma" || client.$executeRaw) {
+            if (hasKysely) {
+                const PARAMS_PER_EVENT = 13;
+                const MAX_PARAMS = 65535;
+                const CHUNK_SIZE = Math.floor(MAX_PARAMS / PARAMS_PER_EVENT) - 1;
+                for (let chunkStart = 0; chunkStart < events.length; chunkStart += CHUNK_SIZE) {
+                    const chunk = events.slice(chunkStart, chunkStart + CHUNK_SIZE);
+                    const values = chunk
+                        .map((_, i) => {
+                        const base = i * PARAMS_PER_EVENT;
+                        return `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}, $${base + 5}, $${base + 6}, $${base + 7}, $${base + 8}, $${base + 9}, $${base + 10}, $${base + 11}, $${base + 12}, $${base + 13})`;
+                    })
+                        .join(", ");
+                    const query = `
+            INSERT INTO ${schema}.${tableName}
+            (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
+            VALUES ${values}
+          `;
+                    const params = chunk.flatMap((event) => getEventInsertParams(event));
+                    try {
+                        await executeKyselyQuery(client, query, params);
+                    }
+                    catch (error) {
+                        console.error(`Failed to insert batch chunk (${chunk.length} events) into ${schema}.${tableName}:`, error);
+                        throw error;
+                    }
+                }
+            }
+            else if (clientType === "prisma" || client.$executeRaw) {
                 // Prisma client - use $executeRawUnsafe for batch inserts
                 const CHUNK_SIZE = 500; // Reasonable chunk size for string-based queries
                 for (let i = 0; i < events.length; i += CHUNK_SIZE) {
@@ -339,21 +405,7 @@ export function createPostgresProvider(options) {
               (id, type, timestamp, status, user_id, session_id, organization_id, metadata, ip_address, user_agent, source, display_message, display_severity)
               VALUES ${values}
             `;
-                        const params = chunk.flatMap((event) => [
-                            event.id,
-                            event.type,
-                            event.timestamp,
-                            event.status || "success",
-                            event.userId || null,
-                            event.sessionId || null,
-                            event.organizationId || null,
-                            JSON.stringify(event.metadata || {}),
-                            event.ipAddress || null,
-                            event.userAgent || null,
-                            event.source,
-                            event.display?.message || null,
-                            event.display?.severity || null,
-                        ]);
+                        const params = chunk.flatMap((event) => getEventInsertParams(event));
                         try {
                             await batchQueryClient.query(query, params);
                         }
@@ -376,7 +428,7 @@ export function createPostgresProvider(options) {
             }
         },
         async query(options) {
-            const { limit = 20, after, sort = "desc", type, userId, since } = options;
+            const { limit = 20, offset, after, sort = "desc", type, userId, since } = options;
             let queryFn;
             if (client.$executeRaw) {
                 // Prisma client
@@ -401,6 +453,11 @@ export function createPostgresProvider(options) {
                     }
                 };
             }
+            else if (hasKysely) {
+                queryFn = async (query, params) => {
+                    return await executeKyselyQuery(client, query, params || []);
+                };
+            }
             else if (client.query) {
                 // Standard pg client (Pool or Client)
                 queryFn = async (query, params) => {
@@ -427,6 +484,9 @@ export function createPostgresProvider(options) {
                         .replace("$2", `'${tableName}'`);
                     checkResult = await client.$queryRawUnsafe(prismaQuery);
                 }
+                else if (hasKysely) {
+                    checkResult = await queryFn(checkTableQuery, [schema, tableName]);
+                }
                 else {
                     // Standard pg client
                     checkResult = await queryFn(checkTableQuery, [schema, tableName]);
@@ -448,8 +508,8 @@ export function createPostgresProvider(options) {
             const whereClauses = [];
             const params = [];
             let paramIndex = 1;
-            // Cursor-based pagination
-            if (after) {
+            // Use cursor-based pagination only when offset is not provided
+            if (offset == null && after) {
                 if (sort === "desc") {
                     whereClauses.push(`id < $${paramIndex++}`);
                     params.push(after);
@@ -473,15 +533,29 @@ export function createPostgresProvider(options) {
             }
             const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
             const orderDirection = sort === "desc" ? "DESC" : "ASC";
-            const query = `
-        SELECT id, type, timestamp, status, user_id, session_id, organization_id, 
-               metadata, ip_address, user_agent, source, display_message, display_severity
-        FROM ${schema}.${tableName}
-        ${whereClause}
-        ORDER BY timestamp ${orderDirection}, id ${orderDirection}
-        LIMIT $${paramIndex++}
-      `;
-            params.push(limit + 1); // Get one extra to check hasMore
+            let query;
+            if (offset != null && offset > 0) {
+                query = `
+          SELECT id, type, timestamp, status, user_id, session_id, organization_id, 
+                 metadata, ip_address, user_agent, source, display_message, display_severity
+          FROM ${schema}.${tableName}
+          ${whereClause}
+          ORDER BY timestamp ${orderDirection}, id ${orderDirection}
+          LIMIT $${paramIndex++} OFFSET $${paramIndex++}
+        `;
+                params.push(limit + 1, offset);
+            }
+            else {
+                query = `
+          SELECT id, type, timestamp, status, user_id, session_id, organization_id, 
+                 metadata, ip_address, user_agent, source, display_message, display_severity
+          FROM ${schema}.${tableName}
+          ${whereClause}
+          ORDER BY timestamp ${orderDirection}, id ${orderDirection}
+          LIMIT $${paramIndex++}
+        `;
+                params.push(limit + 1);
+            }
             try {
                 const result = await queryFn(query, params);
                 const rows = result.rows || result || [];
@@ -698,7 +772,7 @@ export function createSqliteProvider(options) {
             }
         },
         async query(options) {
-            const { limit = 20, after, sort = "desc", type, userId, since } = options;
+            const { limit = 20, offset, after, sort = "desc", type, userId, since } = options;
             await ensureTableSync();
             try {
                 let query = `SELECT * FROM ${tableName} WHERE 1=1`;
@@ -715,13 +789,20 @@ export function createSqliteProvider(options) {
                     query += ` AND timestamp >= ?`;
                     params.push(since instanceof Date ? since.toISOString() : since);
                 }
-                if (after) {
-                    query += sort === "desc" ? ` AND id < ?` : ` AND id > ?`;
-                    params.push(after);
+                if (offset != null && offset > 0) {
+                    query += ` ORDER BY timestamp ${sort === "desc" ? "DESC" : "ASC"}`;
+                    query += ` LIMIT ? OFFSET ?`;
+                    params.push(limit + 1, offset);
+                }
+                else {
+                    if (after) {
+                        query += sort === "desc" ? ` AND id < ?` : ` AND id > ?`;
+                        params.push(after);
+                    }
+                    query += ` ORDER BY timestamp ${sort === "desc" ? "DESC" : "ASC"}`;
+                    query += ` LIMIT ?`;
+                    params.push(limit + 1);
                 }
-                query += ` ORDER BY timestamp ${sort === "desc" ? "DESC" : "ASC"}`;
-                query += ` LIMIT ?`;
-                params.push(limit + 1); // Fetch one extra to check if there are more
                 const stmt = actualClient.prepare(query);
                 const rows = stmt.all(...params);
                 const hasMore = rows.length > limit;
@@ -1154,7 +1235,7 @@ export function createClickHouseProvider(options) {
             await ingestBatchFn(events);
         },
         async query(options) {
-            const { limit = 20, after, sort = "desc", type, userId, since } = options;
+            const { limit = 20, offset, after, sort = "desc", type, userId, since } = options;
             const tableFullName = database ? `${database}.${table}` : table;
             try {
                 const checkTableQuery = `EXISTS TABLE ${tableFullName}`;
@@ -1269,7 +1350,7 @@ export function createClickHouseProvider(options) {
                 }
             }
             const whereClauses = [];
-            if (after) {
+            if (offset == null && after) {
                 if (sort === "desc") {
                     whereClauses.push(`id < '${String(after).replace(/'/g, "''")}'`);
                 }
@@ -1285,13 +1366,12 @@ export function createClickHouseProvider(options) {
             }
             if (since) {
                 const sinceDate = since instanceof Date ? since : new Date(since);
-                // ClickHouse requires DateTime type, so we need to cast the string to DateTime
-                // Format: 'YYYY-MM-DD HH:MM:SS' or use toDateTime() function
                 const isoString = sinceDate.toISOString().replace("T", " ").slice(0, 19);
                 whereClauses.push(`timestamp >= toDateTime('${isoString.replace(/'/g, "''")}')`);
             }
             const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
             const orderDirection = sort === "desc" ? "DESC" : "ASC";
+            const offsetClause = offset != null && offset > 0 ? `OFFSET ${offset}` : "";
             let query = `
         SELECT id, type, timestamp, status, user_id, session_id, organization_id, 
                metadata, ip_address, user_agent, source, display_message, display_severity
@@ -1299,6 +1379,7 @@ export function createClickHouseProvider(options) {
         ${whereClause}
         ORDER BY timestamp ${orderDirection}, id ${orderDirection}
         LIMIT ${limit + 1}
+        ${offsetClause}
       `;
             let result;
             let hasStatusColumn = true;
@@ -1412,6 +1493,132 @@ export function createStorageProvider(options) {
     const { adapter, tableName = "auth_events" } = options;
     let tableEnsured = false;
     let tableEnsuringPromise = null;
+    let resolvedModelName = null;
+    const isMissingModelError = (error) => error?.message?.includes("not found in schema") ||
+        error?.message?.includes("not found in model") ||
+        error?.message?.includes("Model") ||
+        error?.code === "P2025" ||
+        error?.code === "42P01";
+    const toCamelCase = (value) => value.replace(/[_-]([a-z])/g, (_match, char) => char.toUpperCase());
+    const getModelCandidates = () => {
+        const candidates = new Set();
+        const addForms = (value) => {
+            const normalized = value?.trim();
+            if (!normalized)
+                return;
+            const snake = normalized.replace(/-/g, "_");
+            const singularSnake = snake.endsWith("s") ? snake.slice(0, -1) : snake;
+            const pluralSnake = snake.endsWith("s") ? snake : `${snake}s`;
+            const singularCamel = toCamelCase(singularSnake);
+            const pluralCamel = toCamelCase(pluralSnake);
+            [
+                normalized,
+                snake,
+                singularSnake,
+                pluralSnake,
+                singularCamel,
+                pluralCamel,
+                singularCamel.charAt(0).toUpperCase() + singularCamel.slice(1),
+                pluralCamel.charAt(0).toUpperCase() + pluralCamel.slice(1),
+            ].forEach((candidate) => {
+                if (candidate) {
+                    candidates.add(candidate);
+                }
+            });
+        };
+        addForms(tableName);
+        addForms(tableName === "auth_events" ? "auth_event" : "auth_events");
+        return Array.from(candidates);
+    };
+    const withResolvedModel = async (callback) => {
+        const candidates = Array.from(new Set([resolvedModelName, ...getModelCandidates()].filter(Boolean)));
+        let lastLookupError = null;
+        for (const modelName of candidates) {
+            try {
+                const result = await callback(modelName);
+                resolvedModelName = modelName;
+                return result;
+            }
+            catch (error) {
+                if (isMissingModelError(error)) {
+                    lastLookupError = error;
+                    continue;
+                }
+                throw error;
+            }
+        }
+        if (lastLookupError) {
+            throw lastLookupError;
+        }
+        throw new Error(`No event model candidates available for "${tableName}"`);
+    };
+    const getFieldCandidates = (field) => {
+        switch (field) {
+            case "userId":
+                return ["userId", "user_id"];
+            case "sessionId":
+                return ["sessionId", "session_id"];
+            case "organizationId":
+                return ["organizationId", "organization_id"];
+            case "ipAddress":
+                return ["ipAddress", "ip_address"];
+            case "userAgent":
+                return ["userAgent", "user_agent"];
+            case "displayMessage":
+                return ["displayMessage", "display_message"];
+            case "displaySeverity":
+                return ["displaySeverity", "display_severity"];
+            case "createdAt":
+                return ["createdAt", "created_at"];
+            default:
+                return field ? [field] : [];
+        }
+    };
+    const getWhereCandidates = (where) => {
+        if (!Array.isArray(where) || where.length === 0) {
+            return {
+                whereCandidates: [undefined],
+                hasAliasedFields: false,
+            };
+        }
+        let hasAliasedFields = false;
+        let combinations = [[]];
+        for (const clause of where) {
+            const fieldCandidates = getFieldCandidates(clause?.field);
+            if (fieldCandidates.length > 1) {
+                hasAliasedFields = true;
+            }
+            const nextCombinations = fieldCandidates.flatMap((fieldName) => combinations.map((existing) => [...existing, { ...clause, field: fieldName }]));
+            if (nextCombinations.length > 0) {
+                combinations = nextCombinations;
+            }
+        }
+        return {
+            whereCandidates: combinations.length > 0 ? combinations : [where],
+            hasAliasedFields,
+        };
+    };
+    const findManyWithResolvedModel = async (options) => {
+        const { where, ...restOptions } = options;
+        const { whereCandidates, hasAliasedFields } = getWhereCandidates(where);
+        let lastSuccessfulEmptyResult = null;
+        for (let index = 0; index < whereCandidates.length; index += 1) {
+            const result = (await withResolvedModel((modelName) => adapter.findMany({
+                ...restOptions,
+                ...(whereCandidates[index] ? { where: whereCandidates[index] } : {}),
+                model: modelName,
+            })));
+            if (Array.isArray(result) &&
+                result.length === 0 &&
+                hasAliasedFields &&
+                index < whereCandidates.length - 1) {
+                lastSuccessfulEmptyResult = result;
+                continue;
+            }
+            return Array.isArray(result) ? result : [];
+        }
+        return lastSuccessfulEmptyResult ?? [];
+    };
     const ensureTable = async () => {
         if (!adapter)
             return;
@@ -1423,10 +1630,10 @@ export function createStorageProvider(options) {
             try {
                 if (adapter.findMany) {
                     // Try to query the table to see if it exists
-                    await adapter.findMany({
-                        model: tableName,
+                    await withResolvedModel((modelName) => adapter.findMany({
+                        model: modelName,
                         limit: 1,
-                    });
+                    }));
                     tableEnsured = true;
                     return;
                 }
@@ -1496,8 +1703,8 @@ export function createStorageProvider(options) {
     return {
         async ingest(event) {
             if (adapter.create) {
-                await adapter.create({
-                    model: tableName,
+                await withResolvedModel((modelName) => adapter.create({
+                    model: modelName,
                     data: {
                         id: event.id,
                         type: event.type,
@@ -1513,7 +1720,7 @@ export function createStorageProvider(options) {
                         displayMessage: event.display?.message,
                         displaySeverity: event.display?.severity,
                     },
-                });
+                }));
             }
             else if (adapter.insert) {
                 await adapter.insert({
@@ -1540,8 +1747,8 @@ export function createStorageProvider(options) {
             // Ensure table exists before ingesting
             await ensureTable();
             if (adapter.createMany) {
-                await adapter.createMany({
-                    model: tableName,
+                await withResolvedModel((modelName) => adapter.createMany({
+                    model: modelName,
                     data: events.map((event) => ({
                         id: event.id,
                         type: event.type,
@@ -1557,21 +1764,21 @@ export function createStorageProvider(options) {
                         displayMessage: event.display?.message,
                         displaySeverity: event.display?.severity,
                     })),
-                });
+                }));
             }
             else {
                 await Promise.all(events.map((event) => this.ingest(event)));
             }
         },
         async query(options) {
-            const { limit = 20, after, sort = "desc", type, userId, since } = options;
+            const { limit = 20, offset, after, sort = "desc", type, userId, since } = options;
             // Ensure table exists before querying
             await ensureTable();
             // First, try findMany (normal path)
             if (adapter && adapter.findMany) {
                 try {
                     const where = [];
-                    if (after) {
+                    if (offset == null && after) {
                         if (sort === "desc") {
                             where.push({ field: "id", operator: "<", value: after });
                         }
@@ -1589,12 +1796,15 @@ export function createStorageProvider(options) {
                         const sinceDate = since instanceof Date ? since : new Date(since);
                         where.push({ field: "timestamp", operator: ">=", value: sinceDate });
                     }
-                    const events = await adapter.findMany({
-                        model: tableName,
+                    const findManyOptions = {
                         where,
                         orderBy: [{ field: "timestamp", direction: sort === "desc" ? "desc" : "asc" }],
-                        limit: limit + 1, // Get one extra to check hasMore
-                    });
+                        limit: limit + 1,
+                    };
+                    if (offset != null && offset > 0) {
+                        findManyOptions.offset = offset;
+                    }
+                    const events = await findManyWithResolvedModel(findManyOptions);
                     const hasMore = events.length > limit;
                     const paginatedEvents = events.slice(0, limit).map((event) => ({
                         id: event.id,
@@ -1657,7 +1867,7 @@ export function createStorageProvider(options) {
                     const whereConditions = [];
                     const params = [];
                     let paramIndex = 1;
-                    if (after) {
+                    if (offset == null && after) {
                         if (sort === "desc") {
                             whereConditions.push(`id < $${paramIndex}`);
                         }
@@ -1683,12 +1893,13 @@ export function createStorageProvider(options) {
                         paramIndex++;
                     }
                     const whereClause = whereConditions.length > 0 ? `WHERE ${whereConditions.join(" AND ")}` : "";
+                    const offsetSql = offset != null && offset > 0 ? ` OFFSET ${offset}` : "";
                     const orderDirection = sort === "desc" ? "DESC" : "ASC";
                     // Use appropriate raw SQL method
                     let queryFn;
                     if (sqlAdapter.$queryRawUnsafe || adapter.$queryRawUnsafe) {
                         // Prisma - build query with parameters embedded
-                        let query = `SELECT * FROM ${tableName} ${whereClause} ORDER BY timestamp ${orderDirection}, id ${orderDirection} LIMIT ${limit + 1}`;
+                        let query = `SELECT * FROM ${tableName} ${whereClause} ORDER BY timestamp ${orderDirection}, id ${orderDirection} LIMIT ${limit + 1}${offsetSql}`;
                         // Replace $1, $2, etc. with actual values for Prisma
                         params.forEach((param, index) => {
                             const placeholder = `$${index + 1}`;
@@ -1732,7 +1943,7 @@ export function createStorageProvider(options) {
                     }
                     else {
                         // Other adapters - use parameterized query
-                        const query = `SELECT * FROM ${tableName} ${whereClause} ORDER BY timestamp ${orderDirection}, id ${orderDirection} LIMIT $${paramIndex}`;
+                        const query = `SELECT * FROM ${tableName} ${whereClause} ORDER BY timestamp ${orderDirection}, id ${orderDirection} LIMIT $${paramIndex}${offsetSql}`;
                         params.push(limit + 1);
                         if (sqlAdapter.$queryRaw || adapter.$queryRaw) {
                             const queryMethod = sqlAdapter.$queryRaw || adapter.$queryRaw;
@@ -1788,4 +1999,3 @@ export function createStorageProvider(options) {
         },
     };
 }
-//# sourceMappingURL=helpers.js.map