@terreno/api 0.13.3 → 0.14.1

package/src/terrenoApp.test.ts

@@ -1,13 +1,19 @@
 import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
 import type express from "express";
+import mongoose, {Schema} from "mongoose";
 import supertest from "supertest";
 
 import {modelRouter} from "./api";
+import type {UserModel as UserModelType} from "./auth";
+import {configurationPlugin} from "./configurationPlugin";
 import {Permissions} from "./permissions";
+import {createdUpdatedPlugin} from "./plugins";
 import {TerrenoApp} from "./terrenoApp";
 import type {TerrenoPlugin} from "./terrenoPlugin";
 import {authAsUser, FoodModel, setupDb, UserModel} from "./tests";
 
+const typedUserModel = UserModel as unknown as UserModelType;
+
 describe("TerrenoApp", () => {
   const originalEnv = process.env;
 
@@ -30,7 +36,7 @@ describe("TerrenoApp", () => {
     it("returns an express application without listening", () => {
       const app = new TerrenoApp({
         skipListen: true,
-        userModel: UserModel as any,
+        userModel: typedUserModel,
       }).build();
 
       expect(app).toBeDefined();
@@ -40,7 +46,7 @@ describe("TerrenoApp", () => {
       const app = new TerrenoApp({
         corsOrigin: "https://example.com",
         skipListen: true,
-        userModel: UserModel as any,
+        userModel: typedUserModel,
       }).build();
 
       expect(app).toBeDefined();
@@ -51,7 +57,7 @@ describe("TerrenoApp", () => {
     it("returns an express application with skipListen", () => {
       const app = new TerrenoApp({
         skipListen: true,
-        userModel: UserModel as any,
+        userModel: typedUserModel,
       }).start();
 
       expect(app).toBeDefined();
@@ -59,7 +65,7 @@ describe("TerrenoApp", () => {
   });
 
   describe("register with modelRouter", () => {
-    let admin: any;
+    let admin: Awaited<ReturnType<typeof setupDb>>[0];
 
     beforeEach(async () => {
       [admin] = await setupDb();
@@ -83,7 +89,7 @@ describe("TerrenoApp", () => {
 
       const app = new TerrenoApp({
         skipListen: true,
-        userModel: UserModel as any,
+        userModel: typedUserModel,
       })
         .register(foodRegistration)
         .build();
@@ -115,7 +121,7 @@ describe("TerrenoApp", () => {
 
       const app = new TerrenoApp({
         skipListen: true,
-        userModel: UserModel as any,
+        userModel: typedUserModel,
       })
         .register(foodRegistration)
         .build();
@@ -133,14 +139,13 @@ describe("TerrenoApp", () => {
 
       const app = new TerrenoApp({
         skipListen: true,
-        userModel: UserModel as any,
+        userModel: typedUserModel,
       })
         .register(plugin)
         .build();
 
       expect(registerFn).toHaveBeenCalledTimes(1);
-      // Verify the plugin received the express app
-      const calledWith = (registerFn.mock.calls as any[][])[0][0];
+      const calledWith = (registerFn.mock.calls as unknown[][])[0][0];
       expect(calledWith).toBe(app);
     });
   });
@@ -155,7 +160,7 @@ describe("TerrenoApp", () => {
 
       const app = new TerrenoApp({
         skipListen: true,
-        userModel: UserModel as any,
+        userModel: typedUserModel,
       })
         .addMiddleware(middleware)
         .build();
@@ -165,6 +170,127 @@ describe("TerrenoApp", () => {
     });
   });
 
+  describe("configure", () => {
+    beforeEach(async () => {
+      await setupDb();
+    });
+
+    it("mounts configuration routes when configure() is called", async () => {
+      const cfgSchema = new Schema(
+        {siteName: {default: "My Site", description: "Site name", type: String}},
+        {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
+      );
+      cfgSchema.plugin(configurationPlugin);
+      cfgSchema.plugin(createdUpdatedPlugin);
+
+      const modelName = `CfgModel_${Date.now()}`;
+      const CfgModel = mongoose.model(modelName, cfgSchema);
+
+      const app = new TerrenoApp({
+        skipListen: true,
+        userModel: typedUserModel,
+      })
+        .configure(CfgModel)
+        .build();
+
+      const agent = await authAsUser(app, "admin");
+      const res = await agent.get("/configuration/meta");
+      expect(res.status).toBe(200);
+    });
+
+    it("supports custom basePath via configure options", async () => {
+      const cfgSchema2 = new Schema(
+        {siteName: {default: "Test", description: "Site name", type: String}},
+        {strict: "throw", toJSON: {virtuals: true}, toObject: {virtuals: true}}
+      );
+      cfgSchema2.plugin(configurationPlugin);
+      cfgSchema2.plugin(createdUpdatedPlugin);
+
+      const modelName = `CfgModel2_${Date.now()}`;
+      const CfgModel2 = mongoose.model(modelName, cfgSchema2);
+
+      const app = new TerrenoApp({
+        skipListen: true,
+        userModel: typedUserModel,
+      })
+        .configure(CfgModel2, {basePath: "/settings"})
+        .build();
+
+      const agent = await authAsUser(app, "admin");
+      const res = await agent.get("/settings/meta");
+      expect(res.status).toBe(200);
+    });
+  });
+
+  describe("fallthrough error handler", () => {
+    it("returns 500 for non-API errors", async () => {
+      const plugin: TerrenoPlugin = {
+        register: (pluginApp) => {
+          pluginApp.get("/trigger-fallthrough", (_req: express.Request, _res: express.Response) => {
+            throw new Error("unexpected failure");
+          });
+        },
+      };
+      const app = new TerrenoApp({
+        skipListen: true,
+        userModel: typedUserModel,
+      })
+        .register(plugin)
+        .build();
+
+      const res = await supertest(app).get("/trigger-fallthrough");
+      expect(res.status).toBe(500);
+    });
+  });
+
+  describe("start with listen", () => {
+    it("starts and listens on the configured port", async () => {
+      const port = "19876";
+      process.env.PORT = port;
+      const app = new TerrenoApp({
+        userModel: typedUserModel,
+      }).start();
+
+      expect(app).toBeDefined();
+    });
+  });
+
+  describe("addMiddleware with app-configuring function", () => {
+    it("invokes a function that receives the express app (fn.length > 3)", async () => {
+      let receivedApp: express.Application | undefined;
+      const configFn = (
+        _appInstance: express.Application,
+        _a: unknown,
+        _b: unknown,
+        _c: unknown
+      ): void => {
+        receivedApp = _appInstance;
+      };
+
+      const app = new TerrenoApp({
+        skipListen: true,
+        userModel: typedUserModel,
+      })
+        .addMiddleware(configFn as unknown as (app: express.Application) => void)
+        .build();
+
+      expect(app).toBeDefined();
+      expect(receivedApp).toBe(app);
+    });
+  });
+
+  describe("logRequests option", () => {
+    it("disables request logging when logRequests is false", () => {
+      const app = new TerrenoApp({
+        logRequests: false,
+        skipListen: true,
+        userModel: typedUserModel,
+      }).build();
+
+      expect(app).toBeDefined();
+    });
+  });
+
   describe("modelRouter overload", () => {
     it("returns ModelRouterRegistration when path is provided", () => {
       const result = modelRouter("/food", FoodModel, {
@@ -195,7 +321,7 @@ describe("TerrenoApp", () => {
 
       // Should be a regular router (function), not a ModelRouterRegistration
       expect(typeof result).toBe("function");
-      expect((result as any).__type).toBeUndefined();
+      expect((result as unknown as {__type?: string}).__type).toBeUndefined();
     });
   });
 });

package/src/terrenoApp.ts

@@ -1,3 +1,4 @@
+import {createServer} from "node:http";
 import * as Sentry from "@sentry/bun";
 import cors from "cors";
 import express from "express";
@@ -5,12 +6,23 @@ import qs from "qs";
 import type {ModelRouterRegistration} from "./api";
 import {addAuthRoutes, addMeRoutes, setupAuth, type UserModel as UserMongooseModel} from "./auth";
 import {ConfigurationApp, type ConfigurationAppOptions} from "./configurationApp";
-import {apiErrorMiddleware, apiUnauthorizedMiddleware} from "./errors";
+import {
+  apiErrorMiddleware,
+  apiFallthroughErrorMiddleware,
+  apiUnauthorizedMiddleware,
+} from "./errors";
 import {type AuthOptions, logRequests} from "./expressServer";
 import {addGitHubAuthRoutes, type GitHubAuthOptions, setupGitHubAuth} from "./githubAuth";
 import {type LoggingOptions, logger, setupLogging} from "./logger";
 import {openApiCompatMiddleware, patchAppUse} from "./openApiCompat";
 import {openApiEtagMiddleware} from "./openApiEtag";
+import {RealtimeApp} from "./realtime/realtimeApp";
+import type {RealtimeAppOptions} from "./realtime/types";
+import {
+  getCurrentRequestContext,
+  requestContextMiddleware,
+  updateRequestContextFromRequest,
+} from "./requestContext";
 import type {TerrenoPlugin} from "./terrenoPlugin";
 import openapi from "./vendor/wesleytodd-openapi/index";
 
@@ -49,6 +61,13 @@ export interface TerrenoAppOptions {
   arrayLimit?: number;
   /** Whether to log all incoming requests (default: true) */
   logRequests?: boolean;
+  /**
+   * Real-time sync configuration. When provided, Socket.io and MongoDB change streams
+   * are set up automatically — no need to register RealtimeApp as a separate plugin.
+   *
+   * Set to `true` for defaults, or pass a RealtimeAppOptions object for full control.
+   */
+  realtime?: boolean | RealtimeAppOptions;
 }
 
 /**
@@ -196,6 +215,7 @@ export class TerrenoApp {
    * ```
    */
   configure(
+    // biome-ignore lint/suspicious/noExplicitAny: Model<any> required for invariance — consumers pass arbitrary configuration models
     model: import("mongoose").Model<any>,
     options?: Omit<ConfigurationAppOptions, "model">
   ): this {
@@ -239,6 +259,8 @@ export class TerrenoApp {
       qs.parse(str, {arrayLimit: options.arrayLimit ?? 200})
     );
 
+    app.use(requestContextMiddleware);
+
     app.use(cors({credentials: true, origin: options.corsOrigin ?? "*"}));
 
     // Apply custom middleware before JSON parsing
@@ -255,8 +277,12 @@ export class TerrenoApp {
     app.use(express.json({limit: "50mb"}));
 
     // Auth routes (login/signup/refresh_token) before JWT middleware
-    addAuthRoutes(app, options.userModel as any, options.authOptions);
-    setupAuth(app as any, options.userModel as any);
+    addAuthRoutes(app, options.userModel, options.authOptions);
+    setupAuth(app, options.userModel);
+    app.use((req, res, next) => {
+      updateRequestContextFromRequest(req, res);
+      next();
+    });
 
     if (options.logRequests !== false) {
       app.use(logRequests);
@@ -269,9 +295,13 @@ export class TerrenoApp {
     });
 
     // Sentry scopes
-    app.use((req: any, _res: any, next: any) => {
+    app.use((req: express.Request, _res: express.Response, next: express.NextFunction) => {
+      const context = getCurrentRequestContext();
       const transactionId = req.header("X-Transaction-ID");
-      const sessionId = req.header("X-Session-ID");
+      const sessionId = context?.sessionId ?? req.header("X-Session-ID");
+      if (context?.requestId) {
+        Sentry.getCurrentScope().setTag("request_id", context.requestId);
+      }
       if (transactionId) {
         Sentry.getCurrentScope().setTag("transaction_id", transactionId);
       }
@@ -279,7 +309,7 @@ export class TerrenoApp {
         Sentry.getCurrentScope().setTag("session_id", sessionId);
       }
       if (req.user?._id) {
-        Sentry.getCurrentScope().setTag("user", req.user._id);
+        Sentry.getCurrentScope().setTag("user", String(req.user._id));
       }
       next();
     });
@@ -303,8 +333,8 @@ export class TerrenoApp {
 
     // GitHub OAuth
     if (options.githubAuth) {
-      setupGitHubAuth(app, options.userModel as any, options.githubAuth);
-      addGitHubAuthRoutes(app, options.userModel as any, options.githubAuth, options.authOptions);
+      setupGitHubAuth(app, options.userModel, options.githubAuth);
+      addGitHubAuthRoutes(app, options.userModel, options.githubAuth, options.authOptions);
     }
 
     // Mount configuration app if configured
@@ -324,7 +354,7 @@ export class TerrenoApp {
 
     // /auth/me must be registered after plugins so that session middleware
     // (e.g. Better Auth) has a chance to populate req.user first.
-    addMeRoutes(app, options.userModel as any, options.authOptions);
+    addMeRoutes(app, options.userModel, options.authOptions);
 
     Sentry.setupExpressErrorHandler(app);
 
@@ -332,12 +362,7 @@ export class TerrenoApp {
     app.use(apiUnauthorizedMiddleware);
     app.use(apiErrorMiddleware);
 
-    app.use(function onError(err: any, _req: any, res: any, _next: any) {
-      logger.error(`Fallthrough error: ${err}${err?.stack ? `\n${err.stack}` : ""}}`);
-      Sentry.captureException(err);
-      res.statusCode = 500;
-      res.end(`${res.sentry}\n`);
-    });
+    app.use(apiFallthroughErrorMiddleware);
 
     return app;
   }
@@ -363,16 +388,38 @@ export class TerrenoApp {
    * ```
    */
   start(): express.Application {
+    // If realtime option is set, auto-register the RealtimeApp plugin
+    if (this.options.realtime) {
+      const hasRealtimePlugin = this.registrations.some(
+        (r) => !this.isModelRouterRegistration(r) && r instanceof RealtimeApp
+      );
+      if (!hasRealtimePlugin) {
+        const realtimeConfig =
+          typeof this.options.realtime === "object" ? this.options.realtime : {};
+        this.register(new RealtimeApp(realtimeConfig));
+      }
+    }
+
     const app = this.build();
 
     if (!this.options.skipListen) {
       const port = process.env.PORT || "9000";
       try {
-        app.listen(port, () => {
+        const server = createServer(app);
+
+        // Notify plugins that need access to the HTTP server (e.g. WebSocket plugins)
+        for (const reg of this.registrations) {
+          if (!this.isModelRouterRegistration(reg) && typeof reg.onServerCreated === "function") {
+            reg.onServerCreated(server);
+          }
+        }
+
+        server.listen(port, () => {
           logger.info(`Listening on port ${port}`);
         });
       } catch (error) {
-        logger.error(`Error trying to start HTTP server: ${error}\n${(error as any).stack}`);
+        const stack = error instanceof Error ? error.stack : String(error);
+        logger.error(`Error trying to start HTTP server: ${error}\n${stack}`);
         process.exit(1);
       }
     }

package/src/terrenoPlugin.ts

@@ -1,3 +1,4 @@
+import type http from "node:http";
 import type express from "express";
 
 /**
@@ -36,4 +37,15 @@ export interface TerrenoPlugin {
    * @param app - The Express application instance to register with
    */
   register(app: express.Application, openApi?: unknown): void;
+
+  /**
+   * Called after the HTTP server is created but before it starts listening.
+   * Use this to attach services that need the raw HTTP server, such as
+   * Socket.io or other WebSocket libraries.
+   *
+   * Only called when using `TerrenoApp.start()` (not `build()`).
+   *
+   * @param server - The Node.js HTTP server instance
+   */
+  onServerCreated?(server: http.Server): void;
 }

package/src/tests/bunSetup.ts

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {afterAll, afterEach, beforeAll, beforeEach, mock} from "bun:test";
 import {Writable} from "node:stream";
 import mongoose from "mongoose";

package/src/tests.ts

@@ -106,7 +106,12 @@ const foodCategorySchema = new Schema<FoodCategory>(
   {timestamps: {createdAt: "created", updatedAt: "updated"}}
 );
 
-const likesSchema = new Schema<any>({
+interface Likes {
+  likes: boolean;
+  userId: mongoose.Types.ObjectId;
+}
+
+const likesSchema = new Schema<Likes>({
   likes: {description: "Whether the user liked the item", type: Boolean},
   userId: {description: "The user who liked the item", ref: "User", type: "ObjectId"},
 });
@@ -124,7 +129,7 @@ const foodSchema = new Schema<Food>(
         type: Schema.Types.ObjectId,
       },
     ],
-    // noExplicitAny: DateOnly is a custom SchemaType not recognized by Mongoose's built-in type definitions
+    // biome-ignore lint/suspicious/noExplicitAny: DateOnly is a custom SchemaType not recognized by Mongoose's built-in type definitions
     expiration: {description: "Expiration date of the food", type: DateOnly as any},
     hidden: {
       default: false,

package/src/transformers.test.ts

@@ -1,14 +1,17 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {beforeEach, describe, expect, it} from "bun:test";
 import type express from "express";
-import type {ObjectId} from "mongoose";
+import type {Document, ObjectId} from "mongoose";
 import supertest from "supertest";
 import type TestAgent from "supertest/lib/agent";
 
+import type {ModelRouterOptions} from "./api";
 import {modelRouter} from "./api";
 import {addAuthRoutes, setupAuth} from "./auth";
+import {APIError} from "./errors";
 import {Permissions} from "./permissions";
 import {authAsUser, type Food, FoodModel, getBaseServer, setupDb, UserModel} from "./tests";
-import {AdminOwnerTransformer} from "./transformers";
+import {AdminOwnerTransformer, defaultResponseHandler, transform} from "./transformers";
 
 describe("query and transform", () => {
   let notAdmin: any;
@@ -200,3 +203,68 @@ describe("query and transform", () => {
     await server.patch(`/food/${carrots.id}`).send({calories: 10}).expect(403);
   });
 });
+
+describe("transform (deprecated helper)", () => {
+  const mockTransformFn = (obj: Partial<Food>, _method: "create" | "update") => ({
+    ...obj,
+    name: `${obj.name}_transformed`,
+  });
+
+  it("returns data unchanged when no transformer is configured", () => {
+    const options = {permissions: {}} as ModelRouterOptions<Food>;
+    const data = {name: "Apple"} as Partial<Food>;
+    expect(transform(options, data, "create")).toEqual(data);
+  });
+
+  it("transforms a single object", () => {
+    const options = {
+      transformer: {transform: mockTransformFn},
+    } as unknown as ModelRouterOptions<Food>;
+    const result = transform(options, {name: "Apple"} as Partial<Food>, "create");
+    expect((result as Partial<Food>).name).toBe("Apple_transformed");
+  });
+
+  it("transforms an array of objects", () => {
+    const options = {
+      transformer: {transform: mockTransformFn},
+    } as unknown as ModelRouterOptions<Food>;
+    const data = [{name: "Apple"}, {name: "Banana"}] as Partial<Food>[];
+    const result = transform(options, data, "update") as Partial<Food>[];
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe("Apple_transformed");
+    expect(result[1].name).toBe("Banana_transformed");
+  });
+});
+
+describe("defaultResponseHandler", () => {
+  it("returns null when doc is null", async () => {
+    const options = {permissions: {}} as ModelRouterOptions<Food>;
+    const req = {} as express.Request;
+    const result = await defaultResponseHandler<Food>(null, "read", req, options);
+    expect(result).toBeNull();
+  });
+
+  it("throws APIError when serialize throws", async () => {
+    const options = {
+      transformer: {
+        serialize: () => {
+          throw new Error("serialize boom");
+        },
+      },
+    } as unknown as ModelRouterOptions<Food>;
+    const fakeDoc = {
+      _id: "abc",
+      toObject: () => ({name: "Apple"}),
+    } as unknown as Document<unknown, unknown, unknown> & Food;
+    const req = {} as express.Request;
+
+    try {
+      await defaultResponseHandler(fakeDoc, "read", req, options);
+      expect(true).toBe(false);
+    } catch (err: unknown) {
+      expect(err).toBeInstanceOf(APIError);
+      expect((err as APIError).status).toBe(400);
+      expect((err as APIError).title).toContain("Error serializing read response");
+    }
+  });
+});

package/src/transformers.ts

@@ -22,7 +22,8 @@ const getUserType = (
   if (user?.admin) {
     return "admin";
   }
-  if (obj && user && String(obj?.ownerId) === String(user?.id)) {
+  const withOwner = obj as {ownerId?: unknown} | undefined;
+  if (withOwner && user && String(withOwner?.ownerId) === String(user?.id)) {
     return "owner";
   }
   if (user?.id) {
@@ -44,8 +45,9 @@ export const AdminOwnerTransformer = <T>(options: {
   const pickFields = (obj: Partial<T>, fields: string[]): Partial<T> => {
     const newData: Partial<T> = {};
     for (const field of fields) {
-      if ((obj as Record<string, unknown>)[field] !== undefined) {
-        (newData as Record<string, unknown>)[field] = (obj as Record<string, unknown>)[field];
+      const key = field as keyof T;
+      if (obj[key] !== undefined) {
+        newData[key] = obj[key];
       }
     }
     return newData;
@@ -115,11 +117,14 @@ export const transform = <T>(
 export const serialize = <T>(
   req: express.Request,
   options: ModelRouterOptions<T>,
-  data: (Document & T) | (Document & T)[]
+  data: (Document<unknown, unknown, unknown> & T) | (Document<unknown, unknown, unknown> & T)[]
 ) => {
-  const serializeFn = (serializeData: Document & T, serializeUser?: User) => {
+  const serializeFn = (
+    serializeData: Document<unknown, unknown, unknown> & T,
+    serializeUser?: User
+  ) => {
     const dataObject = serializeData.toObject() as T;
-    (dataObject as Record<string, unknown>).id = serializeData._id;
+    (dataObject as unknown as {id: unknown}).id = serializeData._id;
 
     // Search for any value that is a Map and transform it to a plain object.
     // Otherwise Express drops the contents.
@@ -152,7 +157,10 @@ export const serialize = <T>(
  * using transformers.serializer if provided.
  */
 export const defaultResponseHandler = async <T>(
-  doc: (Document & T) | (Document & T)[] | null,
+  doc:
+    | (Document<unknown, unknown, unknown> & T)
+    | (Document<unknown, unknown, unknown> & T)[]
+    | null,
   method: "list" | "create" | "read" | "update",
   request: express.Request,
   options: ModelRouterOptions<T>

package/src/types/consentResponse.ts

@@ -1,18 +1,16 @@
 import type mongoose from "mongoose";
 import type {FindExactlyOnePlugin, FindOneOrNonePlugin} from "../plugins";
 
-// biome-ignore lint/complexity/noBannedTypes: No methods.
-export type ConsentResponseMethods = {};
+// biome-ignore lint/suspicious/noEmptyInterface: Prefer interface over type per project rules
+export interface ConsentResponseMethods {}
 
-export type ConsentResponseStatics = FindExactlyOnePlugin<ConsentResponseDocument> &
-  FindOneOrNonePlugin<ConsentResponseDocument>;
+export interface ConsentResponseStatics
+  extends FindExactlyOnePlugin<ConsentResponseDocument>,
+    FindOneOrNonePlugin<ConsentResponseDocument> {}
 
-export type ConsentResponseModel = mongoose.Model<
-  ConsentResponseDocument,
-  object,
-  ConsentResponseMethods
-> &
-  ConsentResponseStatics;
+export interface ConsentResponseModel
+  extends mongoose.Model<ConsentResponseDocument, object, ConsentResponseMethods>,
+    ConsentResponseStatics {}
 
 export interface ConsentResponseDocument extends mongoose.Document {
   _id: mongoose.Types.ObjectId;

package/src/versionCheckPlugin.ts

@@ -8,6 +8,8 @@ export type VersionCheckStatus = "ok" | "warning" | "required";
 
 export interface VersionCheckResponse {
   message?: string;
+  /** How often the client should poll for updates, in milliseconds. */
+  pollingIntervalMs?: number;
   requiredVersion?: number;
   status: VersionCheckStatus;
   updateUrl?: string;
@@ -17,6 +19,7 @@ export interface VersionCheckResponse {
 const DEFAULT_WARNING_MESSAGE =
   "A new version is available. Please update for the best experience.";
 const DEFAULT_REQUIRED_MESSAGE = "This version is no longer supported. Please update to continue.";
+const DEFAULT_POLLING_INTERVAL_MINUTES = 1440;
 
 /**
  * TerrenoPlugin that adds a public GET /version-check endpoint for upgrade enforcement.
@@ -30,12 +33,12 @@ export class VersionCheckPlugin implements TerrenoPlugin {
         const versionParam = req.query.version;
         const platform = req.query.platform as string | undefined;
 
-        const version =
-          typeof versionParam === "string"
-            ? parseInt(versionParam, 10)
-            : typeof versionParam === "number"
-              ? versionParam
-              : undefined;
+        let version: number | undefined;
+        if (typeof versionParam === "string") {
+          version = parseInt(versionParam, 10);
+        } else if (typeof versionParam === "number") {
+          version = versionParam;
+        }
 
         if (version === undefined || Number.isNaN(version)) {
           return res.json({status: "ok" as VersionCheckStatus});
@@ -46,7 +49,10 @@ export class VersionCheckPlugin implements TerrenoPlugin {
         const config = await VersionConfig.findOneOrNone({_singleton: "config"});
 
         if (!config) {
-          return res.json({status: "ok" as VersionCheckStatus});
+          return res.json({
+            pollingIntervalMs: DEFAULT_POLLING_INTERVAL_MINUTES * 60 * 1000,
+            status: "ok" as VersionCheckStatus,
+          });
         }
 
         const requiredVersion =
@@ -59,6 +65,8 @@ export class VersionCheckPlugin implements TerrenoPlugin {
             : (config.mobileWarningVersion ?? 0);
 
         const response: VersionCheckResponse = {
+          pollingIntervalMs:
+            (config.pollingIntervalMinutes ?? DEFAULT_POLLING_INTERVAL_MINUTES) * 60 * 1000,
           requiredVersion: requiredVersion > 0 ? requiredVersion : undefined,
           status: "ok",
           updateUrl: config.updateUrl || undefined,