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

package/src/migrate.ts

@@ -1,111 +1,103 @@
-import type { BetterAuthDbSchema } from "better-auth/db";
+import type { Database, Field, Metadata } from "@proofkit/fmodata";
+import { isFMODataError, isODataError } from "@proofkit/fmodata";
+import type { DBFieldAttribute } from "better-auth/db";
 import chalk from "chalk";
-import type { Metadata } from "fm-odata-client";
-import z from "zod/v4";
-import type { createRawFetch } from "./odata";
 
-export async function getMetadata(fetch: ReturnType<typeof createRawFetch>["fetch"], databaseName: string) {
-  console.log("getting metadata...");
-  const result = await fetch("/$metadata", {
-    method: "GET",
-    headers: { accept: "application/json" },
-    output: z
-      .looseObject({
-        $Version: z.string(),
-        "@ServerVersion": z.string(),
-      })
-      .or(z.null())
-      .catch(null),
-  });
+/** Schema type returned by better-auth's getSchema function */
+type BetterAuthSchema = Record<string, { fields: Record<string, DBFieldAttribute>; order: number }>;
 
-  if (result.error) {
-    console.error("Failed to get metadata:", result.error);
-    return null;
+function normalizeBetterAuthFieldType(fieldType: unknown): string {
+  if (typeof fieldType === "string") {
+    return fieldType;
   }
+  if (Array.isArray(fieldType)) {
+    return fieldType.map(String).join("|");
+  }
+  return String(fieldType);
+}
 
-  return (result.data?.[databaseName] ?? null) as Metadata | null;
+export async function getMetadata(db: Database): Promise<Metadata> {
+  const metadata = await db.getMetadata({ format: "json" });
+  return metadata;
+}
+
+/** Map a better-auth field type string to an fmodata Field type */
+function mapFieldType(t: string): "string" | "numeric" | "timestamp" {
+  if (t.includes("boolean") || t.includes("number")) {
+    return "numeric";
+  }
+  if (t.includes("date")) {
+    return "timestamp";
+  }
+  return "string";
 }
 
-export async function planMigration(
-  fetch: ReturnType<typeof createRawFetch>["fetch"],
-  betterAuthSchema: BetterAuthDbSchema,
-  databaseName: string,
-): Promise<MigrationPlan> {
-  const metadata = await getMetadata(fetch, databaseName);
+export async function planMigration(db: Database, betterAuthSchema: BetterAuthSchema): Promise<MigrationPlan> {
+  const metadata = await getMetadata(db);
 
   // Build a map from entity set name to entity type key
   const entitySetToType: Record<string, string> = {};
-  if (metadata) {
-    for (const [key, value] of Object.entries(metadata)) {
-      if (value.$Kind === "EntitySet" && value.$Type) {
-        // $Type is like 'betterauth_test.fmp12.proofkit_user_'
-        const typeKey = value.$Type.split(".").pop(); // e.g., 'proofkit_user_'
-        entitySetToType[key] = typeKey || key;
-      }
+  for (const [key, value] of Object.entries(metadata)) {
+    if (value.$Kind === "EntitySet" && value.$Type) {
+      // $Type is like 'betterauth_test.fmp12.proofkit_user_'
+      const typeKey = value.$Type.split(".").pop(); // e.g., 'proofkit_user_'
+      entitySetToType[key] = typeKey || key;
     }
   }
 
-  const existingTables = metadata
-    ? Object.entries(entitySetToType).reduce(
-        (acc, [entitySetName, entityTypeKey]) => {
-          const entityType = metadata[entityTypeKey];
-          if (!entityType) {
-            return acc;
+  const existingTables = Object.entries(entitySetToType).reduce(
+    (acc, [entitySetName, entityTypeKey]) => {
+      const entityType = metadata[entityTypeKey];
+      if (!entityType) {
+        return acc;
+      }
+      const fields = Object.entries(entityType)
+        .filter(
+          ([_fieldKey, fieldValue]) => typeof fieldValue === "object" && fieldValue !== null && "$Type" in fieldValue,
+        )
+        .map(([fieldKey, fieldValue]) => {
+          let type = "string";
+          if (fieldValue.$Type === "Edm.String") {
+            type = "string";
+          } else if (fieldValue.$Type === "Edm.DateTimeOffset") {
+            type = "timestamp";
+          } else if (
+            fieldValue.$Type === "Edm.Decimal" ||
+            fieldValue.$Type === "Edm.Int32" ||
+            fieldValue.$Type === "Edm.Int64"
+          ) {
+            type = "numeric";
           }
-          const fields = Object.entries(entityType)
-            .filter(
-              ([_fieldKey, fieldValue]) =>
-                typeof fieldValue === "object" && fieldValue !== null && "$Type" in fieldValue,
-            )
-            .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;
-        },
-        {} as Record<string, { name: string; type: string }[]>,
-      )
-    : {};
+          return {
+            name: fieldKey,
+            type,
+          };
+        });
+      acc[entitySetName] = fields;
+      return acc;
+    },
+    {} as Record<string, { name: string; type: string }[]>,
+  );
 
   const baTables = Object.entries(betterAuthSchema)
     .sort((a, b) => (a[1].order ?? 0) - (b[1].order ?? 0))
     .map(([key, value]) => ({
       ...value,
-      keyName: key,
+      modelName: key,
     }));
 
   const migrationPlan: MigrationPlan = [];
 
   for (const baTable of baTables) {
     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";
-      }
+      const t = normalizeBetterAuthFieldType(field.type);
+      const type = mapFieldType(t);
       return {
         name: field.fieldName ?? key,
         type,
       };
     });
 
-    // get existing table or create it
     const tableExists = baTable.modelName in existingTables;
 
     if (tableExists) {
@@ -117,7 +109,6 @@ export async function planMigration(
         },
         {} as Record<string, string>,
       );
-      // Warn about type mismatches (optional, not in plan)
       for (const field of fields) {
         if (existingFields.includes(field.name) && existingFieldMap[field.name] !== field.type) {
           console.warn(
@@ -140,7 +131,7 @@ export async function planMigration(
         fields: [
           {
             name: "id",
-            type: "varchar",
+            type: "string",
             primary: true,
             unique: true,
           },
@@ -153,106 +144,101 @@ export async function planMigration(
   return migrationPlan;
 }
 
-export async function executeMigration(
-  fetch: ReturnType<typeof createRawFetch>["fetch"],
-  migrationPlan: MigrationPlan,
-) {
+export async function executeMigration(db: Database, migrationPlan: MigrationPlan) {
   for (const step of migrationPlan) {
+    // Convert plan fields to fmodata Field type
+    const fmodataFields: Field[] = step.fields.map((f) => ({
+      name: f.name,
+      type: f.type,
+      ...(f.primary ? { primary: true } : {}),
+      ...(f.unique ? { unique: true } : {}),
+    }));
+
     if (step.operation === "create") {
       console.log("Creating table:", step.tableName);
-      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}`);
+      try {
+        await db.schema.createTable(step.tableName, fmodataFields);
+      } catch (error) {
+        throw migrationError("create", step.tableName, error);
       }
     } else if (step.operation === "update") {
       console.log("Adding fields to table:", 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}`);
+      try {
+        await db.schema.addFields(step.tableName, fmodataFields);
+      } catch (error) {
+        throw migrationError("update", step.tableName, error);
       }
     }
   }
 }
 
-const genericFieldSchema = z.object({
-  name: z.string(),
-  nullable: z.boolean().optional(),
-  primary: z.boolean().optional(),
-  unique: z.boolean().optional(),
-  global: z.boolean().optional(),
-  repetitions: z.number().optional(),
-});
-
-const stringFieldSchema = genericFieldSchema.extend({
-  type: z.literal("varchar"),
-  maxLength: z.number().optional(),
-  default: z.enum(["USER", "USERNAME", "CURRENT_USER"]).optional(),
-});
-
-const numericFieldSchema = genericFieldSchema.extend({
-  type: z.literal("numeric"),
-});
-
-const dateFieldSchema = genericFieldSchema.extend({
-  type: z.literal("date"),
-  default: z.enum(["CURRENT_DATE", "CURDATE"]).optional(),
-});
-
-const timeFieldSchema = genericFieldSchema.extend({
-  type: z.literal("time"),
-  default: z.enum(["CURRENT_TIME", "CURTIME"]).optional(),
-});
-
-const timestampFieldSchema = genericFieldSchema.extend({
-  type: z.literal("timestamp"),
-  default: z.enum(["CURRENT_TIMESTAMP", "CURTIMESTAMP"]).optional(),
-});
+interface FmField {
+  name: string;
+  type: "string" | "numeric" | "timestamp";
+  primary?: boolean;
+  unique?: boolean;
+}
 
-const containerFieldSchema = genericFieldSchema.extend({
-  type: z.literal("container"),
-  externalSecurePath: z.string().optional(),
-});
+const migrationStepTypes = ["create", "update"] as const;
+interface MigrationStep {
+  tableName: string;
+  operation: (typeof migrationStepTypes)[number];
+  fields: FmField[];
+}
 
-const fieldSchema = z.discriminatedUnion("type", [
-  stringFieldSchema,
-  numericFieldSchema,
-  dateFieldSchema,
-  timeFieldSchema,
-  timestampFieldSchema,
-  containerFieldSchema,
-]);
+export type MigrationPlan = MigrationStep[];
 
-type FmField = z.infer<typeof fieldSchema>;
+function formatError(error: unknown): string {
+  if (isODataError(error)) {
+    const code = error.code ? ` (${error.code})` : "";
+    return `${error.message}${code}`;
+  }
+  if (isFMODataError(error)) {
+    return error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
 
-const migrationPlanSchema = z
-  .object({
-    tableName: z.string(),
-    operation: z.enum(["create", "update"]),
-    fields: z.array(fieldSchema),
-  })
-  .array();
+function migrationError(operation: string, tableName: string, error: unknown): Error {
+  const action = operation === "create" ? "create table" : "update table";
+  const base = `Failed to ${action} "${tableName}"`;
 
-export type MigrationPlan = z.infer<typeof migrationPlanSchema>;
+  if (isODataError(error) && error.code === "207") {
+    console.error(
+      chalk.red(`\n${base}: Cannot modify schema.`),
+      chalk.yellow("\nThe account used does not have schema modification privileges."),
+      chalk.gray(
+        "\nUse --username and --password to provide Full Access credentials, or grant schema modification privileges to the current account.",
+      ),
+    );
+  } else {
+    console.error(chalk.red(`\n${base}:`), formatError(error));
+  }
+  return new Error(`Migration failed: ${formatError(error)}`);
+}
 
-export function prettyPrintMigrationPlan(migrationPlan: MigrationPlan) {
+export function prettyPrintMigrationPlan(
+  migrationPlan: MigrationPlan,
+  target?: { serverUrl?: string; fileName?: string },
+) {
   if (!migrationPlan.length) {
     console.log("No changes to apply. Database is up to date.");
     return;
   }
   console.log(chalk.bold.green("Migration plan:"));
+  if (target?.serverUrl || target?.fileName) {
+    const parts: string[] = [];
+    if (target.fileName) {
+      parts.push(chalk.cyan(target.fileName));
+    }
+    if (target.serverUrl) {
+      parts.push(chalk.gray(target.serverUrl));
+    }
+    console.log(`  Target: ${parts.join(" @ ")}`);
+  }
   for (const step of migrationPlan) {
     const emoji = step.operation === "create" ? "✅" : "✏️";
     console.log(

package/dist/esm/odata/index.d.ts

@@ -1,29 +0,0 @@
-import { Result } from 'neverthrow';
-import { z } from 'zod/v4';
-interface BasicAuthCredentials {
-    username: string;
-    password: string;
-}
-interface OttoAPIKeyAuth {
-    apiKey: string;
-}
-type ODataAuth = BasicAuthCredentials | OttoAPIKeyAuth;
-export interface FmOdataConfig {
-    serverUrl: string;
-    auth: ODataAuth;
-    database: string;
-    logging?: true | "verbose" | "none";
-}
-export declare function validateUrl(input: string): Result<URL, unknown>;
-export declare function createRawFetch(args: FmOdataConfig): {
-    baseURL: string;
-    fetch: <TOutput = any>(input: string | URL | Request, options?: Omit<RequestInit, "body"> & {
-        body?: any;
-        output?: z.ZodSchema<TOutput>;
-    }) => Promise<{
-        data?: TOutput;
-        error?: string;
-        response?: Response;
-    }>;
-};
-export {};

package/dist/esm/odata/index.js

@@ -1,157 +0,0 @@
-import { logger } from "better-auth";
-import { ok, err } from "neverthrow";
-function validateUrl(input) {
-  try {
-    const url = new URL(input);
-    return ok(url);
-  } catch (error) {
-    return err(error);
-  }
-}
-function createRawFetch(args) {
-  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}`;
-  const authHeaders = {};
-  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}`;
-  }
-  const wrappedFetch = async (input, options) => {
-    try {
-      let url;
-      if (typeof input === "string") {
-        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);
-      }
-      let processedBody = options == null ? void 0 : options.body;
-      if (processedBody && typeof processedBody === "object" && !(processedBody instanceof FormData) && !(processedBody instanceof URLSearchParams) && !(processedBody instanceof ReadableStream)) {
-        processedBody = JSON.stringify(processedBody);
-      }
-      const headers = {
-        "Content-Type": "application/json",
-        ...authHeaders,
-        ...(options == null ? void 0 : options.headers) || {}
-      };
-      const requestInit = {
-        ...options,
-        headers,
-        body: processedBody
-      };
-      if (args.logging === "verbose" || args.logging === true) {
-        logger.info("raw-fetch", `${requestInit.method || "GET"} ${url}`);
-        if (requestInit.body) {
-          logger.info("raw-fetch", "Request body:", requestInit.body);
-        }
-      }
-      const response = await fetch(url, requestInit);
-      if (args.logging === "verbose" || args.logging === true) {
-        logger.info("raw-fetch", `Response status: ${response.status} ${response.statusText}`);
-        logger.info("raw-fetch", "Response headers:", Object.fromEntries(response.headers.entries()));
-      }
-      if (!response.ok) {
-        const errorText = await response.text().catch(() => "Unknown error");
-        if (args.logging === "verbose" || args.logging === true) {
-          logger.error("raw-fetch", `HTTP Error ${response.status}: ${errorText}`);
-        }
-        return {
-          error: `HTTP ${response.status}: ${errorText}`,
-          response
-        };
-      }
-      let responseData;
-      const contentType = response.headers.get("content-type");
-      if (args.logging === "verbose" || args.logging === true) {
-        logger.info("raw-fetch", `Response content-type: ${contentType || "none"}`);
-      }
-      if (contentType == null ? void 0 : contentType.includes("application/json")) {
-        try {
-          const responseText = await response.text();
-          if (args.logging === "verbose" || args.logging === true) {
-            logger.info("raw-fetch", `Raw response text: "${responseText}"`);
-            logger.info("raw-fetch", `Response text length: ${responseText.length}`);
-          }
-          if (responseText.trim() === "") {
-            if (args.logging === "verbose" || args.logging === true) {
-              logger.info("raw-fetch", "Empty JSON response, returning null");
-            }
-            responseData = null;
-          } else {
-            responseData = JSON.parse(responseText);
-            if (args.logging === "verbose" || args.logging === true) {
-              logger.info("raw-fetch", "Successfully parsed JSON response");
-            }
-          }
-        } catch (parseError) {
-          if (args.logging === "verbose" || args.logging === true) {
-            logger.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 == null ? void 0 : contentType.includes("text/")) {
-        responseData = await response.text();
-        if (args.logging === "verbose" || args.logging === true) {
-          logger.info("raw-fetch", `Text response: "${responseData}"`);
-        }
-      } else {
-        try {
-          responseData = await response.text();
-          if (args.logging === "verbose" || args.logging === true) {
-            logger.info("raw-fetch", `Unknown content-type response as text: "${responseData}"`);
-          }
-        } catch {
-          responseData = null;
-          if (args.logging === "verbose" || args.logging === true) {
-            logger.info("raw-fetch", "Could not parse response as text, returning null");
-          }
-        }
-      }
-      if (options == null ? void 0 : 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 {
-        data: responseData,
-        response
-      };
-    } catch (error) {
-      return {
-        error: error instanceof Error ? error.message : "Unknown error occurred"
-      };
-    }
-  };
-  return {
-    baseURL,
-    fetch: wrappedFetch
-  };
-}
-export {
-  createRawFetch,
-  validateUrl
-};
-//# sourceMappingURL=index.js.map

package/dist/esm/odata/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../src/odata/index.ts"],"sourcesContent":["/** biome-ignore-all lint/suspicious/noExplicitAny: library code */\nimport { logger as betterAuthLogger } from \"better-auth\";\nimport { err, ok, type Result } from \"neverthrow\";\nimport type { z } from \"zod/v4\";\n\ninterface BasicAuthCredentials {\n  username: string;\n  password: string;\n}\ninterface OttoAPIKeyAuth {\n  apiKey: string;\n}\ntype ODataAuth = BasicAuthCredentials | OttoAPIKeyAuth;\n\nexport interface FmOdataConfig {\n  serverUrl: string;\n  auth: ODataAuth;\n  database: string;\n  logging?: true | \"verbose\" | \"none\";\n}\n\nexport function validateUrl(input: string): Result<URL, unknown> {\n  try {\n    const url = new URL(input);\n    return ok(url);\n  } catch (error) {\n    return err(error);\n  }\n}\n\nexport function createRawFetch(args: FmOdataConfig) {\n  const result = validateUrl(args.serverUrl);\n\n  if (result.isErr()) {\n    throw new Error(\"Invalid server URL\");\n  }\n\n  let baseURL = result.value.origin;\n  if (\"apiKey\" in args.auth) {\n    baseURL += \"/otto\";\n  }\n  baseURL += `/fmi/odata/v4/${args.database}`;\n\n  // Create authentication headers\n  const authHeaders: Record<string, string> = {};\n  if (\"apiKey\" in args.auth) {\n    authHeaders.Authorization = `Bearer ${args.auth.apiKey}`;\n  } else {\n    const credentials = btoa(`${args.auth.username}:${args.auth.password}`);\n    authHeaders.Authorization = `Basic ${credentials}`;\n  }\n\n  // Enhanced fetch function with body handling, validation, and structured responses\n  const wrappedFetch = async <TOutput = any>(\n    input: string | URL | Request,\n    options?: Omit<RequestInit, \"body\"> & {\n      body?: any; // Allow any type for body\n      output?: z.ZodSchema<TOutput>; // Optional schema for validation\n    },\n  ): Promise<{ data?: TOutput; error?: string; response?: Response }> => {\n    try {\n      let url: string;\n\n      // Handle different input types\n      if (typeof input === \"string\") {\n        // If it's already a full URL, use as-is, otherwise prepend baseURL\n        url = input.startsWith(\"http\") ? input : `${baseURL}${input.startsWith(\"/\") ? input : `/${input}`}`;\n      } else if (input instanceof URL) {\n        url = input.toString();\n      } else if (input instanceof Request) {\n        url = input.url;\n      } else {\n        url = String(input);\n      }\n\n      // Handle body serialization\n      let processedBody = options?.body;\n      if (\n        processedBody &&\n        typeof processedBody === \"object\" &&\n        !(processedBody instanceof FormData) &&\n        !(processedBody instanceof URLSearchParams) &&\n        !(processedBody instanceof ReadableStream)\n      ) {\n        processedBody = JSON.stringify(processedBody);\n      }\n\n      // Merge headers\n      const headers = {\n        \"Content-Type\": \"application/json\",\n        ...authHeaders,\n        ...(options?.headers || {}),\n      };\n\n      const requestInit: RequestInit = {\n        ...options,\n        headers,\n        body: processedBody,\n      };\n\n      // Optional logging\n      if (args.logging === \"verbose\" || args.logging === true) {\n        betterAuthLogger.info(\"raw-fetch\", `${requestInit.method || \"GET\"} ${url}`);\n        if (requestInit.body) {\n          betterAuthLogger.info(\"raw-fetch\", \"Request body:\", requestInit.body);\n        }\n      }\n\n      const response = await fetch(url, requestInit);\n\n      // Optional logging for response details\n      if (args.logging === \"verbose\" || args.logging === true) {\n        betterAuthLogger.info(\"raw-fetch\", `Response status: ${response.status} ${response.statusText}`);\n        betterAuthLogger.info(\"raw-fetch\", \"Response headers:\", Object.fromEntries(response.headers.entries()));\n      }\n\n      // Check if response is ok\n      if (!response.ok) {\n        const errorText = await response.text().catch(() => \"Unknown error\");\n        if (args.logging === \"verbose\" || args.logging === true) {\n          betterAuthLogger.error(\"raw-fetch\", `HTTP Error ${response.status}: ${errorText}`);\n        }\n        return {\n          error: `HTTP ${response.status}: ${errorText}`,\n          response,\n        };\n      }\n\n      // Parse response based on content type\n      let responseData: any;\n      const contentType = response.headers.get(\"content-type\");\n\n      if (args.logging === \"verbose\" || args.logging === true) {\n        betterAuthLogger.info(\"raw-fetch\", `Response content-type: ${contentType || \"none\"}`);\n      }\n\n      if (contentType?.includes(\"application/json\")) {\n        try {\n          const responseText = await response.text();\n          if (args.logging === \"verbose\" || args.logging === true) {\n            betterAuthLogger.info(\"raw-fetch\", `Raw response text: \"${responseText}\"`);\n            betterAuthLogger.info(\"raw-fetch\", `Response text length: ${responseText.length}`);\n          }\n\n          // Handle empty responses\n          if (responseText.trim() === \"\") {\n            if (args.logging === \"verbose\" || args.logging === true) {\n              betterAuthLogger.info(\"raw-fetch\", \"Empty JSON response, returning null\");\n            }\n            responseData = null;\n          } else {\n            responseData = JSON.parse(responseText);\n            if (args.logging === \"verbose\" || args.logging === true) {\n              betterAuthLogger.info(\"raw-fetch\", \"Successfully parsed JSON response\");\n            }\n          }\n        } catch (parseError) {\n          if (args.logging === \"verbose\" || args.logging === true) {\n            betterAuthLogger.error(\"raw-fetch\", \"JSON parse error:\", parseError);\n          }\n          return {\n            error: `Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : \"Unknown parse error\"}`,\n            response,\n          };\n        }\n      } else if (contentType?.includes(\"text/\")) {\n        // Handle text responses (text/plain, text/html, etc.)\n        responseData = await response.text();\n        if (args.logging === \"verbose\" || args.logging === true) {\n          betterAuthLogger.info(\"raw-fetch\", `Text response: \"${responseData}\"`);\n        }\n      } else {\n        // For other content types, try to get text but don't fail if it's binary\n        try {\n          responseData = await response.text();\n          if (args.logging === \"verbose\" || args.logging === true) {\n            betterAuthLogger.info(\"raw-fetch\", `Unknown content-type response as text: \"${responseData}\"`);\n          }\n        } catch {\n          // If text parsing fails (e.g., binary data), return null\n          responseData = null;\n          if (args.logging === \"verbose\" || args.logging === true) {\n            betterAuthLogger.info(\"raw-fetch\", \"Could not parse response as text, returning null\");\n          }\n        }\n      }\n\n      // Validate output if schema provided\n      if (options?.output) {\n        const validation = options.output.safeParse(responseData);\n        if (validation.success) {\n          return {\n            data: validation.data,\n            response,\n          };\n        }\n        return {\n          error: `Validation failed: ${validation.error.message}`,\n          response,\n        };\n      }\n\n      // Return unvalidated data\n      return {\n        data: responseData as TOutput,\n        response,\n      };\n    } catch (error) {\n      return {\n        error: error instanceof Error ? error.message : \"Unknown error occurred\",\n      };\n    }\n  };\n\n  return {\n    baseURL,\n    fetch: wrappedFetch,\n  };\n}\n"],"names":["betterAuthLogger"],"mappings":"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"}