Merge branch 'main' into chris/schy-148-schematic-node140-breaks-in-cloudflare-workers

Author: bpapillon

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@schematichq/schematic-typescript-node",
-    "version": "1.4.0",
+    "version": "1.4.1",
     "private": false,
     "repository": {
         "type": "git",

src/wrapper.ts

@@ -300,9 +300,13 @@ export class SchematicClient extends BaseClient {
                 value: response.data.value,
             };
 
-            for (const provider of this.flagCheckCacheProviders) {
-                this.logger.debug(`Caching value for flag ${key} in ${provider.constructor.name}`);
-                await provider.set(cacheKey, result);
+            try {
+                for (const provider of this.flagCheckCacheProviders) {
+                    this.logger.debug(`Caching value for flag ${key} in ${provider.constructor.name}`);
+                    await provider.set(cacheKey, result);
+                }
+            } catch (cacheErr) {
+                this.logger.warn(`Cache write failed for flag ${key}: ${cacheErr}`);
             }
 
             return result;
@@ -406,9 +410,13 @@ export class SchematicClient extends BaseClient {
                         userId: apiResult.userId,
                         value: apiResult.value,
                     };
-                    for (const provider of this.flagCheckCacheProviders) {
-                        this.logger.debug(`Caching value for flag ${cacheKey} in ${provider.constructor.name}`);
-                        await provider.set(cacheKey, cacheEntry);
+                    try {
+                        for (const provider of this.flagCheckCacheProviders) {
+                            this.logger.debug(`Caching value for flag ${cacheKey} in ${provider.constructor.name}`);
+                            await provider.set(cacheKey, cacheEntry);
+                        }
+                    } catch (cacheErr) {
+                        this.logger.warn(`Cache write failed for flag ${key}: ${cacheErr}`);
                     }
                     results.push(apiResult);
                 } else {

tests/unit/cache/cache-write-failure.test.ts

@@ -0,0 +1,105 @@
+import { SchematicClient } from "../../../src/wrapper";
+import type { CacheProvider } from "../../../src/cache";
+import type { CheckFlagWithEntitlementResponse } from "../../../src/wrapper";
+
+/**
+ * A cache provider that always throws on set() to simulate failures
+ * like Cloudflare KV 429 Too Many Requests.
+ */
+class FailingCacheProvider implements CacheProvider<CheckFlagWithEntitlementResponse> {
+    async get(): Promise<CheckFlagWithEntitlementResponse | null> {
+        return null; // Always miss
+    }
+    async set(): Promise<void> {
+        throw new Error("429 Too Many Requests");
+    }
+    async delete(): Promise<void> {}
+}
+
+// Mock the features.checkFlag API call
+jest.mock("../../../src/Client", () => {
+    class MockBaseClient {
+        features = {
+            checkFlag: jest.fn().mockResolvedValue({
+                data: {
+                    value: true,
+                    flag: "test-flag",
+                    reason: "match",
+                    companyId: "comp-1",
+                },
+            }),
+            checkFlags: jest.fn().mockResolvedValue({
+                data: {
+                    flags: [
+                        {
+                            value: true,
+                            flag: "test-flag",
+                            reason: "match",
+                            companyId: "comp-1",
+                        },
+                    ],
+                },
+            }),
+        };
+        events = {};
+    }
+    return { SchematicClient: MockBaseClient };
+});
+
+// Mock the EventBuffer to avoid side effects
+jest.mock("../../../src/events", () => {
+    return {
+        EventBuffer: jest.fn().mockImplementation(() => ({
+            push: jest.fn(),
+            stop: jest.fn().mockResolvedValue(undefined),
+        })),
+    };
+});
+
+describe("Cache write failure should not discard API result", () => {
+    let client: SchematicClient;
+    const warnSpy = jest.fn();
+
+    beforeEach(() => {
+        client = new SchematicClient({
+            apiKey: "test-api-key",
+            cacheProviders: {
+                flagChecks: [new FailingCacheProvider()],
+            },
+            logger: {
+                error: jest.fn(),
+                warn: warnSpy,
+                info: jest.fn(),
+                debug: jest.fn(),
+            },
+        });
+    });
+
+    afterEach(async () => {
+        await client.close();
+    });
+
+    it("checkFlag returns the API value even when cache set() throws", async () => {
+        const result = await client.checkFlag({ company: { id: "comp-1" } }, "test-flag");
+        expect(result).toBe(true);
+    });
+
+    it("checkFlagWithEntitlement returns the API value even when cache set() throws", async () => {
+        const result = await client.checkFlagWithEntitlement({ company: { id: "comp-1" } }, "test-flag");
+        expect(result.value).toBe(true);
+        expect(result.reason).toBe("match");
+    });
+
+    it("logs a warning when cache write fails", async () => {
+        await client.checkFlag({ company: { id: "comp-1" } }, "test-flag");
+        expect(warnSpy).toHaveBeenCalledWith(
+            expect.stringContaining("Cache write failed for flag test-flag"),
+        );
+    });
+
+    it("checkFlags returns API values even when cache set() throws", async () => {
+        const results = await client.checkFlags({ company: { id: "comp-1" } }, ["test-flag"]);
+        expect(results).toHaveLength(1);
+        expect(results[0].value).toBe(true);
+    });
+});

src/events.test.ts tests/unit/events.test.tssrc/events.test.ts renamed to tests/unit/events.test.ts

@@ -1,9 +1,9 @@
 /* eslint @typescript-eslint/no-explicit-any: 0 */
 
-import { EventBuffer } from "./events";
-import { EventsClient } from "./api/resources/events/client/Client";
-import { CreateEventRequestBody } from "./api";
-import { Logger } from "./logger";
+import { EventBuffer } from "../../src/events";
+import { EventsClient } from "../../src/api/resources/events/client/Client";
+import { CreateEventRequestBody } from "../../src/api";
+import { Logger } from "../../src/logger";
 
 process.env.NODE_ENV = "test";