@proofkit/better-auth 0.2.3 → 0.3.0

package/dist/esm/odata/index.js

@@ -1,36 +1,14 @@
-import { createSchema, createFetch } from "@better-fetch/fetch";
-import { logger } from "@better-fetch/logger";
-import { logger as logger$1 } from "better-auth";
+import { logger } from "better-auth";
 import { ok, err } from "neverthrow";
-import { z } from "zod/v4";
-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() })
+function validateUrl(input) {
+  try {
+    const url = new URL(input);
+    return ok(url);
+  } catch (error) {
+    return err(error);
   }
-});
-function createFmOdataFetch(args) {
+}
+function createRawFetch(args) {
   const result = validateUrl(args.serverUrl);
   if (result.isErr()) {
     throw new Error("Invalid server URL");
@@ -40,44 +18,182 @@ function createFmOdataFetch(args) {
     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));
-    },
-    schema,
-    plugins: [
-      logger({
-        verbose: args.logging === "verbose",
-        enabled: args.logging === "verbose" || !!args.logging,
-        console: {
-          fail: (...args2) => logger$1.error("better-fetch", ...args2),
-          success: (...args2) => logger$1.info("better-fetch", ...args2),
-          log: (...args2) => logger$1.info("better-fetch", ...args2),
-          error: (...args2) => logger$1.error("better-fetch", ...args2),
-          warn: (...args2) => logger$1.warn("better-fetch", ...args2)
-        }
-      })
-    ]
-  });
-}
-function validateUrl(input) {
-  try {
-    const url = new URL(input);
-    return ok(url);
-  } catch (error) {
-    return err(error);
+  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
+          };
+        } else {
+          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 {
-  createFmOdataFetch,
+  createRawFetch,
   validateUrl
 };
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/odata/index.ts"],"sourcesContent":["import { createFetch, createSchema } from \"@better-fetch/fetch\";\nimport { logger } from \"@better-fetch/logger\";\nimport { logger as betterAuthLogger } from \"better-auth\";\nimport { err, ok, Result } from \"neverthrow\";\nimport { z } from \"zod/v4\";\n\ntype BasicAuthCredentials = {\n  username: string;\n  password: string;\n};\ntype OttoAPIKeyAuth = {\n  apiKey: string;\n};\ntype ODataAuth = BasicAuthCredentials | OttoAPIKeyAuth;\n\nexport type FmOdataConfig = {\n  serverUrl: string;\n  auth: ODataAuth;\n  database: string;\n  logging?: true | \"verbose\" | \"none\";\n};\n\nconst schema = createSchema({\n  /**\n   * Create a new table\n   */\n  \"@post/FileMaker_Tables\": {\n    input: z.object({ tableName: z.string(), fields: z.array(z.any()) }),\n  },\n  /**\n   * Add fields to a table\n   */\n  \"@patch/FileMaker_Tables/:tableName\": {\n    params: z.object({ tableName: z.string() }),\n    input: z.object({ fields: z.array(z.any()) }),\n  },\n  /**\n   * Delete a table\n   */\n  \"@delete/FileMaker_Tables/:tableName\": {\n    params: z.object({ tableName: z.string() }),\n  },\n  /**\n   * Delete a field from a table\n   */\n  \"@delete/FileMaker_Tables/:tableName/:fieldName\": {\n    params: z.object({ tableName: z.string(), fieldName: z.string() }),\n  },\n});\n\nexport function createFmOdataFetch(args: FmOdataConfig) {\n  const result = validateUrl(args.serverUrl);\n\n  if (result.isErr()) {\n    throw new Error(\"Invalid server URL\");\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  return createFetch({\n    baseURL,\n    auth:\n      \"apiKey\" in args.auth\n        ? { type: \"Bearer\", token: args.auth.apiKey }\n        : {\n            type: \"Basic\",\n            username: args.auth.username,\n            password: args.auth.password,\n          },\n    onError: (error) => {\n      console.error(\"url\", error.request.url.toString());\n      console.log(error.error);\n      console.log(\"error.request.body\", JSON.stringify(error.request.body));\n    },\n    schema,\n    plugins: [\n      logger({\n        verbose: args.logging === \"verbose\",\n        enabled: args.logging === \"verbose\" || !!args.logging,\n        console: {\n          fail: (...args) => betterAuthLogger.error(\"better-fetch\", ...args),\n          success: (...args) => betterAuthLogger.info(\"better-fetch\", ...args),\n          log: (...args) => betterAuthLogger.info(\"better-fetch\", ...args),\n          error: (...args) => betterAuthLogger.error(\"better-fetch\", ...args),\n          warn: (...args) => betterAuthLogger.warn(\"better-fetch\", ...args),\n        },\n      }),\n    ],\n  });\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"],"names":["args","betterAuthLogger"],"mappings":";;;;;AAsBA,MAAM,SAAS,aAAa;AAAA;AAAA;AAAA;AAAA,EAI1B,0BAA0B;AAAA,IACxB,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,QAAQ,EAAE,MAAM,EAAE,IAAK,CAAA,EAAG,CAAA;AAAA,EACrE;AAAA;AAAA;AAAA;AAAA,EAIA,sCAAsC;AAAA,IACpC,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,OAAA,GAAU;AAAA,IAC1C,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAA,CAAK,EAAG,CAAA;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA,EAIA,uCAAuC;AAAA,IACrC,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,SAAU,CAAA;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA,EAIA,kDAAkD;AAAA,IAChD,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,WAAW,EAAE,SAAU,CAAA;AAAA,EAAA;AAErE,CAAC;AAEM,SAAS,mBAAmB,MAAqB;AAChD,QAAA,SAAS,YAAY,KAAK,SAAS;AAErC,MAAA,OAAO,SAAS;AACZ,UAAA,IAAI,MAAM,oBAAoB;AAAA,EAAA;AAElC,MAAA,UAAU,OAAO,MAAM;AACvB,MAAA,YAAY,KAAK,MAAM;AACd,eAAA;AAAA,EAAA;AAEF,aAAA,iBAAiB,KAAK,QAAQ;AAEzC,SAAO,YAAY;AAAA,IACjB;AAAA,IACA,MACE,YAAY,KAAK,OACb,EAAE,MAAM,UAAU,OAAO,KAAK,KAAK,OAAA,IACnC;AAAA,MACE,MAAM;AAAA,MACN,UAAU,KAAK,KAAK;AAAA,MACpB,UAAU,KAAK,KAAK;AAAA,IACtB;AAAA,IACN,SAAS,CAAC,UAAU;AAClB,cAAQ,MAAM,OAAO,MAAM,QAAQ,IAAI,UAAU;AACzC,cAAA,IAAI,MAAM,KAAK;AACvB,cAAQ,IAAI,sBAAsB,KAAK,UAAU,MAAM,QAAQ,IAAI,CAAC;AAAA,IACtE;AAAA,IACA;AAAA,IACA,SAAS;AAAA,MACP,OAAO;AAAA,QACL,SAAS,KAAK,YAAY;AAAA,QAC1B,SAAS,KAAK,YAAY,aAAa,CAAC,CAAC,KAAK;AAAA,QAC9C,SAAS;AAAA,UACP,MAAM,IAAIA,UAASC,SAAiB,MAAM,gBAAgB,GAAGD,KAAI;AAAA,UACjE,SAAS,IAAIA,UAASC,SAAiB,KAAK,gBAAgB,GAAGD,KAAI;AAAA,UACnE,KAAK,IAAIA,UAASC,SAAiB,KAAK,gBAAgB,GAAGD,KAAI;AAAA,UAC/D,OAAO,IAAIA,UAASC,SAAiB,MAAM,gBAAgB,GAAGD,KAAI;AAAA,UAClE,MAAM,IAAIA,UAASC,SAAiB,KAAK,gBAAgB,GAAGD,KAAI;AAAA,QAAA;AAAA,MAEnE,CAAA;AAAA,IAAA;AAAA,EACH,CACD;AACH;AAEO,SAAS,YAAY,OAAqC;AAC3D,MAAA;AACI,UAAA,MAAM,IAAI,IAAI,KAAK;AACzB,WAAO,GAAG,GAAG;AAAA,WACN,OAAO;AACd,WAAO,IAAI,KAAK;AAAA,EAAA;AAEpB;"}
+{"version":3,"file":"index.js","sources":["../../../src/odata/index.ts"],"sourcesContent":["import { logger as betterAuthLogger } from \"better-auth\";\nimport { err, ok, Result } from \"neverthrow\";\nimport { z } from \"zod/v4\";\n\ntype BasicAuthCredentials = {\n  username: string;\n  password: string;\n};\ntype OttoAPIKeyAuth = {\n  apiKey: string;\n};\ntype ODataAuth = BasicAuthCredentials | OttoAPIKeyAuth;\n\nexport type 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\")\n          ? input\n          : `${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(\n          \"raw-fetch\",\n          `${requestInit.method || \"GET\"} ${url}`,\n        );\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(\n          \"raw-fetch\",\n          `Response status: ${response.status} ${response.statusText}`,\n        );\n        betterAuthLogger.info(\n          \"raw-fetch\",\n          `Response headers:`,\n          Object.fromEntries(response.headers.entries()),\n        );\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(\n            \"raw-fetch\",\n            `HTTP Error ${response.status}: ${errorText}`,\n          );\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(\n          \"raw-fetch\",\n          `Response content-type: ${contentType || \"none\"}`,\n        );\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(\n              \"raw-fetch\",\n              `Raw response text: \"${responseText}\"`,\n            );\n            betterAuthLogger.info(\n              \"raw-fetch\",\n              `Response text length: ${responseText.length}`,\n            );\n          }\n\n          // Handle empty responses\n          if (responseText.trim() === \"\") {\n            if (args.logging === \"verbose\" || args.logging === true) {\n              betterAuthLogger.info(\n                \"raw-fetch\",\n                \"Empty JSON response, returning null\",\n              );\n            }\n            responseData = null;\n          } else {\n            responseData = JSON.parse(responseText);\n            if (args.logging === \"verbose\" || args.logging === true) {\n              betterAuthLogger.info(\n                \"raw-fetch\",\n                \"Successfully parsed JSON response\",\n              );\n            }\n          }\n        } catch (parseError) {\n          if (args.logging === \"verbose\" || args.logging === true) {\n            betterAuthLogger.error(\n              \"raw-fetch\",\n              \"JSON parse error:\",\n              parseError,\n            );\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(\n            \"raw-fetch\",\n            `Text response: \"${responseData}\"`,\n          );\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(\n              \"raw-fetch\",\n              `Unknown content-type response as text: \"${responseData}\"`,\n            );\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(\n              \"raw-fetch\",\n              \"Could not parse response as text, returning null\",\n            );\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        } else {\n          return {\n            error: `Validation failed: ${validation.error.message}`,\n            response,\n          };\n        }\n      }\n\n      // Return unvalidated data\n      return {\n        data: responseData as TOutput,\n        response,\n      };\n    } catch (error) {\n      return {\n        error:\n          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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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proofkit/better-auth",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "FileMaker adapter for Better Auth",
   "type": "module",
   "main": "dist/esm/index.js",
@@ -38,8 +38,6 @@
   "dependencies": {
     "@babel/preset-react": "^7.27.1",
     "@babel/preset-typescript": "^7.27.1",
-    "@better-fetch/fetch": "1.1.17",
-    "@better-fetch/logger": "^1.1.18",
     "@commander-js/extra-typings": "^14.0.0",
     "@tanstack/vite-config": "^0.2.0",
     "better-auth": "^1.2.10",
@@ -49,6 +47,7 @@
     "dotenv": "^16.5.0",
     "fs-extra": "^11.3.0",
     "neverthrow": "^8.2.0",
+    "odata-query": "^8.0.4",
     "prompts": "^2.4.2",
     "vite": "^6.3.4",
     "zod": "3.25.64"
@@ -56,10 +55,11 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/prompts": "^2.4.9",
+    "@vitest/ui": "^3.2.4",
     "fm-odata-client": "^3.0.1",
     "publint": "^0.3.12",
-    "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
   },
   "scripts": {
     "dev": "pnpm build:watch",

package/src/adapter.ts

@@ -3,9 +3,10 @@ import {
   createAdapter,
   type AdapterDebugLogs,
 } from "better-auth/adapters";
-import { createFmOdataFetch, type FmOdataConfig } from "./odata";
+import { createRawFetch, type FmOdataConfig } from "./odata";
 import { prettifyError, z } from "zod/v4";
 import { logger } from "better-auth";
+import buildQuery from "odata-query";
 
 const configSchema = z.object({
   debugLogs: z.unknown().optional(),
@@ -153,7 +154,7 @@ export const FileMakerAdapter = (
   }
   const config = parsed.data;
 
-  const fetch = createFmOdataFetch({
+  const { fetch, baseURL } = createRawFetch({
     ...config.odata,
     logging: config.debugLogs ? "verbose" : "none",
   });
@@ -192,114 +193,177 @@ 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 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 rows = await fetch(`/${model}`, {
+          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/cli/index.ts

@@ -13,7 +13,8 @@ import { logger } from "better-auth";
 import prompts from "prompts";
 import chalk from "chalk";
 import { AdapterOptions } from "../adapter";
-import { createFmOdataFetch } from "../odata";
+import { createRawFetch } from "../odata";
+import "dotenv/config";
 
 async function main() {
   const program = new Command();
@@ -63,7 +64,7 @@ async function main() {
       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.
@@ -73,6 +74,7 @@ async function main() {
                 password: options.password,
               }
             : adapterConfig.odata.auth,
+        logging: "verbose", // Enable logging for CLI operations
       });
 
       const migrationPlan = await planMigration(