Refactor webhook management and enhance typegen functionality

- Updated client exports in the typegen output to improve naming consistency.
- Enhanced tests for dynamic scanning to include new properties like title and description.
- Added webhook management capabilities, including listing, adding, getting, and deleting webhooks with type-safe API.
- Improved response handling in capture-responses script and updated mock responses for webhook operations.
- Refactored coverage configuration to include relevant files and exclude test files for better reporting.

Author: eluce2

Users/ericluce/Documents/Code/work/proofkit/apps/demo/tests/typegen-output/without-zod/client/index.ts

@@ -1,2 +1,2 @@
-export { client as testLayoutClient } from "./testLayout";
-export { client as weirdPortalsClient } from "./weirdPortals";
+export { client as testLayoutLayout } from "./testLayout";
+export { client as weirdPortalsLayout } from "./weirdPortals";

apps/docs/tests/utils.manifest.test.ts

@@ -12,9 +12,10 @@ describe("Registry utils (dynamic scanning)", () => {
     // Should find the mode-toggle template
     expect(index.length).toBeGreaterThan(0);
     expect(index[0]).toHaveProperty("name");
-    expect(index[0]).toHaveProperty("type");
     expect(index[0]).toHaveProperty("category");
-    // RegistryIndexItem only has name, type, and category - not files
+    expect(index[0]).toHaveProperty("title");
+    expect(index[0]).toHaveProperty("description");
+    // RegistryIndexItem has name, category, title, description - not type or files
   });
 
   it("reads a known template (mode-toggle)", async () => {

packages/cli/vitest.config.ts

@@ -11,9 +11,11 @@ export default defineConfig({
     environment: "node",
     setupFiles: ["./tests/setup.ts"],
     include: ["tests/**/*.test.ts"],
+    testTimeout: 60000, // 60 seconds for CLI tests which can be slow
     coverage: {
       provider: "v8",
       reporter: ["text", "json", "html"],
+      include: ["src/**/*.ts"],
     },
   },
 });

packages/fmodata/README.md

@@ -778,6 +778,173 @@ console.log(result.result.recordId);
 
 **Note:** OData doesn't support script names with special characters (e.g., `@`, `&`, `/`) or script names beginning with a number. TypeScript will catch these at compile time.
 
+## Webhooks
+
+Webhooks allow you to receive notifications when data changes in your FileMaker database. The library provides a type-safe API for managing webhooks through the `db.webhook` property.
+
+### Adding a Webhook
+
+Create a new webhook to monitor a table for changes:
+
+```typescript
+// Basic webhook
+const result = await db.webhook.add({
+  webhook: "https://example.com/webhook",
+  tableName: contactsTable,
+});
+
+// Access the created webhook ID
+console.log(result.webHookResult.webHookID);
+```
+
+### Webhook Configuration Options
+
+Webhooks support various configuration options:
+
+```typescript
+// With custom headers
+const result = await db.webhook.add({
+  webhook: "https://example.com/webhook",
+  tableName: contactsTable,
+  headers: {
+    "X-Custom-Header": "value",
+    "Authorization": "Bearer token",
+  },
+  notifySchemaChanges: true, // Notify when schema changes
+});
+
+// With field selection (using column references)
+const result = await db.webhook.add({
+  webhook: "https://example.com/webhook",
+  tableName: contacts,
+  select: [contacts.name, contacts.email, contacts.PrimaryKey],
+});
+
+// With filtering (using filter expressions)
+import { eq, gt } from "@proofkit/fmodata";
+
+const result = await db.webhook.add({
+  webhook: "https://example.com/webhook",
+  tableName: contacts,
+  filter: eq(contacts.active, true),
+  select: [contacts.name, contacts.email],
+});
+
+// Complex filter example
+const result = await db.webhook.add({
+  webhook: "https://example.com/webhook",
+  tableName: users,
+  filter: and(eq(users.active, true), gt(users.age, 18)),
+  select: [users.username, users.email],
+});
+```
+
+**Webhook Configuration Properties:**
+
+- `webhook` (required) - The URL to call when the webhook is triggered
+- `tableName` (required) - The `FMTable` instance for the table to monitor
+- `headers` (optional) - Custom headers to include in webhook requests
+- `notifySchemaChanges` (optional) - Whether to notify on schema changes
+- `select` (optional) - Field selection as a string or array of `Column` references
+- `filter` (optional) - Filter expression (string or `FilterExpression`) to limit which records trigger the webhook
+
+### Listing Webhooks
+
+Get all webhooks configured for the database:
+
+```typescript
+const result = await db.webhook.list();
+
+console.log(result.Status); // Status of the operation
+console.log(result.WebHook); // Array of webhook configurations
+
+result.WebHook.forEach((webhook) => {
+  console.log(`Webhook ${webhook.webHookID}:`);
+  console.log(`  Table: ${webhook.tableName}`);
+  console.log(`  URL: ${webhook.url}`);
+  console.log(`  Notify Schema Changes: ${webhook.notifySchemaChanges}`);
+  console.log(`  Select: ${webhook.select}`);
+  console.log(`  Filter: ${webhook.filter}`);
+  console.log(`  Pending Operations: ${webhook.pendingOperations.length}`);
+});
+```
+
+### Getting a Webhook
+
+Retrieve a specific webhook by ID:
+
+```typescript
+const webhook = await db.webhook.get(1);
+
+console.log(webhook.webHookID);
+console.log(webhook.tableName);
+console.log(webhook.url);
+console.log(webhook.headers);
+console.log(webhook.notifySchemaChanges);
+console.log(webhook.select);
+console.log(webhook.filter);
+console.log(webhook.pendingOperations);
+```
+
+### Removing a Webhook
+
+Delete a webhook by ID:
+
+```typescript
+await db.webhook.remove(1);
+```
+
+### Invoking a Webhook
+
+Manually trigger a webhook. This is useful for testing or triggering webhooks on-demand:
+
+```typescript
+// Invoke for all rows matching the webhook's filter
+await db.webhook.invoke(1);
+
+// Invoke for specific row IDs
+await db.webhook.invoke(1, { rowIDs: [63, 61] });
+```
+
+### Complete Example
+
+Here's a complete example of setting up and managing webhooks:
+
+```typescript
+import { eq } from "@proofkit/fmodata";
+
+// Add a webhook to monitor active contacts
+const addResult = await db.webhook.add({
+  webhook: "https://api.example.com/webhooks/contacts",
+  tableName: contacts,
+  headers: {
+    "X-API-Key": "your-api-key",
+  },
+  filter: eq(contacts.active, true),
+  select: [contacts.name, contacts.email, contacts.PrimaryKey],
+  notifySchemaChanges: false,
+});
+
+const webhookId = addResult.webHookResult.webHookID;
+console.log(`Created webhook with ID: ${webhookId}`);
+
+// List all webhooks
+const listResult = await db.webhook.list();
+console.log(`Total webhooks: ${listResult.WebHook.length}`);
+
+// Get the webhook we just created
+const webhook = await db.webhook.get(webhookId);
+console.log(`Webhook URL: ${webhook.url}`);
+
+// Manually invoke the webhook for specific records
+await db.webhook.invoke(webhookId, { rowIDs: [1, 2, 3] });
+
+// Remove the webhook when done
+await db.webhook.remove(webhookId);
+```
+
+**Note:** Webhooks are triggered automatically by FileMaker when records matching the webhook's filter are created, updated, or deleted. The `invoke()` method allows you to manually trigger webhooks for testing or on-demand processing.
+
 ## Batch Operations
 
 Batch operations allow you to execute multiple queries and operations together in a single request. All operations in a batch are executed atomically - they all succeed or all fail together. This is both more efficient (fewer network round-trips) and ensures data consistency across related operations.

packages/fmodata/scripts/capture-responses.ts

@@ -35,6 +35,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { config } from "dotenv";
 import { writeFileSync } from "fs";
+import * as prettier from "prettier";
 import createClient from "@fetchkit/ffetch";
 import { MOCK_SERVER_URL } from "../tests/utils/mock-server-url";
 
@@ -406,6 +407,122 @@ const queriesToCapture: {
       return { url, response };
     },
   },
+  // Webhook API queries
+  {
+    name: "webhook-list",
+    description: "List all webhooks",
+    execute: async (client) => {
+      const path = "/Webhook.GetAll";
+      const response = await client(path);
+      const url = response.url;
+      return { url, response };
+    },
+  },
+  {
+    name: "webhook-add",
+    description: "Add a new webhook",
+    execute: async (client) => {
+      const path = "/Webhook.Add";
+      const response = await client(path, {
+        method: "POST",
+        body: {
+          webhook: "https://example.com/webhook",
+          tableName: "contacts",
+          headers: {
+            "X-Custom-Header": "test-value",
+          },
+          notifySchemaChanges: false,
+          select: "",
+          filter: "",
+        },
+      });
+      const url = response.url;
+
+      // Clone the response before extracting the data
+      const cloned = response.clone();
+      const newWebhookId = (await cloned.json()).webHookResult.webHookID;
+      await client(`/Webhook.Delete(${newWebhookId})`);
+
+      return { url, response };
+    },
+  },
+  {
+    name: "webhook-add-with-options",
+    description: "Add a new webhook",
+    execute: async (client) => {
+      const path = "/Webhook.Add";
+      const response = await client(path, {
+        method: "POST",
+        body: {
+          webhook: "https://example.com/webhook",
+          tableName: "contacts",
+          headers: {
+            "X-Custom-Header": "test-value",
+          },
+          notifySchemaChanges: false,
+          select: "name, age",
+          filter: "name eq 'John'",
+        },
+      });
+      const url = response.url;
+
+      // Clone the response before extracting the data
+      const cloned = response.clone();
+      const newWebhookId = (await cloned.json()).webHookResult.webHookID;
+      await client(`/Webhook.Delete(${newWebhookId})`);
+
+      return { url, response };
+    },
+  },
+  {
+    name: "webhook-get",
+    description: "Get a webhook by ID",
+    execute: async (client) => {
+      const listResponse = await client("/Webhook.GetAll");
+      const listData = await listResponse.json();
+      const webhookId = listData.WebHook?.[0]?.webHookID;
+      if (!webhookId) {
+        throw new Error("No webhook ID found");
+      }
+
+      // First, try to get webhook ID 1, or use a known ID if available
+      const path = `/Webhook.Get(${webhookId})`;
+      const response = await client(path);
+      const url = response.url;
+      return { url, response };
+    },
+  },
+  {
+    name: "webhook-get-not-found",
+    description: "Error response for non-existent webhook",
+    expectError: true,
+    execute: async (client) => {
+      const path = "/Webhook.Get(99999)";
+      const response = await client(path);
+      const url = response.url;
+      return { url, response };
+    },
+  },
+  {
+    name: "webhook-delete",
+    description: "Delete a webhook by ID",
+    execute: async (client) => {
+      const listResponse = await client("/Webhook.GetAll");
+      const listData = await listResponse.json();
+      const webhookId = listData.WebHook?.[0]?.webHookID;
+      if (!webhookId) {
+        throw new Error("No webhook ID found");
+      }
+
+      // Use webhook ID 1, or a known ID if available
+      const path = `/Webhook.Delete(${webhookId})`;
+      const response = await client(path, {
+        method: "POST",
+      });
+      const url = response.url;
+      return { url, response };
+    },
+  },
 ];
 
 /**
@@ -489,7 +606,7 @@ function generateResponsesFile(
  * 2. Run: pnpm capture
  * 3. The captured response will be added to this file automatically
  *
- * You can manually edit responses here if you need to modify test data.
+ * You MUST NOT manually edit this file. Any changes will be overwritten by the capture script.
  */
 
 export type MockResponse = {
@@ -669,7 +786,13 @@ async function main() {
     "../tests/fixtures/responses.ts",
   );
   const fileContent = generateResponsesFile(capturedResponses);
-  writeFileSync(fixturesPath, fileContent, "utf-8");
+
+  // Format the file content with prettier
+  const formattedContent = await prettier.format(fileContent, {
+    filepath: fixturesPath,
+  });
+
+  writeFileSync(fixturesPath, formattedContent, "utf-8");
 
   console.log(`\nResponses written to: ${fixturesPath}`);
   console.log("\nYou can now use these mocks in your tests!");