@proofkit/fmodata 0.1.0-alpha.0

package/src/client/filemaker-odata.ts

@@ -0,0 +1,119 @@
+import createClient, { FFetchOptions } from "@fetchkit/ffetch";
+import type { Auth, ExecutionContext } from "../types";
+import { Database } from "./database";
+import { TableOccurrence } from "./table-occurrence";
+
+export class FileMakerOData implements ExecutionContext {
+  private fetchClient: ReturnType<typeof createClient>;
+  private serverUrl: string;
+  private auth: Auth;
+  constructor(config: {
+    serverUrl: string;
+    auth: Auth;
+    fetchClientOptions?: FFetchOptions;
+  }) {
+    this.fetchClient = createClient({
+      retries: 0,
+      ...config.fetchClientOptions,
+    });
+    // Ensure the URL uses https://, is valid, and has no trailing slash
+    const url = new URL(config.serverUrl);
+    if (url.protocol !== "https:") {
+      url.protocol = "https:";
+    }
+    // Remove any trailing slash from pathname
+    url.pathname = url.pathname.replace(/\/+$/, "");
+    this.serverUrl = url.toString().replace(/\/+$/, "");
+    this.auth = config.auth;
+  }
+
+  /**
+   * @internal
+   */
+  async _makeRequest<T>(
+    url: string,
+    options?: RequestInit & FFetchOptions,
+  ): Promise<T> {
+    const baseUrl = `${this.serverUrl}${"apiKey" in this.auth ? `/otto` : ""}/fmi/odata/v4`;
+
+    const headers = {
+      Authorization:
+        "apiKey" in this.auth
+          ? `Bearer ${this.auth.apiKey}`
+          : `Basic ${btoa(`${this.auth.username}:${this.auth.password}`)}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...(options?.headers || {}),
+    };
+
+    // TEMPORARY WORKAROUND: Hopefully this feature will be fixed in the ffetch library
+    // Extract fetchHandler and headers separately, only for tests where we're overriding the fetch handler per-request
+    const fetchHandler = options?.fetchHandler;
+    const {
+      headers: _headers,
+      fetchHandler: _fetchHandler,
+      ...restOptions
+    } = options || {};
+
+    // If fetchHandler is provided, create a temporary client with it
+    // Otherwise use the existing client
+    const clientToUse = fetchHandler
+      ? createClient({ retries: 0, fetchHandler })
+      : this.fetchClient;
+
+    const resp = await clientToUse(baseUrl + url, {
+      ...restOptions,
+      headers,
+    });
+
+    if (!resp.ok) {
+      throw new Error(
+        `Failed to make request to ${baseUrl + url}: ${resp.statusText}`,
+      );
+    }
+
+    // Check for affected rows header (for DELETE and bulk PATCH operations)
+    // FileMaker may return this with 204 No Content or 200 OK
+    const affectedRows = resp.headers.get("fmodata.affected_rows");
+    if (affectedRows !== null) {
+      return parseInt(affectedRows, 10) as T;
+    }
+
+    // Handle 204 No Content with no body
+    if (resp.status === 204) {
+      return 0 as T;
+    }
+
+    if (resp.headers.get("content-type")?.includes("application/json")) {
+      let data = await resp.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return data as T;
+    }
+    return (await resp.text()) as T;
+  }
+
+  database<
+    const Occurrences extends readonly TableOccurrence<any, any, any, any>[],
+  >(
+    name: string,
+    config?: { occurrences?: Occurrences },
+  ): Database<Occurrences> {
+    return new Database(name, this, config);
+  }
+
+  /**
+   * Lists all available databases from the FileMaker OData service.
+   * @returns Promise resolving to an array of database names
+   */
+  async listDatabaseNames(): Promise<string[]> {
+    const response = (await this._makeRequest("/")) as {
+      value?: Array<{ name: string }>;
+    };
+    if (response.value && Array.isArray(response.value)) {
+      return response.value.map((item) => item.name);
+    }
+    return [];
+  }
+}

package/src/client/insert-builder.ts

@@ -0,0 +1,93 @@
+import type {
+  ExecutionContext,
+  ExecutableBuilder,
+  Result,
+  ODataRecordMetadata,
+  InferSchemaType,
+} from "../types";
+import type { TableOccurrence } from "./table-occurrence";
+import { validateSingleResponse } from "../validation";
+import { type FFetchOptions } from "@fetchkit/ffetch";
+
+export class InsertBuilder<
+  T extends Record<string, any>,
+  Occ extends TableOccurrence<any, any, any, any> | undefined = undefined,
+> implements ExecutableBuilder<T & ODataRecordMetadata>
+{
+  private occurrence?: Occ;
+  private tableName: string;
+  private databaseName: string;
+  private context: ExecutionContext;
+  private data: Partial<T>;
+
+  constructor(config: {
+    occurrence?: Occ;
+    tableName: string;
+    databaseName: string;
+    context: ExecutionContext;
+    data: Partial<T>;
+  }) {
+    this.occurrence = config.occurrence;
+    this.tableName = config.tableName;
+    this.databaseName = config.databaseName;
+    this.context = config.context;
+    this.data = config.data;
+  }
+
+  async execute(
+    options?: RequestInit & FFetchOptions,
+  ): Promise<Result<T & ODataRecordMetadata>> {
+    try {
+      const url = `/${this.databaseName}/${this.tableName}`;
+
+      // Make POST request with JSON body
+      const response = await this.context._makeRequest(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(this.data),
+        ...options,
+      });
+
+      // Get schema from occurrence if available
+      const schema = this.occurrence?.baseTable?.schema;
+
+      // Validate the response (FileMaker returns the created record)
+      const validation = await validateSingleResponse<T>(
+        response,
+        schema,
+        undefined, // No selected fields for insert
+        undefined, // No expand configs
+        "exact", // Expect exactly one record
+      );
+
+      if (!validation.valid) {
+        return { data: undefined, error: validation.error };
+      }
+
+      // Handle null response (shouldn't happen for insert, but handle it)
+      if (validation.data === null) {
+        return {
+          data: undefined,
+          error: new Error("Insert operation returned null response"),
+        };
+      }
+
+      return { data: validation.data, error: undefined };
+    } catch (error) {
+      return {
+        data: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+      };
+    }
+  }
+
+  getRequestConfig(): { method: string; url: string; body?: any } {
+    return {
+      method: "POST",
+      url: `/${this.databaseName}/${this.tableName}`,
+      body: JSON.stringify(this.data),
+    };
+  }
+}