@proofkit/fmdapi 5.0.3-beta.0 → 5.1.0-beta.2

package/src/adapters/fetch-base.ts

@@ -24,32 +24,28 @@ import type {
   ListOptions,
   UpdateOptions,
 } from "./core.js";
-import type {
-  BaseFetchAdapterOptions,
-  GetTokenArguments,
-} from "./fetch-base-types.js";
+import type { BaseFetchAdapterOptions, GetTokenArguments } from "./fetch-base-types.js";
 
 export class BaseFetchAdapter implements Adapter {
   protected server: string;
   protected db: string;
-  private refreshToken: boolean;
+  private readonly refreshToken: boolean;
   baseUrl: URL;
 
   constructor(options: BaseFetchAdapterOptions & { refreshToken?: boolean }) {
     this.server = options.server;
     this.db = options.db;
     this.refreshToken = options.refreshToken ?? false;
-    this.baseUrl = new URL(
-      `${this.server}/fmi/data/vLatest/databases/${this.db}`,
-    );
+    this.baseUrl = new URL(`${this.server}/fmi/data/vLatest/databases/${this.db}`);
 
-    if (this.db === "") throw new Error("Database name is required");
+    if (this.db === "") {
+      throw new Error("Database name is required");
+    }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected getToken = async (args?: GetTokenArguments): Promise<string> => {
+  protected getToken = (_args?: GetTokenArguments): Promise<string> => {
     // method must be implemented in subclass
-    throw new Error("getToken method not implemented by Fetch Adapter");
+    return Promise.reject(new Error("getToken method not implemented by Fetch Adapter"));
   };
 
   protected request = async (params: {
@@ -62,29 +58,20 @@ export class BaseFetchAdapter implements Adapter {
     timeout?: number;
     fetchOptions?: RequestInit;
   }): Promise<unknown> => {
-    const {
-      query,
-      body,
-      method = "GET",
-      retry = false,
-      fetchOptions = {},
-    } = params;
+    const { query, body, method = "GET", retry = false, fetchOptions = {} } = params;
 
     const url = new URL(`${this.baseUrl}${params.url}`);
 
     if (query) {
       const { _sort, ...rest } = query;
-      const searchParams = new URLSearchParams(rest);
+      // Filter out undefined/null values before creating URLSearchParams
+      const filteredRest = Object.fromEntries(Object.entries(rest).filter(([, v]) => v !== undefined && v !== null));
+      const searchParams = new URLSearchParams(filteredRest as Record<string, string>);
       if (query.portalRanges && typeof query.portalRanges === "object") {
-        for (const [portalName, value] of Object.entries(
-          query.portalRanges as PortalRanges,
-        )) {
+        for (const [portalName, value] of Object.entries(query.portalRanges as PortalRanges)) {
           if (value) {
             if (value.offset && value.offset > 0) {
-              searchParams.set(
-                `_offset.${portalName}`,
-                value.offset.toString(),
-              );
+              searchParams.set(`_offset.${portalName}`, value.offset.toString());
             }
             if (value.limit) {
               searchParams.set(`_limit.${portalName}`, value.limit.toString());
@@ -100,31 +87,24 @@ export class BaseFetchAdapter implements Adapter {
     }
 
     if (body && "portalRanges" in body) {
-      for (const [portalName, value] of Object.entries(
-        body.portalRanges as PortalRanges,
-      )) {
+      for (const [portalName, value] of Object.entries(body.portalRanges as PortalRanges)) {
         if (value) {
           if (value.offset && value.offset > 0) {
-            url.searchParams.set(
-              `_offset.${portalName}`,
-              value.offset.toString(),
-            );
+            url.searchParams.set(`_offset.${portalName}`, value.offset.toString());
           }
           if (value.limit) {
-            url.searchParams.set(
-              `_limit.${portalName}`,
-              value.limit.toString(),
-            );
+            url.searchParams.set(`_limit.${portalName}`, value.limit.toString());
           }
         }
       }
-      delete body.portalRanges;
+      body.portalRanges = undefined;
     }
 
     const controller = new AbortController();
     let timeout: NodeJS.Timeout | null = null;
-    if (params.timeout)
+    if (params.timeout) {
       timeout = setTimeout(() => controller.abort(), params.timeout);
+    }
 
     const token = await this.getToken({ refresh: retry });
 
@@ -136,22 +116,26 @@ export class BaseFetchAdapter implements Adapter {
       headers.set("Content-Type", "application/json");
     }
 
+    let requestBody: string | FormData | undefined;
+    if (body instanceof FormData) {
+      requestBody = body;
+    } else if (body) {
+      requestBody = JSON.stringify(body);
+    } else {
+      requestBody = undefined;
+    }
+
     const res = await fetch(url.toString(), {
       ...fetchOptions,
       method,
-      body:
-        body instanceof FormData
-          ? body
-          : body
-            ? JSON.stringify(body)
-            : undefined,
+      body: requestBody,
       headers,
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
       signal: controller.signal,
     });
 
-    if (timeout) clearTimeout(timeout);
+    if (timeout) {
+      clearTimeout(timeout);
+    }
 
     let respData: RawFMResponse;
     try {
@@ -161,29 +145,20 @@ export class BaseFetchAdapter implements Adapter {
     }
 
     if (!res.ok) {
-      if (
-        respData?.messages?.[0].code === "952" &&
-        !retry &&
-        this.refreshToken
-      ) {
+      if (respData?.messages?.[0].code === "952" && !retry && this.refreshToken) {
         // token expired, get new token and retry once
         return this.request({ ...params, retry: true });
-      } else {
-        throw new FileMakerError(
-          respData?.messages?.[0].code ?? "500",
-          `Filemaker Data API failed with (${res.status}): ${JSON.stringify(
-            respData,
-            null,
-            2,
-          )}`,
-        );
       }
+      throw new FileMakerError(
+        respData?.messages?.[0].code ?? "500",
+        `Filemaker Data API failed with (${res.status}): ${JSON.stringify(respData, null, 2)}`,
+      );
     }
 
     return respData.response;
   };
 
-  public list = async (opts: ListOptions): Promise<GetResponse> => {
+  list = async (opts: ListOptions): Promise<GetResponse> => {
     const { data, layout } = opts;
 
     const resp = await this.request({
@@ -195,7 +170,7 @@ export class BaseFetchAdapter implements Adapter {
     return resp as GetResponse;
   };
 
-  public get = async (opts: GetOptions): Promise<GetResponse> => {
+  get = async (opts: GetOptions): Promise<GetResponse> => {
     const { data, layout } = opts;
     const resp = await this.request({
       url: `/layouts/${layout}/records/${data.recordId}`,
@@ -205,7 +180,7 @@ export class BaseFetchAdapter implements Adapter {
     return resp as GetResponse;
   };
 
-  public find = async (opts: FindOptions): Promise<GetResponse> => {
+  find = async (opts: FindOptions): Promise<GetResponse> => {
     const { data, layout } = opts;
     const resp = await this.request({
       url: `/layouts/${layout}/_find`,
@@ -217,7 +192,7 @@ export class BaseFetchAdapter implements Adapter {
     return resp as GetResponse;
   };
 
-  public create = async (opts: CreateOptions): Promise<CreateResponse> => {
+  create = async (opts: CreateOptions): Promise<CreateResponse> => {
     const { data, layout } = opts;
     const resp = await this.request({
       url: `/layouts/${layout}/records`,
@@ -229,7 +204,7 @@ export class BaseFetchAdapter implements Adapter {
     return resp as CreateResponse;
   };
 
-  public update = async (opts: UpdateOptions): Promise<UpdateResponse> => {
+  update = async (opts: UpdateOptions): Promise<UpdateResponse> => {
     const {
       data: { recordId, ...data },
       layout,
@@ -244,7 +219,7 @@ export class BaseFetchAdapter implements Adapter {
     return resp as UpdateResponse;
   };
 
-  public delete = async (opts: DeleteOptions): Promise<DeleteResponse> => {
+  delete = async (opts: DeleteOptions): Promise<DeleteResponse> => {
     const { data, layout } = opts;
     const resp = await this.request({
       url: `/layouts/${layout}/records/${data.recordId}`,
@@ -255,9 +230,7 @@ export class BaseFetchAdapter implements Adapter {
     return resp as DeleteResponse;
   };
 
-  public layoutMetadata = async (
-    opts: LayoutMetadataOptions,
-  ): Promise<LayoutMetadataResponse> => {
+  layoutMetadata = async (opts: LayoutMetadataOptions): Promise<LayoutMetadataResponse> => {
     return (await this.request({
       url: `/layouts/${opts.layout}`,
       fetchOptions: opts.fetch,
@@ -268,7 +241,7 @@ export class BaseFetchAdapter implements Adapter {
   /**
    * Execute a script within the database
    */
-  public executeScript = async (opts: ExecuteScriptOptions) => {
+  executeScript = async (opts: ExecuteScriptOptions) => {
     const { script, scriptParam, layout } = opts;
     const resp = await this.request({
       url: `/layouts/${layout}/script/${script}`,
@@ -282,7 +255,7 @@ export class BaseFetchAdapter implements Adapter {
   /**
    * Returns a list of available layouts on the database.
    */
-  public layouts = async (opts?: Omit<BaseRequest, "layout">) => {
+  layouts = async (opts?: Omit<BaseRequest, "layout">) => {
     return (await this.request({
       url: "/layouts",
       fetchOptions: opts?.fetch,
@@ -293,7 +266,7 @@ export class BaseFetchAdapter implements Adapter {
   /**
    * Returns a list of available scripts on the database.
    */
-  public scripts = async (opts?: Omit<BaseRequest, "layout">) => {
+  scripts = async (opts?: Omit<BaseRequest, "layout">) => {
     return (await this.request({
       url: "/scripts",
       fetchOptions: opts?.fetch,
@@ -301,9 +274,11 @@ export class BaseFetchAdapter implements Adapter {
     })) as ScriptsMetadataResponse;
   };
 
-  public containerUpload = async (opts: ContainerUploadOptions) => {
+  containerUpload = async (opts: ContainerUploadOptions) => {
     let url = `/layouts/${opts.layout}/records/${opts.data.recordId}/containers/${opts.data.containerFieldName}`;
-    if (opts.data.repetition) url += `/${opts.data.repetition}`;
+    if (opts.data.repetition) {
+      url += `/${opts.data.repetition}`;
+    }
     const formData = new FormData();
     formData.append("upload", opts.data.file);
 
@@ -319,7 +294,7 @@ export class BaseFetchAdapter implements Adapter {
   /**
    * Set global fields for the current session
    */
-  public globals = async (
+  globals = async (
     opts: Omit<BaseRequest, "layout"> & {
       globalFields: Record<string, string | number>;
     },

package/src/adapters/fetch.ts

@@ -1,11 +1,8 @@
 import { FileMakerError } from "../client-types.js";
 import memoryStore from "../tokenStore/memory.js";
 import type { TokenStoreDefinitions } from "../tokenStore/types.js";
-import type {
-  BaseFetchAdapterOptions,
-  GetTokenArguments,
-} from "./fetch-base-types.js";
 import { BaseFetchAdapter } from "./fetch-base.js";
+import type { BaseFetchAdapterOptions, GetTokenArguments } from "./fetch-base-types.js";
 
 export interface FetchAdapterOptions extends BaseFetchAdapterOptions {
   auth: {
@@ -16,21 +13,24 @@ export interface FetchAdapterOptions extends BaseFetchAdapterOptions {
 }
 
 export class FetchAdapter extends BaseFetchAdapter {
-  private username: string;
-  private password: string;
-  private tokenStore: Omit<TokenStoreDefinitions, "getKey">;
-  private getTokenKey: Required<TokenStoreDefinitions>["getKey"];
+  private readonly username: string;
+  private readonly password: string;
+  private readonly tokenStore: Omit<TokenStoreDefinitions, "getKey">;
+  private readonly getTokenKey: Required<TokenStoreDefinitions>["getKey"];
 
   constructor(args: FetchAdapterOptions) {
     super({ ...args, refreshToken: true });
     this.username = args.auth.username;
     this.password = args.auth.password;
     this.tokenStore = args.tokenStore ?? memoryStore();
-    this.getTokenKey =
-      args.tokenStore?.getKey ?? (() => `${args.server}/${args.db}`);
+    this.getTokenKey = args.tokenStore?.getKey ?? (() => `${args.server}/${args.db}`);
 
-    if (this.username === "") throw new Error("Username is required");
-    if (this.password === "") throw new Error("Password is required");
+    if (this.username === "") {
+      throw new Error("Username is required");
+    }
+    if (this.password === "") {
+      throw new Error("Password is required");
+    }
   }
 
   /**
@@ -41,9 +41,7 @@ export class FetchAdapter extends BaseFetchAdapter {
    * @param args.refresh - If true, forces getting a new token instead of using cached token
    * @internal This method is intended for internal use, you should not need to use it in most cases.
    */
-  public override getToken = async (
-    args?: GetTokenArguments,
-  ): Promise<string> => {
+  override getToken = async (args?: GetTokenArguments): Promise<string> => {
     const { refresh = false } = args ?? {};
     let token: string | null = null;
     if (!refresh) {
@@ -55,28 +53,25 @@ export class FetchAdapter extends BaseFetchAdapter {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Basic ${Buffer.from(
-            `${this.username}:${this.password}`,
-          ).toString("base64")}`,
+          Authorization: `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`,
         },
       });
 
       if (!res.ok) {
         const data = await res.json();
-        throw new FileMakerError(
-          data.messages[0].code,
-          data.messages[0].message,
-        );
+        throw new FileMakerError(data.messages[0].code, data.messages[0].message);
       }
       token = res.headers.get("X-FM-Data-Access-Token");
-      if (!token) throw new Error("Could not get token");
+      if (!token) {
+        throw new Error("Could not get token");
+      }
       this.tokenStore.setToken(this.getTokenKey(), token);
     }
 
     return token;
   };
 
-  public disconnect = async (): Promise<void> => {
+  disconnect = async (): Promise<void> => {
     const token = await this.tokenStore.getToken(this.getTokenKey());
     if (token) {
       await this.request({

package/src/adapters/fm-http.ts

@@ -0,0 +1,224 @@
+import type {
+  CreateResponse,
+  DeleteResponse,
+  GetResponse,
+  LayoutMetadataResponse,
+  RawFMResponse,
+  ScriptResponse,
+  UpdateResponse,
+} from "../client-types.js";
+import { FileMakerError } from "../client-types.js";
+import type {
+  Adapter,
+  CreateOptions,
+  DeleteOptions,
+  ExecuteScriptOptions,
+  FindOptions,
+  GetOptions,
+  LayoutMetadataOptions,
+  ListOptions,
+  UpdateOptions,
+} from "./core.js";
+
+const TRAILING_SLASHES_REGEX = /\/+$/;
+
+export interface FmHttpAdapterOptions {
+  /** Base URL of the local FM HTTP server (e.g. "http://localhost:3000") */
+  baseUrl: string;
+  /** Name of the connected FileMaker file */
+  connectedFileName: string;
+  /** Name of the FM script that executes Data API calls. Defaults to "execute_data_api" */
+  scriptName?: string;
+}
+
+export class FmHttpAdapter implements Adapter {
+  protected baseUrl: string;
+  protected connectedFileName: string;
+  protected scriptName: string;
+
+  constructor(options: FmHttpAdapterOptions) {
+    this.baseUrl = options.baseUrl.replace(TRAILING_SLASHES_REGEX, "");
+    this.connectedFileName = options.connectedFileName;
+    this.scriptName = options.scriptName ?? "execute_data_api";
+  }
+
+  protected request = async (params: {
+    layout: string;
+    body: object;
+    action?: "read" | "metaData" | "create" | "update" | "delete";
+    timeout?: number;
+    fetchOptions?: RequestInit;
+  }): Promise<unknown> => {
+    const { action = "read", layout, body, fetchOptions = {} } = params;
+
+    // Normalize underscore-prefixed keys to match FM script expectations
+    const normalizedBody: Record<string, unknown> = { ...body } as Record<string, unknown>;
+    if ("_offset" in normalizedBody) {
+      normalizedBody.offset = normalizedBody._offset;
+      normalizedBody._offset = undefined;
+    }
+    if ("_limit" in normalizedBody) {
+      normalizedBody.limit = normalizedBody._limit;
+      normalizedBody._limit = undefined;
+    }
+    if ("_sort" in normalizedBody) {
+      normalizedBody.sort = normalizedBody._sort;
+      normalizedBody._sort = undefined;
+    }
+
+    const scriptParam = JSON.stringify({
+      ...normalizedBody,
+      layouts: layout,
+      action,
+      version: "vLatest",
+    });
+
+    const controller = new AbortController();
+    let timeout: NodeJS.Timeout | null = null;
+    if (params.timeout) {
+      timeout = setTimeout(() => controller.abort(), params.timeout);
+    }
+
+    const headers = new Headers(fetchOptions?.headers);
+    headers.set("Content-Type", "application/json");
+
+    let res: Response;
+    try {
+      res = await fetch(`${this.baseUrl}/callScript`, {
+        ...fetchOptions,
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          connectedFileName: this.connectedFileName,
+          scriptName: this.scriptName,
+          data: scriptParam,
+        }),
+        signal: controller.signal,
+      });
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+
+    if (!res.ok) {
+      throw new FileMakerError(String(res.status), `FM HTTP request failed (${res.status}): ${await res.text()}`);
+    }
+
+    const raw = await res.json();
+    // The /callScript response wraps the script result as a string or object
+    let scriptResult: unknown;
+    try {
+      scriptResult = typeof raw.result === "string" ? JSON.parse(raw.result) : (raw.result ?? raw);
+    } catch (err) {
+      throw new FileMakerError(
+        "500",
+        `FM HTTP response parse failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+
+    const respData = scriptResult as RawFMResponse;
+
+    const errorCode = respData.messages?.[0]?.code;
+    if (errorCode !== undefined && errorCode !== "0") {
+      throw new FileMakerError(
+        errorCode,
+        `Filemaker Data API failed with (${errorCode}): ${JSON.stringify(respData, null, 2)}`,
+      );
+    }
+
+    return respData.response;
+  };
+
+  list = async (opts: ListOptions): Promise<GetResponse> => {
+    return (await this.request({
+      body: opts.data,
+      layout: opts.layout,
+      timeout: opts.timeout,
+      fetchOptions: opts.fetch,
+    })) as GetResponse;
+  };
+
+  get = async (opts: GetOptions): Promise<GetResponse> => {
+    return (await this.request({
+      body: opts.data,
+      layout: opts.layout,
+      timeout: opts.timeout,
+      fetchOptions: opts.fetch,
+    })) as GetResponse;
+  };
+
+  find = async (opts: FindOptions): Promise<GetResponse> => {
+    return (await this.request({
+      body: opts.data,
+      layout: opts.layout,
+      timeout: opts.timeout,
+      fetchOptions: opts.fetch,
+    })) as GetResponse;
+  };
+
+  create = async (opts: CreateOptions): Promise<CreateResponse> => {
+    return (await this.request({
+      action: "create",
+      body: opts.data,
+      layout: opts.layout,
+      timeout: opts.timeout,
+      fetchOptions: opts.fetch,
+    })) as CreateResponse;
+  };
+
+  update = async (opts: UpdateOptions): Promise<UpdateResponse> => {
+    return (await this.request({
+      action: "update",
+      body: opts.data,
+      layout: opts.layout,
+      timeout: opts.timeout,
+      fetchOptions: opts.fetch,
+    })) as UpdateResponse;
+  };
+
+  delete = async (opts: DeleteOptions): Promise<DeleteResponse> => {
+    return (await this.request({
+      action: "delete",
+      body: opts.data,
+      layout: opts.layout,
+      timeout: opts.timeout,
+      fetchOptions: opts.fetch,
+    })) as DeleteResponse;
+  };
+
+  layoutMetadata = async (opts: LayoutMetadataOptions): Promise<LayoutMetadataResponse> => {
+    return (await this.request({
+      action: "metaData",
+      layout: opts.layout,
+      body: {},
+      timeout: opts.timeout,
+      fetchOptions: opts.fetch,
+    })) as LayoutMetadataResponse;
+  };
+
+  executeScript = async (opts: ExecuteScriptOptions): Promise<ScriptResponse> => {
+    const res = await fetch(`${this.baseUrl}/callScript`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        connectedFileName: this.connectedFileName,
+        scriptName: opts.script,
+        data: opts.scriptParam,
+      }),
+    });
+
+    if (!res.ok) {
+      throw new FileMakerError(String(res.status), `FM HTTP executeScript failed (${res.status}): ${await res.text()}`);
+    }
+
+    const raw = await res.json();
+    return {
+      scriptResult: typeof raw.result === "string" ? raw.result : JSON.stringify(raw.result),
+    } as ScriptResponse;
+  };
+
+  containerUpload = (): Promise<never> => {
+    throw new Error("Container upload is not supported via FM HTTP adapter");
+  };
+}

package/src/adapters/otto.ts

@@ -16,7 +16,9 @@ export function isOttoAPIKey(key: string): key is OttoAPIKey {
 }
 
 export function isOttoAuth(auth: unknown): auth is OttoAuth {
-  if (typeof auth !== "object" || auth === null) return false;
+  if (typeof auth !== "object" || auth === null) {
+    return false;
+  }
   return "apiKey" in auth;
 }
 
@@ -32,8 +34,8 @@ export type OttoAdapterOptions = BaseFetchAdapterOptions & {
 };
 
 export class OttoAdapter extends BaseFetchAdapter {
-  private apiKey: OttoAPIKey | Otto3APIKey;
-  private port: number | undefined;
+  private readonly apiKey: OttoAPIKey | Otto3APIKey;
+  private readonly port: number | undefined;
 
   constructor(options: OttoAdapterOptions) {
     super({ ...options, refreshToken: false });
@@ -47,13 +49,11 @@ export class OttoAdapter extends BaseFetchAdapter {
       // otto v4 uses default port, but with /otto prefix
       this.baseUrl.pathname = `otto/${this.baseUrl.pathname.replace(/^\/+|\/+$/g, "")}`;
     } else {
-      throw new Error(
-        "Invalid Otto API key format. Must start with 'KEY_' (Otto v3) or 'dk_' (OttoFMS)",
-      );
+      throw new Error("Invalid Otto API key format. Must start with 'KEY_' (Otto v3) or 'dk_' (OttoFMS)");
     }
   }
 
-  protected override getToken = async (): Promise<string> => {
-    return this.apiKey;
+  protected override getToken = (): Promise<string> => {
+    return Promise.resolve(this.apiKey);
   };
 }