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

package/src/adapter.ts

@@ -1,21 +1,16 @@
-import {
-  CleanedWhere,
-  createAdapter,
-  type AdapterDebugLogs,
-} from "better-auth/adapters";
-import { createFmOdataFetch, type FmOdataConfig } from "./odata";
-import { prettifyError, z } from "zod/v4";
+/** biome-ignore-all lint/suspicious/noExplicitAny: library code */
 import { logger } from "better-auth";
+import { type AdapterDebugLogs, type CleanedWhere, createAdapter } from "better-auth/adapters";
+import buildQuery from "odata-query";
+import { prettifyError, z } from "zod/v4";
+import { createRawFetch, type FmOdataConfig } from "./odata";
 
 const configSchema = z.object({
   debugLogs: z.unknown().optional(),
   usePlural: z.boolean().optional(),
   odata: z.object({
     serverUrl: z.url(),
-    auth: z.union([
-      z.object({ username: z.string(), password: z.string() }),
-      z.object({ apiKey: z.string() }),
-    ]),
+    auth: z.union([z.object({ username: z.string(), password: z.string() }), z.object({ apiKey: z.string() })]),
     database: z.string().endsWith(".fmp12"),
   }),
 });
@@ -36,9 +31,9 @@ interface FileMakerAdapterConfig {
   odata: FmOdataConfig;
 }
 
-export type AdapterOptions = {
+export interface AdapterOptions {
   config: FileMakerAdapterConfig;
-};
+}
 
 const defaultConfig: Required<FileMakerAdapterConfig> = {
   debugLogs: false,
@@ -50,6 +45,10 @@ const defaultConfig: Required<FileMakerAdapterConfig> = {
   },
 };
 
+// Regex patterns for field validation and ISO date detection
+const FIELD_SPECIAL_CHARS_REGEX = /[\s_]/;
+const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+
 /**
  * Parse the where clause to an OData filter string.
  * @param where - The where clause to parse.
@@ -57,29 +56,42 @@ const defaultConfig: Required<FileMakerAdapterConfig> = {
  * @internal
  */
 export function parseWhere(where?: CleanedWhere[]): string {
-  if (!where || where.length === 0) return "";
+  if (!where || where.length === 0) {
+    return "";
+  }
 
   // Helper to quote field names with special chars or if field is 'id'
   function quoteField(field: string, value?: any) {
     // Never quote for null or date values (per test expectations)
-    if (value === null || value instanceof Date) return field;
+    if (value === null || value instanceof Date) {
+      return field;
+    }
     // Always quote if field is 'id' or has space or underscore
-    if (field === "id" || /[\s_]/.test(field)) return `"${field}"`;
+    if (field === "id" || FIELD_SPECIAL_CHARS_REGEX.test(field)) {
+      return `"${field}"`;
+    }
     return field;
   }
 
   // Helper to format values for OData
   function formatValue(value: any): string {
-    if (value === null) return "null";
-    if (typeof value === "boolean") return value ? "true" : "false";
-    if (value instanceof Date) return value.toISOString();
-    if (Array.isArray(value)) return `(${value.map(formatValue).join(",")})`;
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+      return `(${value.map(formatValue).join(",")})`;
+    }
 
     // Handle strings - check if it's an ISO date string first
     if (typeof value === "string") {
       // Check if it's an ISO date string (YYYY-MM-DDTHH:mm:ss.sssZ format)
-      const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
-      if (isoDateRegex.test(value)) {
+      if (ISO_DATE_REGEX.test(value)) {
         return value; // Return ISO date strings without quotes
       }
       return `'${value.replace(/'/g, "''")}'`; // Regular strings get quotes
@@ -102,7 +114,9 @@ export function parseWhere(where?: CleanedWhere[]): string {
   const clauses: string[] = [];
   for (let i = 0; i < where.length; i++) {
     const cond = where[i];
-    if (!cond) continue;
+    if (!cond) {
+      continue;
+    }
     const field = quoteField(cond.field, cond.value);
     let clause = "";
     switch (cond.operator) {
@@ -112,13 +126,11 @@ export function parseWhere(where?: CleanedWhere[]): string {
       case "lte":
       case "gt":
       case "gte":
-        clause = `${field} ${opMap[cond.operator!]} ${formatValue(cond.value)}`;
+        clause = `${field} ${opMap[cond.operator]} ${formatValue(cond.value)}`;
         break;
       case "in":
         if (Array.isArray(cond.value)) {
-          clause = cond.value
-            .map((v) => `${field} eq ${formatValue(v)}`)
-            .join(" or ");
+          clause = cond.value.map((v) => `${field} eq ${formatValue(v)}`).join(" or ");
           clause = `(${clause})`;
         }
         break;
@@ -143,9 +155,7 @@ export function parseWhere(where?: CleanedWhere[]): string {
   return clauses.join(" ");
 }
 
-export const FileMakerAdapter = (
-  _config: FileMakerAdapterConfig = defaultConfig,
-) => {
+export const FileMakerAdapter = (_config: FileMakerAdapterConfig = defaultConfig) => {
   const parsed = configSchema.loose().safeParse(_config);
 
   if (!parsed.success) {
@@ -153,7 +163,7 @@ export const FileMakerAdapter = (
   }
   const config = parsed.data;
 
-  const fetch = createFmOdataFetch({
+  const { fetch } = createRawFetch({
     ...config.odata,
     logging: config.debugLogs ? "verbose" : "none",
   });
@@ -169,10 +179,9 @@ export const FileMakerAdapter = (
       supportsBooleans: false, // Whether the database supports booleans. (Default: true)
       supportsNumericIds: false, // Whether the database supports auto-incrementing numeric IDs. (Default: true)
     },
-    adapter: ({ options }) => {
+    adapter: () => {
       return {
-        options: { config },
-        create: async ({ data, model, select }) => {
+        create: async ({ data, model }) => {
           if (model === "session") {
             console.log("session", data);
           }
@@ -192,114 +201,183 @@ export const FileMakerAdapter = (
         count: async ({ model, where }) => {
           const filter = parseWhere(where);
           logger.debug("$filter", filter);
-          const result = await fetch(`/${model}/$count`, {
+
+          const query = buildQuery({
+            filter: filter.length > 0 ? filter : undefined,
+          });
+
+          const result = await fetch(`/${model}/$count${query}`, {
             method: "GET",
-            query: {
-              $filter: filter,
-            },
             output: z.object({ value: z.number() }),
           });
           if (!result.data) {
             throw new Error("Failed to count records");
           }
-          return result.data?.value ?? 0;
+          return (result.data?.value as any) ?? 0;
         },
         findOne: async ({ model, where }) => {
           const filter = parseWhere(where);
           logger.debug("$filter", filter);
-          const result = await fetch(`/${model}`, {
+
+          const query = buildQuery({
+            top: 1,
+            filter: filter.length > 0 ? filter : undefined,
+          });
+
+          const result = await fetch(`/${model}${query}`, {
             method: "GET",
-            query: {
-              ...(filter.length > 0 ? { $filter: filter } : {}),
-              $top: 1,
-            },
             output: z.object({ value: z.array(z.any()) }),
           });
           if (result.error) {
             throw new Error("Failed to find record");
           }
-          return result.data?.value?.[0] ?? null;
+          return (result.data?.value?.[0] as any) ?? null;
         },
         findMany: async ({ model, where, limit, offset, sortBy }) => {
           const filter = parseWhere(where);
-          logger.debug("$filter", filter);
+          logger.debug("FIND MANY", { where, filter });
 
-          const rows = await fetch(`/${model}`, {
+          const query = buildQuery({
+            top: limit,
+            skip: offset,
+            orderBy: sortBy ? `${sortBy.field} ${sortBy.direction ?? "asc"}` : undefined,
+            filter: filter.length > 0 ? filter : undefined,
+          });
+          logger.debug("QUERY", query);
+
+          const result = await fetch(`/${model}${query}`, {
             method: "GET",
-            query: {
-              ...(filter.length > 0 ? { $filter: filter } : {}),
-              $top: limit,
-              $skip: offset,
-              ...(sortBy
-                ? { $orderby: `"${sortBy.field}" ${sortBy.direction ?? "asc"}` }
-                : {}),
-            },
             output: z.object({ value: z.array(z.any()) }),
           });
-          if (rows.error) {
+          logger.debug("RESULT", result);
+
+          if (result.error) {
             throw new Error("Failed to find records");
           }
-          return rows.data?.value ?? [];
+
+          return (result.data?.value as any) ?? [];
         },
         delete: async ({ model, where }) => {
           const filter = parseWhere(where);
+          console.log("DELETE", { model, where, filter });
           logger.debug("$filter", filter);
-          console.log("delete", model, where, filter);
-          const result = await fetch(`/${model}`, {
+
+          // Find a single id matching the filter
+          const query = buildQuery({
+            top: 1,
+            select: [`"id"`],
+            filter: filter.length > 0 ? filter : undefined,
+          });
+
+          const toDelete = await fetch(`/${model}${query}`, {
+            method: "GET",
+            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
+          });
+
+          const id = toDelete.data?.value?.[0]?.id;
+          if (!id) {
+            // Nothing to delete
+            return;
+          }
+
+          const result = await fetch(`/${model}('${id}')`, {
             method: "DELETE",
-            query: {
-              ...(where.length > 0 ? { $filter: filter } : {}),
-              $top: 1,
-            },
           });
           if (result.error) {
+            console.log("DELETE ERROR", result.error);
             throw new Error("Failed to delete record");
           }
         },
         deleteMany: async ({ model, where }) => {
           const filter = parseWhere(where);
-          logger.debug(
-            where
-              .map((o) => `typeof ${o.value} is ${typeof o.value}`)
-              .join("\n"),
-          );
-          logger.debug("$filter", filter);
+          console.log("DELETE MANY", { model, where, filter });
 
-          const result = await fetch(`/${model}/$count`, {
-            method: "DELETE",
-            query: {
-              ...(where.length > 0 ? { $filter: filter } : {}),
-            },
-            output: z.coerce.number(),
+          // Find all ids matching the filter
+          const query = buildQuery({
+            select: [`"id"`],
+            filter: filter.length > 0 ? filter : undefined,
           });
-          if (result.error) {
-            throw new Error("Failed to delete record");
+
+          const rows = await fetch(`/${model}${query}`, {
+            method: "GET",
+            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
+          });
+
+          const ids = rows.data?.value?.map((r: any) => r.id) ?? [];
+          let deleted = 0;
+          for (const id of ids) {
+            const res = await fetch(`/${model}('${id}')`, {
+              method: "DELETE",
+            });
+            if (!res.error) {
+              deleted++;
+            }
           }
-          return result.data ?? 0;
+          return deleted;
         },
         update: async ({ model, where, update }) => {
-          const result = await fetch(`/${model}`, {
+          const filter = parseWhere(where);
+          logger.debug("UPDATE", { model, where, update });
+          logger.debug("$filter", filter);
+          // Find one id to update
+          const query = buildQuery({
+            select: [`"id"`],
+            filter: filter.length > 0 ? filter : undefined,
+          });
+
+          const existing = await fetch(`/${model}${query}`, {
+            method: "GET",
+            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
+          });
+          logger.debug("EXISTING", existing.data);
+
+          const id = existing.data?.value?.[0]?.id;
+          if (!id) {
+            return null;
+          }
+
+          const patchRes = await fetch(`/${model}('${id}')`, {
             method: "PATCH",
-            query: {
-              ...(where.length > 0 ? { $filter: parseWhere(where) } : {}),
-              $top: 1,
-              $select: [`"id"`],
-            },
             body: update,
-            output: z.object({ value: z.array(z.any()) }),
           });
-          return result.data?.value?.[0] ?? null;
+          logger.debug("PATCH RES", patchRes.data);
+          if (patchRes.error) {
+            return null;
+          }
+
+          // Read back the updated record
+          const readBack = await fetch(`/${model}('${id}')`, {
+            method: "GET",
+            output: z.record(z.string(), z.unknown()),
+          });
+          logger.debug("READ BACK", readBack.data);
+          return (readBack.data as any) ?? null;
         },
         updateMany: async ({ model, where, update }) => {
           const filter = parseWhere(where);
-          const result = await fetch(`/${model}`, {
-            method: "PATCH",
-            query: {
-              ...(where.length > 0 ? { $filter: filter } : {}),
-            },
-            body: update,
+          // Find all ids matching the filter
+          const query = buildQuery({
+            select: [`"id"`],
+            filter: filter.length > 0 ? filter : undefined,
           });
-          return result.data as any;
+
+          const rows = await fetch(`/${model}${query}`, {
+            method: "GET",
+            output: z.object({ value: z.array(z.object({ id: z.string() })) }),
+          });
+
+          const ids = rows.data?.value?.map((r: any) => r.id) ?? [];
+          let updated = 0;
+          for (const id of ids) {
+            const res = await fetch(`/${model}('${id}')`, {
+              method: "PATCH",
+              body: update,
+            });
+            if (!res.error) {
+              updated++;
+            }
+          }
+          return updated as any;
         },
       };
     },

package/src/better-auth-cli/utils/add-svelte-kit-env-modules.ts

@@ -1,108 +1,96 @@
 export function addSvelteKitEnvModules(aliases: Record<string, string>) {
-	aliases["$env/dynamic/private"] = createDataUriModule(
-		createDynamicEnvModule(),
-	);
-	aliases["$env/dynamic/public"] = createDataUriModule(
-		createDynamicEnvModule(),
-	);
-	aliases["$env/static/private"] = createDataUriModule(
-		createStaticEnvModule(filterPrivateEnv("PUBLIC_", "")),
-	);
-	aliases["$env/static/public"] = createDataUriModule(
-		createStaticEnvModule(filterPublicEnv("PUBLIC_", "")),
-	);
+  aliases["$env/dynamic/private"] = createDataUriModule(createDynamicEnvModule());
+  aliases["$env/dynamic/public"] = createDataUriModule(createDynamicEnvModule());
+  aliases["$env/static/private"] = createDataUriModule(createStaticEnvModule(filterPrivateEnv("PUBLIC_", "")));
+  aliases["$env/static/public"] = createDataUriModule(createStaticEnvModule(filterPublicEnv("PUBLIC_", "")));
 }
 
 function createDataUriModule(module: string) {
-	return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
+  return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
 }
 
 function createStaticEnvModule(env: Record<string, string>) {
-	const declarations = Object.keys(env)
-		.filter((k) => validIdentifier.test(k) && !reserved.has(k))
-		.map((k) => `export const ${k} = ${JSON.stringify(env[k])};`);
+  const declarations = Object.keys(env)
+    .filter((k) => validIdentifier.test(k) && !reserved.has(k))
+    .map((k) => `export const ${k} = ${JSON.stringify(env[k])};`);
 
-	return `
+  return `
   ${declarations.join("\n")}
   // jiti dirty hack: .unknown
   `;
 }
 
 function createDynamicEnvModule() {
-	return `
+  return `
   export const env = process.env;
   // jiti dirty hack: .unknown
   `;
 }
 
 export function filterPrivateEnv(publicPrefix: string, privatePrefix: string) {
-	return Object.fromEntries(
-		Object.entries(process.env).filter(
-			([k]) =>
-				k.startsWith(privatePrefix) &&
-				(publicPrefix === "" || !k.startsWith(publicPrefix)),
-		),
-	) as Record<string, string>;
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([k]) => k.startsWith(privatePrefix) && (publicPrefix === "" || !k.startsWith(publicPrefix)),
+    ),
+  ) as Record<string, string>;
 }
 
 export function filterPublicEnv(publicPrefix: string, privatePrefix: string) {
-	return Object.fromEntries(
-		Object.entries(process.env).filter(
-			([k]) =>
-				k.startsWith(publicPrefix) &&
-				(privatePrefix === "" || !k.startsWith(privatePrefix)),
-		),
-	) as Record<string, string>;
+  return Object.fromEntries(
+    Object.entries(process.env).filter(
+      ([k]) => k.startsWith(publicPrefix) && (privatePrefix === "" || !k.startsWith(privatePrefix)),
+    ),
+  ) as Record<string, string>;
 }
 
 const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 const reserved = new Set([
-	"do",
-	"if",
-	"in",
-	"for",
-	"let",
-	"new",
-	"try",
-	"var",
-	"case",
-	"else",
-	"enum",
-	"eval",
-	"null",
-	"this",
-	"true",
-	"void",
-	"with",
-	"await",
-	"break",
-	"catch",
-	"class",
-	"const",
-	"false",
-	"super",
-	"throw",
-	"while",
-	"yield",
-	"delete",
-	"export",
-	"import",
-	"public",
-	"return",
-	"static",
-	"switch",
-	"typeof",
-	"default",
-	"extends",
-	"finally",
-	"package",
-	"private",
-	"continue",
-	"debugger",
-	"function",
-	"arguments",
-	"interface",
-	"protected",
-	"implements",
-	"instanceof",
+  "do",
+  "if",
+  "in",
+  "for",
+  "let",
+  "new",
+  "try",
+  "var",
+  "case",
+  "else",
+  "enum",
+  "eval",
+  "null",
+  "this",
+  "true",
+  "void",
+  "with",
+  "await",
+  "break",
+  "catch",
+  "class",
+  "const",
+  "false",
+  "super",
+  "throw",
+  "while",
+  "yield",
+  "delete",
+  "export",
+  "import",
+  "public",
+  "return",
+  "static",
+  "switch",
+  "typeof",
+  "default",
+  "extends",
+  "finally",
+  "package",
+  "private",
+  "continue",
+  "debugger",
+  "function",
+  "arguments",
+  "interface",
+  "protected",
+  "implements",
+  "instanceof",
 ]);

package/src/better-auth-cli/utils/get-config.ts

@@ -1,24 +1,16 @@
-import { loadConfig } from "c12";
-import type { BetterAuthOptions } from "better-auth";
-import { logger } from "better-auth";
-import path from "path";
-// @ts-expect-error not typed
-import babelPresetTypeScript from "@babel/preset-typescript";
+import fs, { existsSync } from "node:fs";
+import path from "node:path";
 // @ts-expect-error not typed
 import babelPresetReact from "@babel/preset-react";
-import fs, { existsSync } from "fs";
-import { BetterAuthError } from "better-auth";
+// @ts-expect-error not typed
+import babelPresetTypeScript from "@babel/preset-typescript";
+import type { BetterAuthOptions } from "better-auth";
+import { BetterAuthError, logger } from "better-auth";
+import { loadConfig } from "c12";
 import { addSvelteKitEnvModules } from "./add-svelte-kit-env-modules";
 import { getTsconfigInfo } from "./get-tsconfig-info";
 
-let possiblePaths = [
-  "auth.ts",
-  "auth.tsx",
-  "auth.js",
-  "auth.jsx",
-  "auth.server.js",
-  "auth.server.ts",
-];
+let possiblePaths = ["auth.ts", "auth.tsx", "auth.js", "auth.jsx", "auth.server.js", "auth.server.ts"];
 
 possiblePaths = [
   ...possiblePaths,
@@ -47,10 +39,7 @@ function getPathAliases(cwd: string): Record<string, string> | null {
       for (const aliasedPath of aliasPaths) {
         const resolvedBaseUrl = path.join(cwd, baseUrl);
         const finalAlias = alias.slice(-1) === "*" ? alias.slice(0, -1) : alias;
-        const finalAliasedPath =
-          aliasedPath.slice(-1) === "*"
-            ? aliasedPath.slice(0, -1)
-            : aliasedPath;
+        const finalAliasedPath = aliasedPath.slice(-1) === "*" ? aliasedPath.slice(0, -1) : aliasedPath;
 
         result[finalAlias || ""] = path.join(resolvedBaseUrl, finalAliasedPath);
       }
@@ -99,7 +88,9 @@ export async function getConfig({
     let configFile: BetterAuthOptions | null = null;
     if (configPath) {
       let resolvedPath: string = path.join(cwd, configPath);
-      if (existsSync(configPath)) resolvedPath = configPath; // If the configPath is a file, use it as is, as it means the path wasn't relative.
+      if (existsSync(configPath)) {
+        resolvedPath = configPath; // If the configPath is a file, use it as is, as it means the path wasn't relative.
+      }
       const { config } = await loadConfig<{
         auth: {
           options: BetterAuthOptions;
@@ -112,7 +103,7 @@ export async function getConfig({
         dotenv: true,
         jitiOptions: jitiOptions(cwd),
       });
-      if (!config.auth && !config.default) {
+      if (!(config.auth || config.default)) {
         if (shouldThrowOnError) {
           throw new Error(
             `Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`,
@@ -142,8 +133,7 @@ export async function getConfig({
           });
           const hasConfig = Object.keys(config).length > 0;
           if (hasConfig) {
-            configFile =
-              config.auth?.options || config.default?.options || null;
+            configFile = config.auth?.options || config.default?.options || null;
             if (!configFile) {
               if (shouldThrowOnError) {
                 throw new Error(
@@ -165,9 +155,7 @@ export async function getConfig({
             e &&
             "message" in e &&
             typeof e.message === "string" &&
-            e.message.includes(
-              "This module cannot be imported from a Client Component module",
-            )
+            e.message.includes("This module cannot be imported from a Client Component module")
           ) {
             if (shouldThrowOnError) {
               throw new Error(
@@ -194,9 +182,7 @@ export async function getConfig({
       e &&
       "message" in e &&
       typeof e.message === "string" &&
-      e.message.includes(
-        "This module cannot be imported from a Client Component module",
-      )
+      e.message.includes("This module cannot be imported from a Client Component module")
     ) {
       if (shouldThrowOnError) {
         throw new Error(