@xylex-group/better-auth-athena 1.0.0 → 1.0.2

package/README.md

@@ -1,5 +1,6 @@
 # better-auth-athena
 
+current version: `1.0.2`
 A Better-Auth database adapter for the `@xylex-group/athena` gateway. It lets Better-Auth read and write data through Athena while keeping column names in `snake_case` as required by the gateway.
 
 ## Installation
@@ -22,8 +23,6 @@ import { athenaAdapter } from "better-auth-athena";
 
 export const auth = betterAuth({
   database: athenaAdapter({
-    url: process.env.ATHENA_URL!,
-    apiKey: process.env.ATHENA_API_KEY!,
     client: "my-app",
   }),
 });
@@ -35,11 +34,15 @@ export const auth = betterAuth({
 
 | Option | Type | Required | Default | Description |
 | --- | --- | --- | --- | --- |
-| `url` | `string` | ✅ | — | Athena gateway URL. |
-| `apiKey` | `string` | ✅ | — | API key used to authenticate with Athena. |
+| `url` | `string` | ❌ (if `config.yaml` provides it) | — | Athena gateway URL. |
+| `apiKey` | `string` | ❌ (if `config.yaml` provides it) | — | API key used to authenticate with Athena. |
 | `client` | `string` | ❌ | — | Client name included with gateway requests. |
 | `debugLogs` | `DBAdapterDebugLogOption` | ❌ | `false` | Enables Better-Auth adapter debug logs. |
 | `usePlural` | `boolean` | ❌ | `false` | Treats table names as plural when mapping models. |
+| `configPath` | `string` | ❌ | `./config.yaml` | Path to the YAML config file (resolved from `process.cwd()`). |
+| `watchConfig` | `boolean` | ❌ | `true` | When enabled, reload `config.yaml` on changes. |
+
+If `url`/`apiKey` are not passed, the adapter reads them from `config.yaml` in `process.cwd()`. If the file does not exist, it is generated at runtime from defaults.
 
 ## Notes
 

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -25,38 +35,199 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_adapters = require("better-auth/adapters");
 var import_athena = require("@xylex-group/athena");
-function applyWhere(builder, field, operator, value) {
+
+// src/config.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_yaml = __toESM(require("yaml"), 1);
+var defaultAthenaGlobalConfig = {
+  athena: {
+    url: "http://localhost:3000",
+    apiKey: "",
+    client: "better-auth"
+  }
+};
+var DEFAULT_CONFIG_FILENAME = "config.yaml";
+function resolveConfigPath(configPath) {
+  if (configPath) return import_node_path.default.resolve(configPath);
+  return import_node_path.default.resolve(process.cwd(), DEFAULT_CONFIG_FILENAME);
+}
+var cached = null;
+var cachedConfigPath = null;
+var version = 0;
+var watcher = null;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, partial) {
+  if (!isObject(partial)) return base;
+  const out = { ...base };
+  for (const [k, v] of Object.entries(partial)) {
+    if (v && isObject(v) && isObject(out[k])) {
+      out[k] = deepMerge(out[k], v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function ensureConfigFile(configPath) {
+  const dir = import_node_path.default.dirname(configPath);
+  if (!import_node_fs.default.existsSync(dir)) import_node_fs.default.mkdirSync(dir, { recursive: true });
+  if (!import_node_fs.default.existsSync(configPath)) {
+    const yaml = import_yaml.default.stringify(defaultAthenaGlobalConfig);
+    import_node_fs.default.writeFileSync(configPath, yaml, "utf-8");
+  }
+}
+function readConfigFromDisk(configPath) {
+  ensureConfigFile(configPath);
+  const raw = import_node_fs.default.readFileSync(configPath, "utf-8");
+  const parsed = import_yaml.default.parse(raw);
+  return deepMerge(defaultAthenaGlobalConfig, parsed);
+}
+function startWatcher(configPath) {
+  if (cachedConfigPath !== null && cachedConfigPath !== configPath && watcher) {
+    try {
+      watcher.close();
+    } catch {
+    }
+    watcher = null;
+  }
+  if (watcher || cachedConfigPath === configPath) return;
+  try {
+    watcher = import_node_fs.default.watch(configPath, { persistent: false }, (event) => {
+      if (event !== "change" && event !== "rename") return;
+      try {
+        cached = readConfigFromDisk(configPath);
+        version += 1;
+      } catch {
+      }
+    });
+    cachedConfigPath = configPath;
+  } catch {
+  }
+}
+function getAthenaGlobalConfig(options) {
+  const configPath = resolveConfigPath(options?.configPath);
+  const shouldWatch = options?.watch ?? true;
+  if (!cached || cachedConfigPath !== configPath) {
+    cached = readConfigFromDisk(configPath);
+    cachedConfigPath = configPath;
+    version += 1;
+  }
+  if (shouldWatch) startWatcher(configPath);
+  return { config: cached, version };
+}
+
+// src/index.ts
+function toSnakeCase(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/__/g, "_").toLowerCase();
+}
+function toCamelCase(key) {
+  return key.replace(/_([a-z0-9])/g, (_, ch) => ch.toUpperCase());
+}
+function hasUppercase(key) {
+  return /[A-Z]/.test(key);
+}
+function mapKeys(obj, mapKey) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) out[mapKey(k)] = v;
+  return out;
+}
+function mapRowToBetterAuth(row) {
+  if (!row || typeof row !== "object") return row;
+  if (Array.isArray(row)) return row.map(mapRowToBetterAuth);
+  return mapKeys(row, toCamelCase);
+}
+function isLikelyIsoDateString(value) {
+  if (!/^\d{4}-\d{2}-\d{2}T/.test(value)) return false;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms);
+}
+function isTimestampKey(key) {
+  return key.endsWith("At") || key.endsWith("_at") || key === "expires";
+}
+function coerceDateFields(data) {
+  const out = { ...data };
+  for (const [key, val] of Object.entries(out)) {
+    if (val == null) continue;
+    if (typeof val === "string" && isTimestampKey(key) && isLikelyIsoDateString(val)) {
+      out[key] = new Date(val);
+    }
+  }
+  return out;
+}
+function toDbRecord(data) {
+  const withDbKeys = mapKeys(
+    data,
+    (k) => hasUppercase(k) ? toSnakeCase(k) : k
+  );
+  return coerceDateFields(withDbKeys);
+}
+function applyWhere(builder, field, operator, value, columnMapper = (col) => hasUppercase(col) ? toSnakeCase(col) : col) {
+  const dbField = columnMapper(field);
   switch (operator) {
     case "eq":
-      return builder.eq(field, value);
+      return builder.eq(dbField, value);
     case "ne":
-      return builder.neq(field, value);
+      return builder.neq(dbField, value);
     case "gt":
-      return builder.gt(field, value);
+      return builder.gt(dbField, value);
     case "gte":
-      return builder.gte(field, value);
+      return builder.gte(dbField, value);
     case "lt":
-      return builder.lt(field, value);
+      return builder.lt(dbField, value);
     case "lte":
-      return builder.lte(field, value);
+      return builder.lte(dbField, value);
     case "in":
-      return builder.in(field, value);
+      return builder.in(dbField, value);
     case "not_in":
-      return builder.not(field, "in", value);
+      return builder.not(dbField, "in", value);
     case "contains":
-      return builder.like(field, `%${value}%`);
+      return builder.like(dbField, `%${value}%`);
     case "starts_with":
-      return builder.like(field, `${value}%`);
+      return builder.like(dbField, `${value}%`);
     case "ends_with":
-      return builder.like(field, `%${value}`);
+      return builder.like(dbField, `%${value}`);
     default:
-      return builder.eq(field, value);
+      return builder.eq(dbField, value);
   }
 }
+function isMissingColumnError(error) {
+  const msg = String(error ?? "");
+  return msg.includes("specified column does not exist") || msg.includes("column does not exist");
+}
 var athenaAdapter = (config) => {
-  const db = (0, import_athena.createClient)(config.url, config.apiKey, {
-    client: config.client
-  });
+  let dbClient = null;
+  let lastDbConfigVersion = -1;
+  const shouldUseFixedConfig = typeof config.url === "string" && config.url.length > 0 && typeof config.apiKey === "string" && config.apiKey.length > 0;
+  function ensureDbClient() {
+    if (shouldUseFixedConfig) {
+      if (!dbClient) {
+        dbClient = (0, import_athena.createClient)(config.url, config.apiKey, {
+          client: config.client
+        });
+      }
+      return dbClient;
+    }
+    const { config: globalConfig, version: version2 } = getAthenaGlobalConfig({
+      configPath: config.configPath,
+      watch: config.watchConfig ?? true
+    });
+    const url = config.url ?? globalConfig.athena.url;
+    const apiKey = config.apiKey ?? globalConfig.athena.apiKey;
+    const client = config.client ?? globalConfig.athena.client;
+    if (!url || !apiKey) {
+      throw new Error(
+        `[AthenaAdapter] Missing Athena connection details. Set both 'athena.url' and 'athena.apiKey' in config.yaml (or pass 'url'/'apiKey' to athenaAdapter).`
+      );
+    }
+    if (!dbClient || version2 !== lastDbConfigVersion) {
+      dbClient = (0, import_athena.createClient)(url, apiKey, { client });
+      lastDbConfigVersion = version2;
+    }
+    return dbClient;
+  }
   return (0, import_adapters.createAdapterFactory)({
     config: {
       adapterId: "athena",
@@ -67,143 +238,297 @@ var athenaAdapter = (config) => {
       supportsJSON: true,
       supportsDates: true,
       supportsBooleans: true,
-      supportsNumericIds: true
+      supportsNumericIds: true,
+      supportsUUIDs: true
     },
     adapter: () => {
       return {
         // ------------------------------------------------------------------
         // CREATE
         // ------------------------------------------------------------------
-        create: async ({ model, data }) => {
-          const { data: result, error } = await db.from(model).insert(data).select();
+        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}`);
+            throw new Error(
+              `[AthenaAdapter] create on "${model}" failed: ${error}`
+            );
           }
           const row = Array.isArray(result) ? result[0] : result;
-          return row ?? data;
+          return mapRowToBetterAuth(row ?? insertData);
         },
         // ------------------------------------------------------------------
         // UPDATE
         // ------------------------------------------------------------------
-        update: async ({ model, where, update }) => {
-          let builder = db.from(model).update(update);
+        update: async ({
+          model,
+          where,
+          update
+        }) => {
+          const db = ensureDbClient();
+          const updateData = toDbRecord(update);
+          let builder = db.from(model).update(updateData);
           for (const clause of where) {
-            builder = applyWhere(builder, clause.field, clause.operator, clause.value);
+            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}`);
+            throw new Error(
+              `[AthenaAdapter] update on "${model}" failed: ${error}`
+            );
           }
           const row = Array.isArray(result) ? result[0] : result;
-          return row ?? null;
+          return row ? mapRowToBetterAuth(row) : null;
         },
         // ------------------------------------------------------------------
         // UPDATE MANY
         // ------------------------------------------------------------------
-        updateMany: async ({ model, where, update }) => {
-          let builder = db.from(model).update(update);
+        updateMany: async ({
+          model,
+          where,
+          update
+        }) => {
+          const db = ensureDbClient();
+          const updateData = toDbRecord(update);
+          let builder = db.from(model).update(updateData);
           for (const clause of where) {
-            builder = applyWhere(builder, clause.field, clause.operator, clause.value);
+            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}`);
+            throw new Error(
+              `[AthenaAdapter] updateMany on "${model}" failed: ${error}`
+            );
           }
           return Array.isArray(result) ? result.length : result ? 1 : 0;
         },
         // ------------------------------------------------------------------
         // DELETE
         // ------------------------------------------------------------------
-        delete: async ({ model, where }) => {
+        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);
+            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}`);
+            throw new Error(
+              `[AthenaAdapter] delete on "${model}" failed: ${error}`
+            );
           }
         },
         // ------------------------------------------------------------------
         // DELETE MANY
         // ------------------------------------------------------------------
-        deleteMany: async ({ model, where }) => {
+        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);
+            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}`);
+            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 columns = select && select.length > 0 ? select.join(", ") : void 0;
-          let builder = db.from(model).select(columns);
-          for (const clause of where) {
-            builder = applyWhere(builder, clause.field, clause.operator, clause.value);
-          }
-          const { data: result, error } = await builder.limit(1);
-          if (error) {
-            throw new Error(`[AthenaAdapter] findOne on "${model}" failed: ${error}`);
+        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(result) ? result : result ? [result] : [];
-          return rows[0] ?? null;
+          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 columns = select && select.length > 0 ? select.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);
+        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;
-          if (error) {
-            throw new Error(`[AthenaAdapter] findMany on "${model}" failed: ${error}`);
-          }
-          const rows = Array.isArray(result) ? result : [];
-          if (sortBy) {
+            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[sortBy.field];
-              const bVal = b[sortBy.field];
+              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 rows;
+          return mapAndSort(pickRows(first.result));
         },
         // ------------------------------------------------------------------
         // COUNT
         // ------------------------------------------------------------------
-        count: async ({ model, where }) => {
-          let builder = db.from(model).select();
-          if (where) {
-            for (const clause of where) {
-              builder = applyWhere(builder, clause.field, clause.operator, clause.value);
+        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}`
+            );
           }
-          const { data: result, error } = await builder;
-          if (error) {
-            throw new Error(`[AthenaAdapter] count on "${model}" failed: ${error}`);
-          }
-          return Array.isArray(result) ? result.length : 0;
+          return Array.isArray(first.result) ? first.result.length : 0;
         }
       };
     }