@terreno/api 0.14.1 → 0.15.0

package/package.json

@@ -106,5 +106,5 @@
     "updateSnapshot": "bun test --update-snapshots"
   },
   "types": "dist/index.d.ts",
-  "version": "0.14.1"
+  "version": "0.15.0"
 }

package/src/__tests__/versionCheckPlugin.test.ts

@@ -202,6 +202,30 @@ describe("VersionCheckPlugin", () => {
     expect(res.status).toBe(200);
     expect(res.body.status).toBe("warning");
   });
+
+  it("uses default messages when warningMessage/requiredMessage are not set", async () => {
+    await VersionConfig.create({
+      webRequiredVersion: 100,
+      webWarningVersion: 200,
+    });
+
+    const warningRes = await app.get("/version-check").query({platform: "web", version: 150});
+    expect(warningRes.body.status).toBe("warning");
+    expect(warningRes.body.message).toBe(
+      "A new version is available. Please update for the best experience."
+    );
+
+    const requiredRes = await app.get("/version-check").query({platform: "web", version: 50});
+    expect(requiredRes.body.status).toBe("required");
+    expect(requiredRes.body.message).toBe(
+      "This version is no longer supported. Please update to continue."
+    );
+  });
+
+  it("handles numeric version parameter", async () => {
+    const res = await app.get("/version-check?version=50&platform=web");
+    expect(res.status).toBe(200);
+  });
 });
 
 describe("VersionCheckPlugin direct usage", () => {

package/src/errors.test.ts

@@ -7,6 +7,8 @@ import {
   APIError,
   apiErrorMiddleware,
   apiUnauthorizedMiddleware,
+  errorMessage,
+  errorStack,
   errorsPlugin,
   getAPIErrorBody,
   getDisableExternalErrorTracking,
@@ -154,6 +156,36 @@ describe("getDisableExternalErrorTracking", () => {
   });
 });
 
+describe("errorMessage", () => {
+  it("returns the message from an Error instance", () => {
+    expect(errorMessage(new Error("boom"))).toBe("boom");
+  });
+
+  it("returns the string representation of a non-Error value", () => {
+    expect(errorMessage("raw string")).toBe("raw string");
+    expect(errorMessage(42)).toBe("42");
+    expect(errorMessage(null)).toBe("null");
+  });
+});
+
+describe("errorStack", () => {
+  it("returns the stack trace from an Error with a stack", () => {
+    const err = new Error("fail");
+    expect(errorStack(err)).toBe(err.stack as string);
+  });
+
+  it("returns the string representation when error has no stack", () => {
+    const err = new Error("no-stack");
+    Object.defineProperty(err, "stack", {value: undefined});
+    expect(errorStack(err)).toBe("Error: no-stack");
+  });
+
+  it("returns the string representation of a non-Error value", () => {
+    expect(errorStack("plain")).toBe("plain");
+    expect(errorStack(123)).toBe("123");
+  });
+});
+
 describe("getAPIErrorBody", () => {
   it("returns title and status by default", () => {
     const error = new APIError({status: 404, title: "Not Found"});

package/src/expressServer.test.ts

@@ -770,6 +770,85 @@ describe("expressServer", () => {
 
       expect(func).toHaveBeenCalled();
     });
+
+    it("fires warning timeout callback when script is slow", async () => {
+      // terminateTimeout = 0.3s → warnTime = 150ms, closeTime = 300ms
+      // The func takes 200ms, so the warn callback fires at 150ms,
+      // but func completes at 200ms before the terminate callback at 300ms.
+      // afterEach clears the terminate timer.
+      const func = mock(
+        () => new Promise<string>((resolve) => originalSetTimeout(() => resolve("done"), 200))
+      );
+      try {
+        await wrapScript(func, {terminateTimeout: 0.3});
+      } catch {
+        // process.exit(0) throws
+      }
+      expect(process.exit).toHaveBeenCalledWith(0);
+    });
+  });
+
+  describe("setupServer with listen (skipListen false)", () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = {
+        ...originalEnv,
+        PORT: "0", // Use port 0 to let OS assign a random free port
+        REFRESH_TOKEN_SECRET: "test-refresh-secret",
+        SESSION_SECRET: "test-session-secret",
+        TOKEN_EXPIRES_IN: "1h",
+        TOKEN_ISSUER: "test-issuer",
+        TOKEN_SECRET: "test-secret",
+      };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it("starts the server when skipListen is false", async () => {
+      const addRoutes = () => {};
+      // Mock app.listen on the Express prototype to avoid opening a real port
+      const express = await import("express");
+      const originalListen = express.default.application.listen;
+      // biome-ignore lint/suspicious/noExplicitAny: mocking Express internals requires type escape
+      express.default.application.listen = mock(function (this: unknown, ...args: unknown[]) {
+        const cb = args.find((a: unknown) => typeof a === "function") as (() => void) | undefined;
+        if (cb) {
+          cb();
+        }
+        return this;
+      }) as unknown as typeof originalListen;
+      try {
+        const app = setupServer({
+          addRoutes,
+          skipListen: false,
+          userModel: UserModel as any,
+        });
+        expect(app).toBeDefined();
+      } finally {
+        express.default.application.listen = originalListen;
+      }
+    });
+
+    it("handles listen error with invalid port", () => {
+      process.env.PORT = "-1";
+      const addRoutes = () => {};
+      // Using an invalid port should trigger the catch block and process.exit(1)
+      const originalExit = process.exit;
+      process.exit = (() => {}) as unknown as typeof process.exit;
+      try {
+        setupServer({
+          addRoutes,
+          skipListen: false,
+          userModel: UserModel as any,
+        });
+      } catch {
+        // May throw
+      }
+      process.exit = originalExit;
+    });
   });
 
   describe("setupServer with listen", () => {