@budibase/worker 3.27.5 → 3.28.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "3.27.5",
+  "version": "3.28.0",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -107,5 +107,5 @@
       }
     }
   },
-  "gitHead": "46316dfbbf8e41a547bc8a4977ccd819a7515b9a"
+  "gitHead": "b57235144ae6ed94b1b54d9ea73335106feedc02"
 }

package/src/api/controllers/global/github.ts

@@ -0,0 +1,77 @@
+import fetch from "node-fetch"
+import { type GetGitHubStarsResponse, type UserCtx } from "@budibase/types"
+import { cache } from "@budibase/backend-core"
+
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000
+const FAILURE_TTL_MS = 5 * 60 * 1000
+const GITHUB_TIMEOUT_MS = 5000
+const GITHUB_REPO_URL = "https://api.github.com/repos/budibase/budibase"
+const USER_AGENT = "Budibase"
+
+const CACHE_KEY = "global:github:stars"
+const RETENTION_TTL_SECONDS = 30 * 24 * 60 * 60
+
+interface StarsCacheEnvelope {
+  value: GetGitHubStarsResponse
+  expiresAt: number
+}
+
+export async function getStars(ctx: UserCtx<void, GetGitHubStarsResponse>) {
+  const envelope = (await cache.get(CACHE_KEY, {
+    useTenancy: false,
+  })) as StarsCacheEnvelope | null
+  if (envelope && envelope.expiresAt > Date.now()) {
+    ctx.body = envelope.value
+    return
+  }
+
+  try {
+    const response = await fetch(GITHUB_REPO_URL, {
+      headers: {
+        Accept: "application/vnd.github+json",
+        "User-Agent": USER_AGENT,
+      },
+      timeout: GITHUB_TIMEOUT_MS,
+    })
+
+    if (!response.ok) {
+      throw new Error(`GitHub response: ${response.status}`)
+    }
+
+    const json = (await response.json()) as { stargazers_count?: number }
+    const stars = json.stargazers_count
+
+    if (typeof stars !== "number") {
+      throw new Error("GitHub stars missing")
+    }
+
+    const value: GetGitHubStarsResponse = {
+      stars,
+      fetchedAt: new Date().toISOString(),
+    }
+    const toStore: StarsCacheEnvelope = {
+      value,
+      expiresAt: Date.now() + CACHE_TTL_MS,
+    }
+
+    await cache.store(CACHE_KEY, toStore, RETENTION_TTL_SECONDS, {
+      useTenancy: false,
+    })
+
+    ctx.body = value
+  } catch (err) {
+    console.error("Failed to fetch GitHub stars", err)
+
+    const value = envelope?.value || { stars: null, fetchedAt: null }
+    const toStore: StarsCacheEnvelope = {
+      value,
+      expiresAt: Date.now() + FAILURE_TTL_MS,
+    }
+
+    await cache.store(CACHE_KEY, toStore, RETENTION_TTL_SECONDS, {
+      useTenancy: false,
+    })
+
+    ctx.body = value
+  }
+}

package/src/api/controllers/global/tests/github.spec.ts

@@ -0,0 +1,193 @@
+import { type GetGitHubStarsResponse } from "@budibase/types"
+
+jest.mock("node-fetch", () => jest.fn())
+
+interface CacheOpts {
+  useTenancy?: boolean
+}
+
+interface TestCtx {
+  body: GetGitHubStarsResponse | undefined
+}
+
+describe("GitHub controller", () => {
+  let cacheGet: jest.Mock
+  let cacheStore: jest.Mock
+  let cacheState: Map<string, unknown>
+  let consoleErrorSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    jest.resetModules()
+    jest.clearAllMocks()
+
+    jest.useFakeTimers()
+    jest.setSystemTime(new Date("2020-01-01T00:00:00.000Z"))
+
+    consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {})
+
+    cacheState = new Map()
+    jest.doMock("@budibase/backend-core", () => {
+      cacheGet = jest.fn(async (key: string, opts?: CacheOpts) => {
+        if (opts?.useTenancy !== false) {
+          throw new Error("Expected global cache usage")
+        }
+        return cacheState.get(key) ?? null
+      })
+
+      cacheStore = jest.fn(
+        async (
+          key: string,
+          value: unknown,
+          _ttl?: number,
+          opts?: CacheOpts
+        ) => {
+          if (opts?.useTenancy !== false) {
+            throw new Error("Expected global cache usage")
+          }
+          cacheState.set(key, value)
+        }
+      )
+
+      return {
+        cache: {
+          get: cacheGet,
+          store: cacheStore,
+        },
+      }
+    })
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+    jest.useRealTimers()
+  })
+
+  const getFetchMock = () => {
+    return jest.requireMock("node-fetch") as unknown as jest.Mock
+  }
+
+  const makeCtx = () => {
+    const ctx: TestCtx = { body: undefined }
+    return ctx
+  }
+
+  function assertHasBody(
+    ctx: TestCtx
+  ): asserts ctx is { body: GetGitHubStarsResponse } {
+    if (!ctx.body) {
+      throw new Error("Expected ctx.body to be set")
+    }
+  }
+
+  it("adds a request timeout", async () => {
+    const fetchMock = getFetchMock()
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ stargazers_count: 123 }),
+    })
+
+    const { getStars } = require("../github")
+    const ctx = makeCtx()
+    await getStars(ctx)
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    expect(fetchMock.mock.calls[0][1]).toEqual(
+      expect.objectContaining({ timeout: 5000 })
+    )
+    assertHasBody(ctx)
+    expect(ctx.body.stars).toEqual(123)
+
+    expect(cacheGet).toHaveBeenCalledWith("global:github:stars", {
+      useTenancy: false,
+    })
+    expect(cacheStore).toHaveBeenCalledWith(
+      "global:github:stars",
+      expect.any(Object),
+      expect.any(Number),
+      { useTenancy: false }
+    )
+  })
+
+  it("caches successful responses", async () => {
+    const fetchMock = getFetchMock()
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ stargazers_count: 999 }),
+    })
+
+    const { getStars } = require("../github")
+    const ctx1 = makeCtx()
+    await getStars(ctx1)
+    const ctx2 = makeCtx()
+    await getStars(ctx2)
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    expect(ctx2.body).toEqual(ctx1.body)
+  })
+
+  it("serves cached value and sets a short failure TTL on error", async () => {
+    const fetchMock = getFetchMock()
+    fetchMock.mockRejectedValue(new Error("timeout"))
+
+    const { getStars } = require("../github")
+    const ctx1 = makeCtx()
+    await getStars(ctx1)
+    const ctx2 = makeCtx()
+    await getStars(ctx2)
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    expect(ctx1.body).toEqual({ stars: null, fetchedAt: null })
+    expect(ctx2.body).toEqual(ctx1.body)
+  })
+
+  it("returns last known value on refresh failure", async () => {
+    const fetchMock = getFetchMock()
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ stargazers_count: 111 }),
+    })
+
+    const { getStars } = require("../github")
+    const ctx1 = makeCtx()
+    await getStars(ctx1)
+
+    jest.setSystemTime(new Date(Date.now() + 6 * 60 * 60 * 1000 + 1))
+    fetchMock.mockRejectedValue(new Error("github down"))
+
+    const ctx2 = makeCtx()
+    await getStars(ctx2)
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    expect(ctx2.body).toEqual(ctx1.body)
+  })
+
+  it("retries after failure backoff expires", async () => {
+    const fetchMock = getFetchMock()
+    fetchMock.mockRejectedValue(new Error("timeout"))
+
+    const { getStars } = require("../github")
+    const ctx1 = makeCtx()
+    await getStars(ctx1)
+    const ctx2 = makeCtx()
+    await getStars(ctx2)
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+
+    jest.setSystemTime(new Date(Date.now() + 5 * 60 * 1000 + 1))
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ stargazers_count: 222 }),
+    })
+
+    const ctx3 = makeCtx()
+    await getStars(ctx3)
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    assertHasBody(ctx3)
+    expect(ctx3.body.stars).toEqual(222)
+  })
+})

package/src/api/controllers/global/users.ts

@@ -268,10 +268,12 @@ export const adminUser = async (
   })
 }
 
-export const countByApp = async (ctx: UserCtx<void, CountUserResponse>) => {
-  const appId = ctx.params.appId
+export const countByWorkspace = async (
+  ctx: UserCtx<void, CountUserResponse>
+) => {
+  const workspaceId = ctx.params.workspaceId
   try {
-    ctx.body = await userSdk.db.countUsersByApp(appId)
+    ctx.body = await userSdk.db.countUsersByWorkspace(workspaceId)
   } catch (err: any) {
     ctx.throw(err.status || 400, err)
   }

package/src/api/routes/global/github.ts

@@ -0,0 +1,4 @@
+import * as controller from "../../controllers/global/github"
+import { builderRoutes } from "../endpointGroups"
+
+builderRoutes.get("/api/global/github/stars", controller.getStars)

package/src/api/routes/global/users.ts

@@ -92,7 +92,7 @@ adminRoutes
 
 builderOrAdminRoutes
   .get("/api/global/users", controller.fetch)
-  .get("/api/global/users/count/:appId", controller.countByApp)
+  .get("/api/global/users/count/:workspaceId", controller.countByWorkspace)
   .get("/api/global/users/invites", controller.getUserInvites)
   .get("/api/global/users/:id", controller.find)
   .post(

package/src/api/routes/index.ts

@@ -7,6 +7,7 @@ import "./global/auth"
 import "./global/configs"
 import "./global/email"
 import "./global/events"
+import "./global/github"
 import "./global/license"
 import "./global/roles"
 import "./global/self"