@xylex-group/better-auth-athena 1.0.3 → 1.0.6

package/dist/index.js

@@ -2,9 +2,7 @@
 import {
   createAdapterFactory
 } from "better-auth/adapters";
-import {
-  createClient
-} from "@xylex-group/athena";
+import { createClient } from "@xylex-group/athena";
 
 // src/config.ts
 import fs from "fs";
@@ -12,9 +10,9 @@ import path from "path";
 import YAML from "yaml";
 var defaultAthenaGlobalConfig = {
   athena: {
-    url: "http://localhost:3000",
-    apiKey: "",
-    client: "better-auth"
+    url: "https://mirror3.athena-db.com",
+    apiKey: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYXV0aGVudGljYXRlZCIsImVtYWlsIjoiZmxvcmlzQHh5bGV4LmFpIiwiZXhwIjoyNDk3MDMzNjY2fQ.LdPqTGaFq5pTokW1DA81WFjmG4nReJCOSKr3mFtXNoA",
+    client: "athena_logging"
   }
 };
 var DEFAULT_CONFIG_FILENAME = "config.yaml";
@@ -89,7 +87,7 @@ function getAthenaGlobalConfig(options) {
   return { config: cached, version };
 }
 
-// src/index.ts
+// src/utils.ts
 function toSnakeCase(key) {
   return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/__/g, "_").toLowerCase();
 }
@@ -134,7 +132,8 @@ function toDbRecord(data) {
   );
   return coerceDateFields(withDbKeys);
 }
-function applyWhere(builder, field, operator, value, columnMapper = (col) => hasUppercase(col) ? toSnakeCase(col) : col) {
+var defaultColumnMapper = (col) => hasUppercase(col) ? toSnakeCase(col) : col;
+function applyWhere(builder, field, operator, value, columnMapper = defaultColumnMapper) {
   const dbField = columnMapper(field);
   switch (operator) {
     case "eq":
@@ -167,6 +166,451 @@ function isMissingColumnError(error) {
   const msg = String(error ?? "");
   return msg.includes("specified column does not exist") || msg.includes("column does not exist");
 }
+function isSuccessMessageInError(error) {
+  const msg = String(error ?? "").toLowerCase();
+  return msg === "data inserted successfully" || msg === "data updated successfully" || msg === "data deleted successfully";
+}
+function snakeMapper(col) {
+  return hasUppercase(col) ? toSnakeCase(col) : col;
+}
+function identityMapper(col) {
+  return col;
+}
+function getRowValue(row, field) {
+  if (Object.prototype.hasOwnProperty.call(row, field)) return row[field];
+  const snake = hasUppercase(field) ? toSnakeCase(field) : field;
+  return row[snake];
+}
+function filterRowsByWhere(rows, where) {
+  if (!where.length) return rows;
+  return rows.filter((row) => {
+    for (const { field, operator, value } of where) {
+      const rowVal = getRowValue(row, field);
+      switch (operator) {
+        case "eq":
+          if (rowVal !== value) return false;
+          break;
+        case "ne":
+          if (rowVal === value) return false;
+          break;
+        case "in":
+          if (!Array.isArray(value) || !value.includes(rowVal)) return false;
+          break;
+        case "not_in":
+          if (Array.isArray(value) && value.includes(rowVal)) return false;
+          break;
+        default:
+          if (rowVal !== value) return false;
+      }
+    }
+    return true;
+  });
+}
+
+// src/methods/create.ts
+function createMethod(deps) {
+  const { ensureDbClient } = deps;
+  return async function create({
+    model,
+    data
+  }) {
+    const db = ensureDbClient();
+    const insertData = toDbRecord(data);
+    const { data: result, error } = await db.from(model).insert(insertData).select();
+    if (error && !isSuccessMessageInError(error)) {
+      throw new Error(`[AthenaAdapter] create on "${model}" failed: ${error}`);
+    }
+    const row = Array.isArray(result) ? result[0] : result;
+    return mapRowToBetterAuth(row ?? insertData);
+  };
+}
+
+// src/methods/update.ts
+function updateMethod(deps) {
+  const { ensureDbClient } = deps;
+  return async function update({
+    model,
+    where,
+    update
+  }) {
+    const db = ensureDbClient();
+    const updateData = toDbRecord(update);
+    const build = (useRetryShape) => {
+      if (!useRetryShape) {
+        let b2 = db.from(model).update({ data: updateData, set: updateData });
+        for (const clause of where) {
+          b2 = applyWhere(b2, clause.field, clause.operator, clause.value);
+        }
+        return b2;
+      }
+      let b = db.from(model).update(updateData, {
+        updateBody: { data: updateData, set: updateData }
+      });
+      for (const clause of where) {
+        b = applyWhere(b, clause.field, clause.operator, clause.value);
+      }
+      return b;
+    };
+    const run = async (b) => {
+      const { data: result, error } = await b.select();
+      return { result, error };
+    };
+    const first = await run(build(false));
+    if (first.error && !isSuccessMessageInError(first.error)) {
+      const msg = String(first.error);
+      if (msg.toLowerCase().includes("update payload required")) {
+        const retry = await run(build(true));
+        if (retry.error && !isSuccessMessageInError(retry.error)) {
+          throw new Error(
+            `[AthenaAdapter] update on "${model}" failed: ${retry.error}`
+          );
+        }
+        const row2 = Array.isArray(retry.result) ? retry.result[0] : retry.result;
+        return row2 ? mapRowToBetterAuth(row2) : null;
+      }
+      throw new Error(`[AthenaAdapter] update on "${model}" failed: ${first.error}`);
+    }
+    const row = Array.isArray(first.result) ? first.result[0] : first.result;
+    return row ? mapRowToBetterAuth(row) : null;
+  };
+}
+
+// src/methods/update-many.ts
+function updateManyMethod(deps) {
+  const { ensureDbClient } = deps;
+  return async function updateMany({
+    model,
+    where,
+    update
+  }) {
+    const db = ensureDbClient();
+    const updateData = toDbRecord(update);
+    const build = (useRetryShape) => {
+      if (!useRetryShape) {
+        let b2 = db.from(model).update({ data: updateData, set: updateData });
+        for (const clause of where) {
+          b2 = applyWhere(b2, clause.field, clause.operator, clause.value);
+        }
+        return b2;
+      }
+      let b = db.from(model).update(updateData, {
+        updateBody: { data: updateData, set: updateData }
+      });
+      for (const clause of where) {
+        b = applyWhere(b, clause.field, clause.operator, clause.value);
+      }
+      return b;
+    };
+    const run = async (b) => {
+      const { data: result, error } = await b.select();
+      return { result, error };
+    };
+    const first = await run(build(false));
+    if (first.error && !isSuccessMessageInError(first.error)) {
+      const msg = String(first.error);
+      if (msg.toLowerCase().includes("update payload required")) {
+        const retry = await run(build(true));
+        if (retry.error && !isSuccessMessageInError(retry.error)) {
+          throw new Error(
+            `[AthenaAdapter] updateMany on "${model}" failed: ${retry.error}`
+          );
+        }
+        return Array.isArray(retry.result) ? retry.result.length : retry.result ? 1 : 0;
+      }
+      throw new Error(
+        `[AthenaAdapter] updateMany on "${model}" failed: ${first.error}`
+      );
+    }
+    return Array.isArray(first.result) ? first.result.length : first.result ? 1 : 0;
+  };
+}
+
+// src/methods/delete.ts
+function deleteMethod(deps) {
+  const { ensureDbClient, headers } = deps;
+  return async function del({
+    model,
+    where
+  }) {
+    const db = ensureDbClient();
+    let builder = db.from(model);
+    for (const clause of where) {
+      builder = applyWhere(
+        builder,
+        clause.field,
+        clause.operator,
+        clause.value
+      );
+    }
+    const { error } = await builder.delete(
+      headers ? { headers } : void 0
+    );
+    if (error && !isSuccessMessageInError(error)) {
+      throw new Error(
+        `[AthenaAdapter] delete on "${model}" failed: ${error}`
+      );
+    }
+  };
+}
+
+// src/methods/delete-many.ts
+function deleteManyMethod(deps) {
+  const { ensureDbClient, headers } = deps;
+  return async function deleteMany({
+    model,
+    where
+  }) {
+    const db = ensureDbClient();
+    const mainBuilder = db.from(model);
+    let builder = mainBuilder;
+    for (const clause of where) {
+      builder = applyWhere(
+        builder,
+        clause.field,
+        clause.operator,
+        clause.value
+      );
+    }
+    const { data: result, error } = await builder.delete(
+      headers ? { headers } : void 0
+    ).select();
+    if (error && !isSuccessMessageInError(error)) {
+      throw new Error(
+        `[AthenaAdapter] deleteMany on "${model}" failed: ${error}`
+      );
+    }
+    const deletedCount = Array.isArray(result) ? result.length : result ? 1 : 0;
+    const inClause = where.find(
+      (c) => c.operator === "in" && c.value != null
+    );
+    if (inClause && Array.isArray(inClause.value) && deletedCount < inClause.value.length) {
+      let n = 0;
+      for (const v of inClause.value) {
+        const b = db.from(model);
+        const filtered = applyWhere(
+          b,
+          inClause.field,
+          "eq",
+          v
+        );
+        const { data: rowData, error: rowErr } = await filtered.delete(
+          headers ? { headers } : void 0
+        ).select();
+        if (rowErr && isSuccessMessageInError(rowErr)) continue;
+        n += Array.isArray(rowData) ? rowData.length : rowData ? 1 : 0;
+      }
+      return n;
+    }
+    return deletedCount;
+  };
+}
+
+// src/methods/find-one.ts
+function findOneMethod(deps) {
+  const { ensureDbClient } = deps;
+  return async function findOne({
+    model,
+    where,
+    select
+  }) {
+    const db = ensureDbClient();
+    const run = async (columnMapper) => {
+      const columns = select && select.length > 0 ? select.map((c) => columnMapper(c)).join(", ") : void 0;
+      let builder = db.from(model).select(columns);
+      for (const clause of where) {
+        builder = applyWhere(
+          builder,
+          clause.field,
+          clause.operator,
+          clause.value,
+          columnMapper
+        );
+      }
+      const { data: result, error } = await builder.limit(1);
+      return { result, error };
+    };
+    const first = await run(snakeMapper);
+    if (first.error) {
+      if (isMissingColumnError(first.error)) {
+        const retry = await run(identityMapper);
+        if (retry.error) {
+          throw new Error(
+            `[AthenaAdapter] findOne on "${model}" failed: ${retry.error}`
+          );
+        }
+        const rows2 = Array.isArray(retry.result) ? retry.result : retry.result ? [retry.result] : [];
+        const row2 = rows2[0] ?? null;
+        return row2 ? mapRowToBetterAuth(row2) : null;
+      }
+      throw new Error(
+        `[AthenaAdapter] findOne on "${model}" failed: ${first.error}`
+      );
+    }
+    const rows = Array.isArray(first.result) ? first.result : first.result ? [first.result] : [];
+    const row = rows[0] ?? null;
+    if (!row) return null;
+    const mapped = mapRowToBetterAuth(row);
+    const filtered = filterRowsByWhere(
+      [mapped],
+      where
+    );
+    return filtered[0] ? mapped : null;
+  };
+}
+
+// src/methods/find-many.ts
+function findManyMethod(deps) {
+  const { ensureDbClient } = deps;
+  return async function findMany({
+    model,
+    where,
+    limit,
+    sortBy,
+    offset,
+    select
+  }) {
+    const db = ensureDbClient();
+    const run = async (columnMapper, opts) => {
+      const columns = select && select.length > 0 ? select.map((c) => columnMapper(c)).join(", ") : void 0;
+      let builder = db.from(model).select(columns);
+      if (!opts?.skipWhere && where) {
+        for (const clause of where) {
+          builder = applyWhere(
+            builder,
+            clause.field,
+            clause.operator,
+            clause.value,
+            columnMapper
+          );
+        }
+      }
+      const effectiveLimit = opts?.limitOverride ?? limit;
+      const effectiveOffset = opts?.offsetOverride ?? offset;
+      if (effectiveLimit !== void 0) {
+        builder = builder.limit(effectiveLimit);
+      }
+      if (effectiveOffset !== void 0) {
+        builder = builder.offset(effectiveOffset);
+      }
+      const { data: result, error } = await builder;
+      return { result, error };
+    };
+    const first = await run(snakeMapper);
+    const pickRows = (res) => Array.isArray(res) ? res : [];
+    const applySort = (rows) => {
+      if (!sortBy) return rows;
+      const sortField = sortBy.field;
+      rows.sort((a, b) => {
+        const aVal = a[sortField];
+        const bVal = b[sortField];
+        if (aVal == null && bVal == null) return 0;
+        if (aVal == null) return sortBy.direction === "asc" ? -1 : 1;
+        if (bVal == null) return sortBy.direction === "asc" ? 1 : -1;
+        const cmp = typeof aVal === "string" && typeof bVal === "string" ? aVal.localeCompare(bVal) : aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+        return sortBy.direction === "asc" ? cmp : -cmp;
+      });
+      return rows;
+    };
+    const mapAndSort = (rows) => {
+      const betterAuthRows = rows.map((r) => mapRowToBetterAuth(r));
+      if (!where?.length) return applySort(betterAuthRows);
+      const filtered = filterRowsByWhere(
+        betterAuthRows,
+        where
+      );
+      if (filtered.length !== betterAuthRows.length) {
+        const off = offset ?? 0;
+        const end = limit !== void 0 ? off + limit : void 0;
+        return applySort(filtered).slice(off, end);
+      }
+      return applySort(filtered);
+    };
+    const postFilterAndSlice = (rows) => {
+      const mappedSorted = mapAndSort(rows);
+      const off = offset ?? 0;
+      const end = limit !== void 0 ? off + limit : void 0;
+      return mappedSorted.slice(off, end);
+    };
+    if (first.error) {
+      if (isMissingColumnError(first.error)) {
+        const retry = await run(identityMapper);
+        if (retry.error) {
+          throw new Error(
+            `[AthenaAdapter] findMany on "${model}" failed: ${retry.error}`
+          );
+        }
+        const retryRows = pickRows(retry.result);
+        if (where?.length) {
+          const broad = await run(identityMapper, {
+            skipWhere: true,
+            limitOverride: Math.max((offset ?? 0) + (limit ?? 0) + 500, 5e3),
+            offsetOverride: 0
+          });
+          if (!broad.error) return postFilterAndSlice(pickRows(broad.result));
+        }
+        return mapAndSort(retryRows);
+      }
+      throw new Error(
+        `[AthenaAdapter] findMany on "${model}" failed: ${first.error}`
+      );
+    }
+    const firstRows = pickRows(first.result);
+    if (where?.length) {
+      const broad = await run(snakeMapper, {
+        skipWhere: true,
+        limitOverride: Math.max((offset ?? 0) + (limit ?? 0) + 500, 5e3),
+        offsetOverride: 0
+      });
+      if (!broad.error) return postFilterAndSlice(pickRows(broad.result));
+    }
+    return mapAndSort(firstRows);
+  };
+}
+
+// src/methods/count.ts
+function countMethod(deps) {
+  const { ensureDbClient } = deps;
+  return async function count({
+    model,
+    where
+  }) {
+    const db = ensureDbClient();
+    const run = async (columnMapper) => {
+      let builder = db.from(model).select();
+      if (where) {
+        for (const clause of where) {
+          builder = applyWhere(
+            builder,
+            clause.field,
+            clause.operator,
+            clause.value,
+            columnMapper
+          );
+        }
+      }
+      const { data: result, error } = await builder;
+      return { result, error };
+    };
+    const first = await run(snakeMapper);
+    if (first.error) {
+      if (isMissingColumnError(first.error)) {
+        const retry = await run(identityMapper);
+        if (retry.error) {
+          throw new Error(
+            `[AthenaAdapter] count on "${model}" failed: ${retry.error}`
+          );
+        }
+        return Array.isArray(retry.result) ? retry.result.length : 0;
+      }
+      throw new Error(
+        `[AthenaAdapter] count on "${model}" failed: ${first.error}`
+      );
+    }
+    return Array.isArray(first.result) ? first.result.length : 0;
+  };
+}
+
+// src/index.ts
 var athenaAdapter = (config) => {
   let dbClient = null;
   let lastDbConfigVersion = -1;
@@ -175,7 +619,8 @@ var athenaAdapter = (config) => {
     if (shouldUseFixedConfig) {
       if (!dbClient) {
         dbClient = createClient(config.url, config.apiKey, {
-          client: config.client
+          client: config.client,
+          ...config.headers && { headers: config.headers }
         });
       }
       return dbClient;
@@ -193,18 +638,21 @@ var athenaAdapter = (config) => {
       );
     }
     if (!dbClient || version2 !== lastDbConfigVersion) {
-      dbClient = createClient(url, apiKey, { client });
+      dbClient = createClient(url, apiKey, {
+        client,
+        ...config.headers && { headers: config.headers }
+      });
       lastDbConfigVersion = version2;
     }
     return dbClient;
   }
+  const deps = { ensureDbClient, headers: config.headers };
   return createAdapterFactory({
     config: {
       adapterId: "athena",
       adapterName: "Athena Adapter",
       usePlural: config.usePlural ?? false,
       debugLogs: config.debugLogs ?? false,
-      // Athena/Postgres supports all these natively
       supportsJSON: true,
       supportsDates: true,
       supportsBooleans: true,
@@ -213,293 +661,14 @@ var athenaAdapter = (config) => {
     },
     adapter: () => {
       return {
-        // ------------------------------------------------------------------
-        // CREATE
-        // ------------------------------------------------------------------
-        create: async ({
-          model,
-          data
-        }) => {
-          const db = ensureDbClient();
-          const insertData = toDbRecord(data);
-          const { data: result, error } = await db.from(model).insert(insertData).select();
-          if (error) {
-            throw new Error(
-              `[AthenaAdapter] create on "${model}" failed: ${error}`
-            );
-          }
-          const row = Array.isArray(result) ? result[0] : result;
-          return mapRowToBetterAuth(row ?? insertData);
-        },
-        // ------------------------------------------------------------------
-        // UPDATE
-        // ------------------------------------------------------------------
-        update: async ({
-          model,
-          where,
-          update
-        }) => {
-          const db = ensureDbClient();
-          const updateData = toDbRecord(update);
-          let builder = db.from(model).update({ set: updateData });
-          for (const clause of where) {
-            builder = applyWhere(
-              builder,
-              clause.field,
-              clause.operator,
-              clause.value
-            );
-          }
-          const { data: result, error } = await builder.select();
-          if (error) {
-            throw new Error(
-              `[AthenaAdapter] update on "${model}" failed: ${error}`
-            );
-          }
-          const row = Array.isArray(result) ? result[0] : result;
-          return row ? mapRowToBetterAuth(row) : null;
-        },
-        // ------------------------------------------------------------------
-        // UPDATE MANY
-        // ------------------------------------------------------------------
-        updateMany: async ({
-          model,
-          where,
-          update
-        }) => {
-          const db = ensureDbClient();
-          const updateData = toDbRecord(update);
-          let builder = db.from(model).update({ set: updateData });
-          for (const clause of where) {
-            builder = applyWhere(
-              builder,
-              clause.field,
-              clause.operator,
-              clause.value
-            );
-          }
-          const { data: result, error } = await builder.select();
-          if (error) {
-            throw new Error(
-              `[AthenaAdapter] updateMany on "${model}" failed: ${error}`
-            );
-          }
-          return Array.isArray(result) ? result.length : result ? 1 : 0;
-        },
-        // ------------------------------------------------------------------
-        // DELETE
-        // ------------------------------------------------------------------
-        delete: async ({
-          model,
-          where
-        }) => {
-          const db = ensureDbClient();
-          let builder = db.from(model);
-          for (const clause of where) {
-            builder = applyWhere(
-              builder,
-              clause.field,
-              clause.operator,
-              clause.value
-            );
-          }
-          const { error } = await builder.delete();
-          if (error) {
-            throw new Error(
-              `[AthenaAdapter] delete on "${model}" failed: ${error}`
-            );
-          }
-        },
-        // ------------------------------------------------------------------
-        // DELETE MANY
-        // ------------------------------------------------------------------
-        deleteMany: async ({
-          model,
-          where
-        }) => {
-          const db = ensureDbClient();
-          let builder = db.from(model);
-          for (const clause of where) {
-            builder = applyWhere(
-              builder,
-              clause.field,
-              clause.operator,
-              clause.value
-            );
-          }
-          const { data: result, error } = await builder.delete().select();
-          if (error) {
-            throw new Error(
-              `[AthenaAdapter] deleteMany on "${model}" failed: ${error}`
-            );
-          }
-          return Array.isArray(result) ? result.length : result ? 1 : 0;
-        },
-        // ------------------------------------------------------------------
-        // FIND ONE
-        // ------------------------------------------------------------------
-        findOne: async ({
-          model,
-          where,
-          select
-        }) => {
-          const db = ensureDbClient();
-          const snakeMapper = (col) => hasUppercase(col) ? toSnakeCase(col) : col;
-          const identityMapper = (col) => col;
-          const run = async (columnMapper) => {
-            const columns = select && select.length > 0 ? select.map((c) => columnMapper(c)).join(", ") : void 0;
-            let builder = db.from(model).select(columns);
-            for (const clause of where) {
-              builder = applyWhere(
-                builder,
-                clause.field,
-                clause.operator,
-                clause.value,
-                columnMapper
-              );
-            }
-            const { data: result, error } = await builder.limit(1);
-            return { result, error };
-          };
-          const first = await run(snakeMapper);
-          if (first.error) {
-            if (isMissingColumnError(first.error)) {
-              const retry = await run(identityMapper);
-              if (retry.error) {
-                throw new Error(
-                  `[AthenaAdapter] findOne on "${model}" failed: ${retry.error}`
-                );
-              }
-              const rows2 = Array.isArray(retry.result) ? retry.result : retry.result ? [retry.result] : [];
-              const row2 = rows2[0] ?? null;
-              return row2 ? mapRowToBetterAuth(row2) : null;
-            }
-            throw new Error(
-              `[AthenaAdapter] findOne on "${model}" failed: ${first.error}`
-            );
-          }
-          const rows = Array.isArray(first.result) ? first.result : first.result ? [first.result] : [];
-          const row = rows[0] ?? null;
-          return row ? mapRowToBetterAuth(row) : null;
-        },
-        // ------------------------------------------------------------------
-        // FIND MANY
-        // ------------------------------------------------------------------
-        findMany: async ({
-          model,
-          where,
-          limit,
-          sortBy,
-          offset,
-          select
-        }) => {
-          const db = ensureDbClient();
-          const snakeMapper = (col) => hasUppercase(col) ? toSnakeCase(col) : col;
-          const identityMapper = (col) => col;
-          const run = async (columnMapper) => {
-            const columns = select && select.length > 0 ? select.map((c) => columnMapper(c)).join(", ") : void 0;
-            let builder = db.from(model).select(columns);
-            if (where) {
-              for (const clause of where) {
-                builder = applyWhere(
-                  builder,
-                  clause.field,
-                  clause.operator,
-                  clause.value,
-                  columnMapper
-                );
-              }
-            }
-            if (limit !== void 0) {
-              builder = builder.limit(limit);
-            }
-            if (offset !== void 0) {
-              builder = builder.offset(offset);
-            }
-            const { data: result, error } = await builder;
-            return { result, error };
-          };
-          const first = await run(snakeMapper);
-          const pickRows = (res) => Array.isArray(res) ? res : [];
-          const applySort = (rows) => {
-            if (!sortBy) return rows;
-            const sortField = sortBy.field;
-            rows.sort((a, b) => {
-              const aVal = a[sortField];
-              const bVal = b[sortField];
-              if (aVal == null && bVal == null) return 0;
-              if (aVal == null) return sortBy.direction === "asc" ? -1 : 1;
-              if (bVal == null) return sortBy.direction === "asc" ? 1 : -1;
-              const cmp = typeof aVal === "string" && typeof bVal === "string" ? aVal.localeCompare(bVal) : aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-              return sortBy.direction === "asc" ? cmp : -cmp;
-            });
-            return rows;
-          };
-          const mapAndSort = (rows) => {
-            const betterAuthRows = rows.map(
-              (r) => mapRowToBetterAuth(r)
-            );
-            return applySort(betterAuthRows);
-          };
-          if (first.error) {
-            if (isMissingColumnError(first.error)) {
-              const retry = await run(identityMapper);
-              if (retry.error) {
-                throw new Error(
-                  `[AthenaAdapter] findMany on "${model}" failed: ${retry.error}`
-                );
-              }
-              return mapAndSort(pickRows(retry.result));
-            }
-            throw new Error(
-              `[AthenaAdapter] findMany on "${model}" failed: ${first.error}`
-            );
-          }
-          return mapAndSort(pickRows(first.result));
-        },
-        // ------------------------------------------------------------------
-        // COUNT
-        // ------------------------------------------------------------------
-        count: async ({
-          model,
-          where
-        }) => {
-          const db = ensureDbClient();
-          const snakeMapper = (col) => hasUppercase(col) ? toSnakeCase(col) : col;
-          const identityMapper = (col) => col;
-          const run = async (columnMapper) => {
-            let builder = db.from(model).select();
-            if (where) {
-              for (const clause of where) {
-                builder = applyWhere(
-                  builder,
-                  clause.field,
-                  clause.operator,
-                  clause.value,
-                  columnMapper
-                );
-              }
-            }
-            const { data: result, error } = await builder;
-            return { result, error };
-          };
-          const first = await run(snakeMapper);
-          if (first.error) {
-            if (isMissingColumnError(first.error)) {
-              const retry = await run(identityMapper);
-              if (retry.error) {
-                throw new Error(
-                  `[AthenaAdapter] count on "${model}" failed: ${retry.error}`
-                );
-              }
-              return Array.isArray(retry.result) ? retry.result.length : 0;
-            }
-            throw new Error(
-              `[AthenaAdapter] count on "${model}" failed: ${first.error}`
-            );
-          }
-          return Array.isArray(first.result) ? first.result.length : 0;
-        }
+        create: createMethod(deps),
+        update: updateMethod(deps),
+        updateMany: updateManyMethod(deps),
+        delete: deleteMethod(deps),
+        deleteMany: deleteManyMethod(deps),
+        findOne: findOneMethod(deps),
+        findMany: findManyMethod(deps),
+        count: countMethod(deps)
       };
     }
   });