@proofkit/better-auth 0.2.4 → 0.3.1-beta.0

package/src/better-auth-cli/utils/get-tsconfig-info.ts

@@ -1,26 +1,18 @@
-import path from "path";
+import path from "node:path";
 import fs from "fs-extra";
 
 export function stripJsonComments(jsonString: string): string {
-	return jsonString
-		.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) =>
-			g ? "" : m,
-		)
-		.replace(/,(?=\s*[}\]])/g, "");
+  return jsonString
+    .replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => (g ? "" : m))
+    .replace(/,(?=\s*[}\]])/g, "");
 }
 export function getTsconfigInfo(cwd?: string, flatPath?: string) {
-	let tsConfigPath: string;
-	if (flatPath) {
-		tsConfigPath = flatPath;
-	} else {
-		tsConfigPath = cwd
-			? path.join(cwd, "tsconfig.json")
-			: path.join("tsconfig.json");
-	}
-	try {
-		const text = fs.readFileSync(tsConfigPath, "utf-8");
-		return JSON.parse(stripJsonComments(text));
-	} catch (error) {
-		throw error;
-	}
+  let tsConfigPath: string;
+  if (flatPath) {
+    tsConfigPath = flatPath;
+  } else {
+    tsConfigPath = cwd ? path.join(cwd, "tsconfig.json") : path.join("tsconfig.json");
+  }
+  const text = fs.readFileSync(tsConfigPath, "utf-8");
+  return JSON.parse(stripJsonComments(text));
 }

package/src/cli/index.ts

@@ -1,19 +1,14 @@
 #!/usr/bin/env node --no-warnings
 import { Command } from "@commander-js/extra-typings";
-import fs from "fs-extra";
-
-import {
-  executeMigration,
-  planMigration,
-  prettyPrintMigrationPlan,
-} from "../migrate";
-import { getAdapter, getAuthTables } from "better-auth/db";
-import { getConfig } from "../better-auth-cli/utils/get-config";
 import { logger } from "better-auth";
-import prompts from "prompts";
+import { getAdapter, getAuthTables } from "better-auth/db";
 import chalk from "chalk";
-import { AdapterOptions } from "../adapter";
-import { createFmOdataFetch } from "../odata";
+import fs from "fs-extra";
+import prompts from "prompts";
+import type { AdapterOptions } 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() {
@@ -21,11 +16,7 @@ async function main() {
 
   program
     .command("migrate", { isDefault: true })
-    .option(
-      "--cwd <path>",
-      "Path to the current working directory",
-      process.cwd(),
-    )
+    .option("--cwd <path>", "Path to the current working directory", process.cwd())
     .option("--config <path>", "Path to the config file")
     .option("-u, --username <username>", "Full Access Username")
     .option("-p, --password <password>", "Full Access Password")
@@ -55,16 +46,14 @@ async function main() {
       });
 
       if (adapter.id !== "filemaker") {
-        logger.error(
-          "This generator is only compatible with the FileMaker adapter.",
-        );
+        logger.error("This generator is only compatible with the FileMaker adapter.");
         return;
       }
 
       const betterAuthSchema = getAuthTables(config);
 
       const adapterConfig = (adapter.options as AdapterOptions).config;
-      const fetch = createFmOdataFetch({
+      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.
@@ -74,13 +63,10 @@ async function main() {
                 password: options.password,
               }
             : adapterConfig.odata.auth,
+        logging: "verbose", // Enable logging for CLI operations
       });
 
-      const migrationPlan = await planMigration(
-        fetch,
-        betterAuthSchema,
-        adapterConfig.odata.database,
-      );
+      const migrationPlan = await planMigration(fetch, betterAuthSchema, adapterConfig.odata.database);
 
       if (migrationPlan.length === 0) {
         logger.info("No changes to apply. Database is up to date.");
@@ -91,11 +77,7 @@ async function main() {
         prettyPrintMigrationPlan(migrationPlan);
 
         if (migrationPlan.length > 0) {
-          console.log(
-            chalk.gray(
-              "💡 Tip: You can use the --yes flag to skip this confirmation.",
-            ),
-          );
+          console.log(chalk.gray("💡 Tip: You can use the --yes flag to skip this confirmation."));
         }
 
         const { confirm } = await prompts({

package/src/index.ts

@@ -1 +1,2 @@
+/** biome-ignore-all lint/performance/noBarrelFile: But I want to */
 export { FileMakerAdapter } from "./adapter";

package/src/migrate.ts

@@ -1,13 +1,10 @@
-import { type BetterAuthDbSchema } from "better-auth/db";
-import { type Metadata } from "fm-odata-client";
+import type { BetterAuthDbSchema } from "better-auth/db";
 import chalk from "chalk";
+import type { Metadata } from "fm-odata-client";
 import z from "zod/v4";
-import { createFmOdataFetch } from "./odata";
+import type { createRawFetch } from "./odata";
 
-export async function getMetadata(
-  fetch: ReturnType<typeof createFmOdataFetch>,
-  databaseName: string,
-) {
+export async function getMetadata(fetch: ReturnType<typeof createRawFetch>["fetch"], databaseName: string) {
   console.log("getting metadata...");
   const result = await fetch("/$metadata", {
     method: "GET",
@@ -21,18 +18,23 @@ 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> {
   const metadata = await getMetadata(fetch, databaseName);
 
   // Build a map from entity set name to entity type key
-  let entitySetToType: Record<string, string> = {};
+  const entitySetToType: Record<string, string> = {};
   if (metadata) {
     for (const [key, value] of Object.entries(metadata)) {
       if (value.$Kind === "EntitySet" && value.$Type) {
@@ -47,27 +49,32 @@ export async function planMigration(
     ? Object.entries(entitySetToType).reduce(
         (acc, [entitySetName, entityTypeKey]) => {
           const entityType = metadata[entityTypeKey];
-          if (!entityType) return acc;
+          if (!entityType) {
+            return acc;
+          }
           const fields = Object.entries(entityType)
             .filter(
-              ([fieldKey, fieldValue]) =>
-                typeof fieldValue === "object" &&
-                fieldValue !== null &&
-                "$Type" in fieldValue,
+              ([_fieldKey, fieldValue]) =>
+                typeof fieldValue === "object" && fieldValue !== null && "$Type" in fieldValue,
             )
-            .map(([fieldKey, fieldValue]) => ({
-              name: fieldKey,
-              type:
-                fieldValue.$Type === "Edm.String"
-                  ? "varchar"
-                  : fieldValue.$Type === "Edm.DateTimeOffset"
-                    ? "timestamp"
-                    : fieldValue.$Type === "Edm.Decimal" ||
-                        fieldValue.$Type === "Edm.Int32" ||
-                        fieldValue.$Type === "Edm.Int64"
-                      ? "numeric"
-                      : "varchar",
-            }));
+            .map(([fieldKey, fieldValue]) => {
+              let type = "varchar";
+              if (fieldValue.$Type === "Edm.String") {
+                type = "varchar";
+              } else if (fieldValue.$Type === "Edm.DateTimeOffset") {
+                type = "timestamp";
+              } else if (
+                fieldValue.$Type === "Edm.Decimal" ||
+                fieldValue.$Type === "Edm.Int32" ||
+                fieldValue.$Type === "Edm.Int64"
+              ) {
+                type = "numeric";
+              }
+              return {
+                name: fieldKey,
+                type,
+              };
+            });
           acc[entitySetName] = fields;
           return acc;
         },
@@ -85,42 +92,24 @@ export async function planMigration(
   const migrationPlan: MigrationPlan = [];
 
   for (const baTable of baTables) {
-    const fields: FmField[] = Object.entries(baTable.fields).map(
-      ([key, field]) => ({
+    const fields: FmField[] = Object.entries(baTable.fields).map(([key, field]) => {
+      let type: "varchar" | "numeric" | "timestamp" = "varchar";
+      if (field.type === "boolean" || field.type.includes("number")) {
+        type = "numeric";
+      } else if (field.type === "date") {
+        type = "timestamp";
+      }
+      return {
         name: field.fieldName ?? key,
-        type:
-          field.type === "boolean" || field.type.includes("number")
-            ? "numeric"
-            : field.type === "date"
-              ? "timestamp"
-              : "varchar",
-      }),
-    );
+        type,
+      };
+    });
 
     // get existing table or create it
-    const tableExists = Object.prototype.hasOwnProperty.call(
-      existingTables,
-      baTable.modelName,
-    );
+    const tableExists = baTable.modelName in existingTables;
 
-    if (!tableExists) {
-      migrationPlan.push({
-        tableName: baTable.modelName,
-        operation: "create",
-        fields: [
-          {
-            name: "id",
-            type: "varchar",
-            primary: true,
-            unique: true,
-          },
-          ...fields,
-        ],
-      });
-    } else {
-      const existingFields = (existingTables[baTable.modelName] || []).map(
-        (f) => f.name,
-      );
+    if (tableExists) {
+      const existingFields = (existingTables[baTable.modelName] || []).map((f) => f.name);
       const existingFieldMap = (existingTables[baTable.modelName] || []).reduce(
         (acc, f) => {
           acc[f.name] = f.type;
@@ -129,19 +118,14 @@ export async function planMigration(
         {} as Record<string, string>,
       );
       // Warn about type mismatches (optional, not in plan)
-      fields.forEach((field) => {
-        if (
-          existingFields.includes(field.name) &&
-          existingFieldMap[field.name] !== field.type
-        ) {
+      for (const field of fields) {
+        if (existingFields.includes(field.name) && existingFieldMap[field.name] !== field.type) {
           console.warn(
             `⚠️ WARNING: Field '${field.name}' in table '${baTable.modelName}' exists but has type '${existingFieldMap[field.name]}' (expected '${field.type}'). Change the field type in FileMaker to avoid potential errors.`,
           );
         }
-      });
-      const fieldsToAdd = fields.filter(
-        (f) => !existingFields.includes(f.name),
-      );
+      }
+      const fieldsToAdd = fields.filter((f) => !existingFields.includes(f.name));
       if (fieldsToAdd.length > 0) {
         migrationPlan.push({
           tableName: baTable.modelName,
@@ -149,6 +133,20 @@ export async function planMigration(
           fields: fieldsToAdd,
         });
       }
+    } else {
+      migrationPlan.push({
+        tableName: baTable.modelName,
+        operation: "create",
+        fields: [
+          {
+            name: "id",
+            type: "varchar",
+            primary: true,
+            unique: true,
+          },
+          ...fields,
+        ],
+      });
     }
   }
 
@@ -156,24 +154,35 @@ 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}`);
+      }
     }
   }
 }
@@ -252,8 +261,12 @@ export function prettyPrintMigrationPlan(migrationPlan: MigrationPlan) {
     if (step.fields.length) {
       for (const field of step.fields) {
         let fieldDesc = `    - ${field.name} (${field.type}`;
-        if (field.primary) fieldDesc += ", primary";
-        if (field.unique) fieldDesc += ", unique";
+        if (field.primary) {
+          fieldDesc += ", primary";
+        }
+        if (field.unique) {
+          fieldDesc += ", unique";
+        }
         fieldDesc += ")";
         console.log(fieldDesc);
       }

package/src/odata/index.ts

@@ -1,102 +1,219 @@
-import { createFetch, createSchema } from "@better-fetch/fetch";
-import { logger } from "@better-fetch/logger";
+/** biome-ignore-all lint/suspicious/noExplicitAny: library code */
 import { logger as betterAuthLogger } from "better-auth";
-import { err, ok, Result } from "neverthrow";
-import { z } from "zod/v4";
+import { err, ok, type Result } from "neverthrow";
+import type { z } from "zod/v4";
 
-type BasicAuthCredentials = {
+interface BasicAuthCredentials {
   username: string;
   password: string;
-};
-type OttoAPIKeyAuth = {
+}
+interface OttoAPIKeyAuth {
   apiKey: string;
-};
+}
 type ODataAuth = BasicAuthCredentials | OttoAPIKeyAuth;
 
-export type FmOdataConfig = {
+export interface FmOdataConfig {
   serverUrl: string;
   auth: ODataAuth;
   database: string;
   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 += "/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,
+          };
+        }
+        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,
+  };
 }