@proofkit/better-auth 0.2.4 → 0.3.0

package/src/migrate.ts

@@ -2,10 +2,10 @@ import { type BetterAuthDbSchema } from "better-auth/db";
 import { type Metadata } from "fm-odata-client";
 import chalk from "chalk";
 import z from "zod/v4";
-import { createFmOdataFetch } from "./odata";
+import { createRawFetch } from "./odata";
 
 export async function getMetadata(
-  fetch: ReturnType<typeof createFmOdataFetch>,
+  fetch: ReturnType<typeof createRawFetch>["fetch"],
   databaseName: string,
 ) {
   console.log("getting metadata...");
@@ -21,11 +21,16 @@ export async function getMetadata(
       .catch(null),
   });
 
+  if (result.error) {
+    console.error("Failed to get metadata:", result.error);
+    return null;
+  }
+
   return (result.data?.[databaseName] ?? null) as Metadata | null;
 }
 
 export async function planMigration(
-  fetch: ReturnType<typeof createFmOdataFetch>,
+  fetch: ReturnType<typeof createRawFetch>["fetch"],
   betterAuthSchema: BetterAuthDbSchema,
   databaseName: string,
 ): Promise<MigrationPlan> {
@@ -156,24 +161,41 @@ export async function planMigration(
 }
 
 export async function executeMigration(
-  fetch: ReturnType<typeof createFmOdataFetch>,
+  fetch: ReturnType<typeof createRawFetch>["fetch"],
   migrationPlan: MigrationPlan,
 ) {
   for (const step of migrationPlan) {
     if (step.operation === "create") {
       console.log("Creating table:", step.tableName);
-      await fetch("@post/FileMaker_Tables", {
+      const result = await fetch("/FileMaker_Tables", {
+        method: "POST",
         body: {
           tableName: step.tableName,
           fields: step.fields,
         },
       });
+
+      if (result.error) {
+        console.error(
+          `Failed to create table ${step.tableName}:`,
+          result.error,
+        );
+        throw new Error(`Migration failed: ${result.error}`);
+      }
     } else if (step.operation === "update") {
       console.log("Adding fields to table:", step.tableName);
-      await fetch("@post/FileMaker_Tables/:tableName", {
-        params: { tableName: step.tableName },
+      const result = await fetch(`/FileMaker_Tables/${step.tableName}`, {
+        method: "PATCH",
         body: { fields: step.fields },
       });
+
+      if (result.error) {
+        console.error(
+          `Failed to update table ${step.tableName}:`,
+          result.error,
+        );
+        throw new Error(`Migration failed: ${result.error}`);
+      }
     }
   }
 }

package/src/odata/index.ts

@@ -1,5 +1,3 @@
-import { createFetch, createSchema } from "@better-fetch/fetch";
-import { logger } from "@better-fetch/logger";
 import { logger as betterAuthLogger } from "better-auth";
 import { err, ok, Result } from "neverthrow";
 import { z } from "zod/v4";
@@ -20,83 +18,246 @@ export type FmOdataConfig = {
   logging?: true | "verbose" | "none";
 };
 
-const schema = createSchema({
-  /**
-   * Create a new table
-   */
-  "@post/FileMaker_Tables": {
-    input: z.object({ tableName: z.string(), fields: z.array(z.any()) }),
-  },
-  /**
-   * Add fields to a table
-   */
-  "@patch/FileMaker_Tables/:tableName": {
-    params: z.object({ tableName: z.string() }),
-    input: z.object({ fields: z.array(z.any()) }),
-  },
-  /**
-   * Delete a table
-   */
-  "@delete/FileMaker_Tables/:tableName": {
-    params: z.object({ tableName: z.string() }),
-  },
-  /**
-   * Delete a field from a table
-   */
-  "@delete/FileMaker_Tables/:tableName/:fieldName": {
-    params: z.object({ tableName: z.string(), fieldName: z.string() }),
-  },
-});
-
-export function createFmOdataFetch(args: FmOdataConfig) {
+export function validateUrl(input: string): Result<URL, unknown> {
+  try {
+    const url = new URL(input);
+    return ok(url);
+  } catch (error) {
+    return err(error);
+  }
+}
+
+export function createRawFetch(args: FmOdataConfig) {
   const result = validateUrl(args.serverUrl);
 
   if (result.isErr()) {
     throw new Error("Invalid server URL");
   }
+
   let baseURL = result.value.origin;
   if ("apiKey" in args.auth) {
     baseURL += `/otto`;
   }
   baseURL += `/fmi/odata/v4/${args.database}`;
 
-  return createFetch({
-    baseURL,
-    auth:
-      "apiKey" in args.auth
-        ? { type: "Bearer", token: args.auth.apiKey }
-        : {
-            type: "Basic",
-            username: args.auth.username,
-            password: args.auth.password,
-          },
-    onError: (error) => {
-      console.error("url", error.request.url.toString());
-      console.log(error.error);
-      console.log("error.request.body", JSON.stringify(error.request.body));
+  // Create authentication headers
+  const authHeaders: Record<string, string> = {};
+  if ("apiKey" in args.auth) {
+    authHeaders.Authorization = `Bearer ${args.auth.apiKey}`;
+  } else {
+    const credentials = btoa(`${args.auth.username}:${args.auth.password}`);
+    authHeaders.Authorization = `Basic ${credentials}`;
+  }
+
+  // Enhanced fetch function with body handling, validation, and structured responses
+  const wrappedFetch = async <TOutput = any>(
+    input: string | URL | Request,
+    options?: Omit<RequestInit, "body"> & {
+      body?: any; // Allow any type for body
+      output?: z.ZodSchema<TOutput>; // Optional schema for validation
     },
-    schema,
-    plugins: [
-      logger({
-        verbose: args.logging === "verbose",
-        enabled: args.logging === "verbose" || !!args.logging,
-        console: {
-          fail: (...args) => betterAuthLogger.error("better-fetch", ...args),
-          success: (...args) => betterAuthLogger.info("better-fetch", ...args),
-          log: (...args) => betterAuthLogger.info("better-fetch", ...args),
-          error: (...args) => betterAuthLogger.error("better-fetch", ...args),
-          warn: (...args) => betterAuthLogger.warn("better-fetch", ...args),
-        },
-      }),
-    ],
-  });
-}
+  ): Promise<{ data?: TOutput; error?: string; response?: Response }> => {
+    try {
+      let url: string;
 
-export function validateUrl(input: string): Result<URL, unknown> {
-  try {
-    const url = new URL(input);
-    return ok(url);
-  } catch (error) {
-    return err(error);
-  }
+      // Handle different input types
+      if (typeof input === "string") {
+        // If it's already a full URL, use as-is, otherwise prepend baseURL
+        url = input.startsWith("http")
+          ? input
+          : `${baseURL}${input.startsWith("/") ? input : `/${input}`}`;
+      } else if (input instanceof URL) {
+        url = input.toString();
+      } else if (input instanceof Request) {
+        url = input.url;
+      } else {
+        url = String(input);
+      }
+
+      // Handle body serialization
+      let processedBody = options?.body;
+      if (
+        processedBody &&
+        typeof processedBody === "object" &&
+        !(processedBody instanceof FormData) &&
+        !(processedBody instanceof URLSearchParams) &&
+        !(processedBody instanceof ReadableStream)
+      ) {
+        processedBody = JSON.stringify(processedBody);
+      }
+
+      // Merge headers
+      const headers = {
+        "Content-Type": "application/json",
+        ...authHeaders,
+        ...(options?.headers || {}),
+      };
+
+      const requestInit: RequestInit = {
+        ...options,
+        headers,
+        body: processedBody,
+      };
+
+      // Optional logging
+      if (args.logging === "verbose" || args.logging === true) {
+        betterAuthLogger.info(
+          "raw-fetch",
+          `${requestInit.method || "GET"} ${url}`,
+        );
+        if (requestInit.body) {
+          betterAuthLogger.info("raw-fetch", "Request body:", requestInit.body);
+        }
+      }
+
+      const response = await fetch(url, requestInit);
+
+      // Optional logging for response details
+      if (args.logging === "verbose" || args.logging === true) {
+        betterAuthLogger.info(
+          "raw-fetch",
+          `Response status: ${response.status} ${response.statusText}`,
+        );
+        betterAuthLogger.info(
+          "raw-fetch",
+          `Response headers:`,
+          Object.fromEntries(response.headers.entries()),
+        );
+      }
+
+      // Check if response is ok
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        if (args.logging === "verbose" || args.logging === true) {
+          betterAuthLogger.error(
+            "raw-fetch",
+            `HTTP Error ${response.status}: ${errorText}`,
+          );
+        }
+        return {
+          error: `HTTP ${response.status}: ${errorText}`,
+          response,
+        };
+      }
+
+      // Parse response based on content type
+      let responseData: any;
+      const contentType = response.headers.get("content-type");
+
+      if (args.logging === "verbose" || args.logging === true) {
+        betterAuthLogger.info(
+          "raw-fetch",
+          `Response content-type: ${contentType || "none"}`,
+        );
+      }
+
+      if (contentType?.includes("application/json")) {
+        try {
+          const responseText = await response.text();
+          if (args.logging === "verbose" || args.logging === true) {
+            betterAuthLogger.info(
+              "raw-fetch",
+              `Raw response text: "${responseText}"`,
+            );
+            betterAuthLogger.info(
+              "raw-fetch",
+              `Response text length: ${responseText.length}`,
+            );
+          }
+
+          // Handle empty responses
+          if (responseText.trim() === "") {
+            if (args.logging === "verbose" || args.logging === true) {
+              betterAuthLogger.info(
+                "raw-fetch",
+                "Empty JSON response, returning null",
+              );
+            }
+            responseData = null;
+          } else {
+            responseData = JSON.parse(responseText);
+            if (args.logging === "verbose" || args.logging === true) {
+              betterAuthLogger.info(
+                "raw-fetch",
+                "Successfully parsed JSON response",
+              );
+            }
+          }
+        } catch (parseError) {
+          if (args.logging === "verbose" || args.logging === true) {
+            betterAuthLogger.error(
+              "raw-fetch",
+              "JSON parse error:",
+              parseError,
+            );
+          }
+          return {
+            error: `Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : "Unknown parse error"}`,
+            response,
+          };
+        }
+      } else if (contentType?.includes("text/")) {
+        // Handle text responses (text/plain, text/html, etc.)
+        responseData = await response.text();
+        if (args.logging === "verbose" || args.logging === true) {
+          betterAuthLogger.info(
+            "raw-fetch",
+            `Text response: "${responseData}"`,
+          );
+        }
+      } else {
+        // For other content types, try to get text but don't fail if it's binary
+        try {
+          responseData = await response.text();
+          if (args.logging === "verbose" || args.logging === true) {
+            betterAuthLogger.info(
+              "raw-fetch",
+              `Unknown content-type response as text: "${responseData}"`,
+            );
+          }
+        } catch {
+          // If text parsing fails (e.g., binary data), return null
+          responseData = null;
+          if (args.logging === "verbose" || args.logging === true) {
+            betterAuthLogger.info(
+              "raw-fetch",
+              "Could not parse response as text, returning null",
+            );
+          }
+        }
+      }
+
+      // Validate output if schema provided
+      if (options?.output) {
+        const validation = options.output.safeParse(responseData);
+        if (validation.success) {
+          return {
+            data: validation.data,
+            response,
+          };
+        } else {
+          return {
+            error: `Validation failed: ${validation.error.message}`,
+            response,
+          };
+        }
+      }
+
+      // Return unvalidated data
+      return {
+        data: responseData as TOutput,
+        response,
+      };
+    } catch (error) {
+      return {
+        error:
+          error instanceof Error ? error.message : "Unknown error occurred",
+      };
+    }
+  };
+
+  return {
+    baseURL,
+    fetch: wrappedFetch,
+  };
 }