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

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, getAuthTables } from "better-auth/db";
+import { getSchema } from "better-auth/db";
 import chalk from "chalk";
 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() {
@@ -40,33 +40,87 @@ async function main() {
         return;
       }
 
-      const adapter = await getAdapter(config).catch((e) => {
-        logger.error(e.message);
+      // Resolve adapter directly (getAdapter removed in Better Auth 1.5)
+      const databaseFactory = config.database;
+      if (!databaseFactory || typeof databaseFactory !== "function") {
+        logger.error("No database adapter found in auth config.");
         process.exit(1);
-      });
+      }
+      let adapter: { id?: string; database?: unknown };
+      try {
+        adapter = (databaseFactory as (opts: unknown) => { id?: string; database?: unknown })(config);
+      } catch (e) {
+        logger.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+      }
 
-      if (adapter.id !== "filemaker") {
+      if (adapter?.id !== "filemaker") {
         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 } = 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
-      });
+      const betterAuthSchema = getSchema(config);
+
+      // 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);
+        }
 
-      const migrationPlan = await planMigration(fetch, betterAuthSchema, adapterConfig.odata.database);
+        if (!baseUrl) {
+          logger.error(
+            "Could not determine server URL from adapter config. Ensure your auth.ts uses FMServerConnection.",
+          );
+          process.exit(1);
+        }
+
+        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 +128,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 +145,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);
+});

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 {};