@proofkit/better-auth 0.3.1-beta.1 → 0.4.0-beta.2

package/src/adapter.ts

@@ -1,19 +1,7 @@
 /** biome-ignore-all lint/suspicious/noExplicitAny: library code */
+import type { Database } from "@proofkit/fmodata";
 import { logger } from "better-auth";
 import { type CleanedWhere, createAdapter, type DBAdapterDebugLogOption } from "better-auth/adapters";
-import buildQuery from "odata-query";
-import { prettifyError, z } from "zod/v4";
-import { createRawFetch, type FmOdataConfig } from "./odata";
-
-const configSchema = z.object({
-  debugLogs: z.unknown().optional(),
-  usePlural: z.boolean().optional(),
-  odata: z.object({
-    serverUrl: z.url(),
-    auth: z.union([z.object({ username: z.string(), password: z.string() }), z.object({ apiKey: z.string() })]),
-    database: z.string().endsWith(".fmp12"),
-  }),
-});
 
 export interface FileMakerAdapterConfig {
   /**
@@ -24,27 +12,12 @@ export interface FileMakerAdapterConfig {
    * If the table names in the schema are plural.
    */
   usePlural?: boolean;
-
   /**
-   * Connection details for the FileMaker server.
+   * The fmodata Database instance to use for all OData requests.
    */
-  odata: FmOdataConfig;
-}
-
-export interface AdapterOptions {
-  config: FileMakerAdapterConfig;
+  database: Database;
 }
 
-const defaultConfig: Required<FileMakerAdapterConfig> = {
-  debugLogs: false,
-  usePlural: false,
-  odata: {
-    serverUrl: "",
-    auth: { username: "", password: "" },
-    database: "",
-  },
-};
-
 // Regex patterns for field validation and ISO date detection
 const FIELD_SPECIAL_CHARS_REGEX = /[\s_]/;
 const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
@@ -155,41 +128,59 @@ export function parseWhere(where?: CleanedWhere[]): string {
   return clauses.join(" ");
 }
 
-export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig) => {
-  const parsed = configSchema.loose().safeParse(_config);
+/**
+ * Build an OData query string from parameters.
+ */
+function buildQueryString(params: {
+  top?: number;
+  skip?: number;
+  filter?: string;
+  orderBy?: string;
+  select?: string[];
+}): string {
+  const parts: string[] = [];
+  if (params.top !== undefined) {
+    parts.push(`$top=${params.top}`);
+  }
+  if (params.skip !== undefined) {
+    parts.push(`$skip=${params.skip}`);
+  }
+  if (params.filter) {
+    parts.push(`$filter=${encodeURIComponent(params.filter)}`);
+  }
+  if (params.orderBy) {
+    parts.push(`$orderby=${encodeURIComponent(params.orderBy)}`);
+  }
+  if (params.select?.length) {
+    parts.push(`$select=${params.select.map(encodeURIComponent).join(",")}`);
+  }
+  return parts.length > 0 ? `?${parts.join("&")}` : "";
+}
 
-  if (!parsed.success) {
-    throw new Error(`Invalid configuration: ${prettifyError(parsed.error)}`);
+export const FileMakerAdapter = (config: FileMakerAdapterConfig) => {
+  if (!config.database || typeof config.database !== "object") {
+    throw new Error("FileMakerAdapter requires a `database` (fmodata Database instance).");
   }
-  const config = parsed.data;
 
-  const { fetch } = createRawFetch({
-    ...config.odata,
-    logging: config.debugLogs ? "verbose" : "none",
-  });
+  const db = config.database;
 
   const adapterFactory = createAdapter({
     config: {
       adapterId: "filemaker",
       adapterName: "FileMaker",
-      usePlural: config.usePlural ?? false, // Whether the table names in the schema are plural.
-      debugLogs: config.debugLogs ?? false, // Whether to enable debug logs.
-      supportsJSON: false, // Whether the database supports JSON. (Default: false)
-      supportsDates: false, // Whether the database supports dates. (Default: true)
-      supportsBooleans: false, // Whether the database supports booleans. (Default: true)
-      supportsNumericIds: false, // Whether the database supports auto-incrementing numeric IDs. (Default: true)
+      usePlural: config.usePlural ?? false,
+      debugLogs: config.debugLogs ?? false,
+      supportsJSON: false,
+      supportsDates: false,
+      supportsBooleans: false,
+      supportsNumericIds: false,
     },
     adapter: () => {
       return {
         create: async ({ data, model }) => {
-          if (model === "session") {
-            console.log("session", data);
-          }
-
-          const result = await fetch(`/${model}`, {
+          const result = await db._makeRequest<Record<string, any>>(`/${model}`, {
             method: "POST",
-            body: data,
-            output: z.looseObject({ id: z.string() }),
+            body: JSON.stringify(data),
           });
 
           if (result.error) {
@@ -202,15 +193,12 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
           const filter = parseWhere(where);
           logger.debug("$filter", filter);
 
-          const query = buildQuery({
+          const query = buildQueryString({
             filter: filter.length > 0 ? filter : undefined,
           });
 
-          const result = await fetch(`/${model}/$count${query}`, {
-            method: "GET",
-            output: z.object({ value: z.number() }),
-          });
-          if (!result.data) {
+          const result = await db._makeRequest<{ value: number }>(`/${model}/$count${query}`);
+          if (result.error) {
             throw new Error("Failed to count records");
           }
           return (result.data?.value as any) ?? 0;
@@ -219,15 +207,12 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
           const filter = parseWhere(where);
           logger.debug("$filter", filter);
 
-          const query = buildQuery({
+          const query = buildQueryString({
             top: 1,
             filter: filter.length > 0 ? filter : undefined,
           });
 
-          const result = await fetch(`/${model}${query}`, {
-            method: "GET",
-            output: z.object({ value: z.array(z.any()) }),
-          });
+          const result = await db._makeRequest<{ value: any[] }>(`/${model}${query}`);
           if (result.error) {
             throw new Error("Failed to find record");
           }
@@ -237,7 +222,7 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
           const filter = parseWhere(where);
           logger.debug("FIND MANY", { where, filter });
 
-          const query = buildQuery({
+          const query = buildQueryString({
             top: limit,
             skip: offset,
             orderBy: sortBy ? `${sortBy.field} ${sortBy.direction ?? "asc"}` : undefined,
@@ -245,10 +230,7 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
           });
           logger.debug("QUERY", query);
 
-          const result = await fetch(`/${model}${query}`, {
-            method: "GET",
-            output: z.object({ value: z.array(z.any()) }),
-          });
+          const result = await db._makeRequest<{ value: any[] }>(`/${model}${query}`);
           logger.debug("RESULT", result);
 
           if (result.error) {
@@ -259,54 +241,44 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
         },
         delete: async ({ model, where }) => {
           const filter = parseWhere(where);
-          console.log("DELETE", { model, where, filter });
           logger.debug("$filter", filter);
 
           // Find a single id matching the filter
-          const query = buildQuery({
+          const query = buildQueryString({
             top: 1,
             select: [`"id"`],
             filter: filter.length > 0 ? filter : undefined,
           });
 
-          const toDelete = await fetch(`/${model}${query}`, {
-            method: "GET",
-            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
-          });
+          const toDelete = await db._makeRequest<{ value: { id: string }[] }>(`/${model}${query}`);
 
           const id = toDelete.data?.value?.[0]?.id;
           if (!id) {
-            // Nothing to delete
             return;
           }
 
-          const result = await fetch(`/${model}('${id}')`, {
+          const result = await db._makeRequest(`/${model}('${id}')`, {
             method: "DELETE",
           });
           if (result.error) {
-            console.log("DELETE ERROR", result.error);
             throw new Error("Failed to delete record");
           }
         },
         deleteMany: async ({ model, where }) => {
           const filter = parseWhere(where);
-          console.log("DELETE MANY", { model, where, filter });
 
           // Find all ids matching the filter
-          const query = buildQuery({
+          const query = buildQueryString({
             select: [`"id"`],
             filter: filter.length > 0 ? filter : undefined,
           });
 
-          const rows = await fetch(`/${model}${query}`, {
-            method: "GET",
-            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
-          });
+          const rows = await db._makeRequest<{ value: { id: string }[] }>(`/${model}${query}`);
 
           const ids = rows.data?.value?.map((r: any) => r.id) ?? [];
           let deleted = 0;
           for (const id of ids) {
-            const res = await fetch(`/${model}('${id}')`, {
+            const res = await db._makeRequest(`/${model}('${id}')`, {
               method: "DELETE",
             });
             if (!res.error) {
@@ -319,16 +291,14 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
           const filter = parseWhere(where);
           logger.debug("UPDATE", { model, where, update });
           logger.debug("$filter", filter);
+
           // Find one id to update
-          const query = buildQuery({
+          const query = buildQueryString({
             select: [`"id"`],
             filter: filter.length > 0 ? filter : undefined,
           });
 
-          const existing = await fetch(`/${model}${query}`, {
-            method: "GET",
-            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
-          });
+          const existing = await db._makeRequest<{ value: { id: string }[] }>(`/${model}${query}`);
           logger.debug("EXISTING", existing.data);
 
           const id = existing.data?.value?.[0]?.id;
@@ -336,9 +306,9 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
             return null;
           }
 
-          const patchRes = await fetch(`/${model}('${id}')`, {
+          const patchRes = await db._makeRequest(`/${model}('${id}')`, {
             method: "PATCH",
-            body: update,
+            body: JSON.stringify(update),
           });
           logger.debug("PATCH RES", patchRes.data);
           if (patchRes.error) {
@@ -346,32 +316,27 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
           }
 
           // Read back the updated record
-          const readBack = await fetch(`/${model}('${id}')`, {
-            method: "GET",
-            output: z.record(z.string(), z.unknown()),
-          });
+          const readBack = await db._makeRequest<Record<string, unknown>>(`/${model}('${id}')`);
           logger.debug("READ BACK", readBack.data);
           return (readBack.data as any) ?? null;
         },
         updateMany: async ({ model, where, update }) => {
           const filter = parseWhere(where);
+
           // Find all ids matching the filter
-          const query = buildQuery({
+          const query = buildQueryString({
             select: [`"id"`],
             filter: filter.length > 0 ? filter : undefined,
           });
 
-          const rows = await fetch(`/${model}${query}`, {
-            method: "GET",
-            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
-          });
+          const rows = await db._makeRequest<{ value: { id: string }[] }>(`/${model}${query}`);
 
           const ids = rows.data?.value?.map((r: any) => r.id) ?? [];
           let updated = 0;
           for (const id of ids) {
-            const res = await fetch(`/${model}('${id}')`, {
+            const res = await db._makeRequest(`/${model}('${id}')`, {
               method: "PATCH",
-              body: update,
+              body: JSON.stringify(update),
             });
             if (!res.error) {
               updated++;
@@ -383,7 +348,15 @@ export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig
     },
   });
 
-  // Expose the FileMaker config for CLI access
-  (adapterFactory as any).filemakerConfig = config as FileMakerAdapterConfig;
-  return adapterFactory;
+  // Expose the Database instance for CLI access.
+  // Set on both the factory function (for pre-getAdapter extraction)
+  // and the returned adapter (for post-getAdapter extraction).
+  const originalFactory = adapterFactory;
+  const wrappedFactory = ((options: unknown) => {
+    const adapter = (originalFactory as (opts: unknown) => Record<string, unknown>)(options);
+    adapter.database = db;
+    return adapter;
+  }) as typeof adapterFactory;
+  (wrappedFactory as unknown as { database: Database }).database = db;
+  return wrappedFactory;
 };

package/src/cli/index.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env node --no-warnings
 import { Command } from "@commander-js/extra-typings";
+import type { Database, FFetchOptions } from "@proofkit/fmodata";
+import { FMServerConnection } from "@proofkit/fmodata";
 import { logger } from "better-auth";
 import { getAdapter, getSchema } from "better-auth/db";
 import chalk from "chalk";
 import fs from "fs-extra";
 import prompts from "prompts";
-import type { FileMakerAdapterConfig } from "../adapter";
 import { getConfig } from "../better-auth-cli/utils/get-config";
 import { executeMigration, planMigration, prettyPrintMigrationPlan } from "../migrate";
-import { createRawFetch } from "../odata";
 import "dotenv/config";
 
 async function main() {
@@ -52,21 +52,66 @@ async function main() {
 
       const betterAuthSchema = getSchema(config);
 
-      const adapterConfig = (adapter as unknown as { filemakerConfig: FileMakerAdapterConfig }).filemakerConfig;
-      const { fetch } = createRawFetch({
-        ...adapterConfig.odata,
-        auth:
-          // If the username and password are provided in the CLI, use them to authenticate instead of what's in the config file.
-          options.username && options.password
-            ? {
-                username: options.username,
-                password: options.password,
-              }
-            : adapterConfig.odata.auth,
-        logging: "verbose", // Enable logging for CLI operations
-      });
+      // Extract Database from the adapter factory or resolved adapter.
+      // config.database is the FileMakerAdapter factory function (has .database set on it).
+      // adapter is the resolved adapter after getAdapter() calls the factory (also has .database).
+      // Try both: adapter first (post-call), then config.database (pre-call / factory function).
+      const configDb =
+        (adapter as unknown as { database?: Database }).database ??
+        (config.database as unknown as { database?: Database } | undefined)?.database;
+      if (!configDb || typeof configDb !== "object" || !("schema" in configDb)) {
+        logger.error(
+          "Could not extract Database instance from adapter. Ensure your auth.ts uses FileMakerAdapter with an fmodata Database.",
+        );
+        process.exit(1);
+      }
+      let db: Database = configDb;
+
+      // Extract database name and server URL for display.
+      // Try the public getter first (_getDatabaseName), fall back to the private field (databaseName).
+      const dbObj = configDb as unknown as {
+        _getDatabaseName?: string;
+        databaseName?: string;
+        context?: { _getBaseUrl?: () => string; _fetchClientOptions?: unknown };
+      };
+      const dbName: string = dbObj._getDatabaseName ?? dbObj.databaseName ?? "";
+      const baseUrl: string | undefined = dbObj.context?._getBaseUrl?.();
+      const serverUrl = baseUrl ? new URL(baseUrl).origin : undefined;
+
+      // If CLI credential overrides are provided, construct a new connection
+      if (options.username && options.password) {
+        if (!dbName) {
+          logger.error("Could not determine database filename from adapter config.");
+          process.exit(1);
+        }
+
+        if (!baseUrl) {
+          logger.error(
+            "Could not determine server URL from adapter config. Ensure your auth.ts uses FMServerConnection.",
+          );
+          process.exit(1);
+        }
 
-      const migrationPlan = await planMigration(fetch, betterAuthSchema, adapterConfig.odata.database);
+        const fetchClientOptions = dbObj.context?._fetchClientOptions as FFetchOptions | undefined;
+        const connection = new FMServerConnection({
+          serverUrl: serverUrl as string,
+          auth: {
+            username: options.username,
+            password: options.password,
+          },
+          fetchClientOptions,
+        });
+
+        db = connection.database(dbName);
+      }
+
+      let migrationPlan: Awaited<ReturnType<typeof planMigration>>;
+      try {
+        migrationPlan = await planMigration(db, betterAuthSchema);
+      } catch (err) {
+        logger.error(`Failed to read database schema: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
 
       if (migrationPlan.length === 0) {
         logger.info("No changes to apply. Database is up to date.");
@@ -74,7 +119,7 @@ async function main() {
       }
 
       if (!options.yes) {
-        prettyPrintMigrationPlan(migrationPlan);
+        prettyPrintMigrationPlan(migrationPlan, { serverUrl, fileName: dbName });
 
         if (migrationPlan.length > 0) {
           console.log(chalk.gray("💡 Tip: You can use the --yes flag to skip this confirmation."));
@@ -91,12 +136,18 @@ async function main() {
         }
       }
 
-      await executeMigration(fetch, migrationPlan);
-
-      logger.info("Migration applied successfully.");
+      try {
+        await executeMigration(db, migrationPlan);
+        logger.info("Migration applied successfully.");
+      } catch {
+        process.exit(1);
+      }
     });
   await program.parseAsync(process.argv);
   process.exit(0);
 }
 
-main().catch(console.error);
+main().catch((err) => {
+  logger.error(err.message ?? err);
+  process.exit(1);
+});