@proofkit/better-auth 0.3.0 → 0.3.1-beta.1

package/src/migrate.ts

@@ -1,13 +1,23 @@
-import { type BetterAuthDbSchema } from "better-auth/db";
-import { type Metadata } from "fm-odata-client";
+import type { DBFieldAttribute } from "better-auth/db";
 import chalk from "chalk";
+import type { Metadata } from "fm-odata-client";
 import z from "zod/v4";
-import { createRawFetch } from "./odata";
+import type { createRawFetch } from "./odata";
 
-export async function getMetadata(
-  fetch: ReturnType<typeof createRawFetch>["fetch"],
-  databaseName: string,
-) {
+/** Schema type returned by better-auth's getSchema function */
+type BetterAuthSchema = Record<string, { fields: Record<string, DBFieldAttribute>; order: number }>;
+
+function normalizeBetterAuthFieldType(fieldType: unknown): string {
+  if (typeof fieldType === "string") {
+    return fieldType;
+  }
+  if (Array.isArray(fieldType)) {
+    return fieldType.map(String).join("|");
+  }
+  return String(fieldType);
+}
+
+export async function getMetadata(fetch: ReturnType<typeof createRawFetch>["fetch"], databaseName: string) {
   console.log("getting metadata...");
   const result = await fetch("/$metadata", {
     method: "GET",
@@ -31,13 +41,13 @@ export async function getMetadata(
 
 export async function planMigration(
   fetch: ReturnType<typeof createRawFetch>["fetch"],
-  betterAuthSchema: BetterAuthDbSchema,
+  betterAuthSchema: BetterAuthSchema,
   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) {
@@ -52,27 +62,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;
         },
@@ -84,48 +99,34 @@ export async function planMigration(
     .sort((a, b) => (a[1].order ?? 0) - (b[1].order ?? 0))
     .map(([key, value]) => ({
       ...value,
-      keyName: key,
+      modelName: key, // Use the key as modelName since getSchema uses table names as keys
     }));
 
   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]) => {
+      // Better Auth's FieldType can be a string literal union or arrays.
+      // Normalize it to a string so our FM mapping logic remains stable.
+      // Use .includes() for all checks to handle array types like ["boolean", "null"] → "boolean|null"
+      const t = normalizeBetterAuthFieldType(field.type);
+      let type: "varchar" | "numeric" | "timestamp" = "varchar";
+      if (t.includes("boolean") || t.includes("number")) {
+        type = "numeric";
+      } else if (t.includes("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;
@@ -134,19 +135,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,
@@ -154,6 +150,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,
+        ],
+      });
     }
   }
 
@@ -176,10 +186,7 @@ export async function executeMigration(
       });
 
       if (result.error) {
-        console.error(
-          `Failed to create table ${step.tableName}:`,
-          result.error,
-        );
+        console.error(`Failed to create table ${step.tableName}:`, result.error);
         throw new Error(`Migration failed: ${result.error}`);
       }
     } else if (step.operation === "update") {
@@ -190,10 +197,7 @@ export async function executeMigration(
       });
 
       if (result.error) {
-        console.error(
-          `Failed to update table ${step.tableName}:`,
-          result.error,
-        );
+        console.error(`Failed to update table ${step.tableName}:`, result.error);
         throw new Error(`Migration failed: ${result.error}`);
       }
     }
@@ -274,8 +278,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,22 +1,23 @@
+/** 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";
-};
+}
 
 export function validateUrl(input: string): Result<URL, unknown> {
   try {
@@ -36,7 +37,7 @@ export function createRawFetch(args: FmOdataConfig) {
 
   let baseURL = result.value.origin;
   if ("apiKey" in args.auth) {
-    baseURL += `/otto`;
+    baseURL += "/otto";
   }
   baseURL += `/fmi/odata/v4/${args.database}`;
 
@@ -63,9 +64,7 @@ export function createRawFetch(args: FmOdataConfig) {
       // 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}`}`;
+        url = input.startsWith("http") ? input : `${baseURL}${input.startsWith("/") ? input : `/${input}`}`;
       } else if (input instanceof URL) {
         url = input.toString();
       } else if (input instanceof Request) {
@@ -101,10 +100,7 @@ export function createRawFetch(args: FmOdataConfig) {
 
       // Optional logging
       if (args.logging === "verbose" || args.logging === true) {
-        betterAuthLogger.info(
-          "raw-fetch",
-          `${requestInit.method || "GET"} ${url}`,
-        );
+        betterAuthLogger.info("raw-fetch", `${requestInit.method || "GET"} ${url}`);
         if (requestInit.body) {
           betterAuthLogger.info("raw-fetch", "Request body:", requestInit.body);
         }
@@ -114,25 +110,15 @@ export function createRawFetch(args: FmOdataConfig) {
 
       // 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()),
-        );
+        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}`,
-          );
+          betterAuthLogger.error("raw-fetch", `HTTP Error ${response.status}: ${errorText}`);
         }
         return {
           error: `HTTP ${response.status}: ${errorText}`,
@@ -145,51 +131,32 @@ export function createRawFetch(args: FmOdataConfig) {
       const contentType = response.headers.get("content-type");
 
       if (args.logging === "verbose" || args.logging === true) {
-        betterAuthLogger.info(
-          "raw-fetch",
-          `Response content-type: ${contentType || "none"}`,
-        );
+        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}`,
-            );
+            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",
-              );
+              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",
-              );
+              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,
-            );
+            betterAuthLogger.error("raw-fetch", "JSON parse error:", parseError);
           }
           return {
             error: `Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : "Unknown parse error"}`,
@@ -200,29 +167,20 @@ export function createRawFetch(args: FmOdataConfig) {
         // 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}"`,
-          );
+          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}"`,
-            );
+            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",
-            );
+            betterAuthLogger.info("raw-fetch", "Could not parse response as text, returning null");
           }
         }
       }
@@ -235,12 +193,11 @@ export function createRawFetch(args: FmOdataConfig) {
             data: validation.data,
             response,
           };
-        } else {
-          return {
-            error: `Validation failed: ${validation.error.message}`,
-            response,
-          };
         }
+        return {
+          error: `Validation failed: ${validation.error.message}`,
+          response,
+        };
       }
 
       // Return unvalidated data
@@ -250,8 +207,7 @@ export function createRawFetch(args: FmOdataConfig) {
       };
     } catch (error) {
       return {
-        error:
-          error instanceof Error ? error.message : "Unknown error occurred",
+        error: error instanceof Error ? error.message : "Unknown error occurred",
       };
     }
   };