@budibase/worker 2.8.22-alpha.1 → 2.8.22-alpha.3

package/__mocks__/@budibase/pro.ts

@@ -0,0 +1,27 @@
+const actual = jest.requireActual("@budibase/pro")
+const pro = {
+  ...actual,
+  licensing: {
+    keys: {
+      activateLicenseKey: jest.fn(),
+      getLicenseKey: jest.fn(),
+      deleteLicenseKey: jest.fn(),
+    },
+    offline: {
+      activateOfflineLicenseToken: jest.fn(),
+      getOfflineLicenseToken: jest.fn(),
+      deleteOfflineLicenseToken: jest.fn(),
+      getIdentifierBase64: jest.fn(),
+    },
+    cache: {
+      ...actual.licensing.cache,
+      refresh: jest.fn(),
+    },
+  },
+  quotas: {
+    ...actual.quotas,
+    getQuotaUsage: jest.fn(),
+  },
+}
+
+export = pro

package/openapi-3.0.yaml

@@ -0,0 +1,133 @@
+openapi: 3.0.0
+info:
+  title: Worker API Specification
+  version: 1.0.0
+servers:
+  - url: "http://localhost:10000"
+    description: localhost
+  - url: "https://budibaseqa.app"
+    description: QA
+  - url: "https://preprod.qa.budibase.net"
+    description: Preprod
+  - url: "https://budibase.app"
+    description: Production
+
+tags:
+  - name: license
+    description: License operations
+
+paths:
+  /api/global/license/key:
+    post:
+      tags:
+        - license
+      summary: Activate license key
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ActivateLicenseKeyRequest'
+      responses:
+        '200':
+          description: Success
+    get:
+      tags:
+        - license
+      summary: Get license key
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GetLicenseKeyResponse'
+    delete:
+      tags:
+        - license
+      summary: Delete license key
+      responses:
+        '204':
+          description: No content
+  /api/global/license/offline:
+    post:
+      tags:
+        - license
+      summary: Activate offline license
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ActivateOfflineLicenseTokenRequest'
+      responses:
+        '200':
+          description: Success
+    get:
+      tags:
+        - license
+      summary: Get offline license
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GetOfflineLicenseTokenResponse'
+    delete:
+      tags:
+        - license
+      summary: Delete offline license
+      responses:
+        '204':
+          description: No content
+  /api/global/license/offline/identifier:
+    get:
+      tags:
+        - license
+      summary: Get offline identifier
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GetOfflineIdentifierResponse'
+
+components:
+  schemas:
+    ActivateOfflineLicenseTokenRequest:
+      type: object
+      properties:
+        offlineLicenseToken:
+          type: string
+      required:
+        - offlineLicenseToken
+    GetOfflineLicenseTokenResponse:
+      type: object
+      properties:
+        offlineLicenseToken:
+          type: string
+      required:
+        - offlineLicenseToken
+    ActivateLicenseKeyRequest:
+      type: object
+      properties:
+        licenseKey:
+          type: string
+      required:
+        - licenseKey
+    GetLicenseKeyResponse:
+      type: object
+      properties:
+        licenseKey:
+          type: string
+      required:
+        - licenseKey
+    GetOfflineIdentifierResponse:
+      type: object
+      properties:
+        identifierBase64:
+          type: string
+      required:
+        - identifierBase64

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "2.8.22-alpha.1",
+  "version": "2.8.22-alpha.3",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -38,10 +38,10 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "2.8.22-alpha.1",
-    "@budibase/pro": "2.8.22-alpha.1",
-    "@budibase/string-templates": "2.8.22-alpha.1",
-    "@budibase/types": "2.8.22-alpha.1",
+    "@budibase/backend-core": "2.8.22-alpha.3",
+    "@budibase/pro": "2.8.22-alpha.3",
+    "@budibase/string-templates": "2.8.22-alpha.3",
+    "@budibase/types": "2.8.22-alpha.3",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
@@ -104,5 +104,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "efcef8d6f8ce0744d1f80f8161a41f55ef6c8ea4"
+  "gitHead": "c628700e78b58122ffd2cc83a39360e12b7f3046"
 }

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

@@ -1,34 +1,83 @@
 import { licensing, quotas } from "@budibase/pro"
+import {
+  ActivateLicenseKeyRequest,
+  ActivateOfflineLicenseTokenRequest,
+  GetLicenseKeyResponse,
+  GetOfflineIdentifierResponse,
+  GetOfflineLicenseTokenResponse,
+  UserCtx,
+} from "@budibase/types"
 
-export const activate = async (ctx: any) => {
+// LICENSE KEY
+
+export async function activateLicenseKey(
+  ctx: UserCtx<ActivateLicenseKeyRequest>
+) {
   const { licenseKey } = ctx.request.body
-  if (!licenseKey) {
-    ctx.throw(400, "licenseKey is required")
+  await licensing.keys.activateLicenseKey(licenseKey)
+  ctx.status = 200
+}
+
+export async function getLicenseKey(ctx: UserCtx<void, GetLicenseKeyResponse>) {
+  const licenseKey = await licensing.keys.getLicenseKey()
+  if (licenseKey) {
+    ctx.body = { licenseKey: "*" }
+    ctx.status = 200
+  } else {
+    ctx.status = 404
   }
+}
 
-  await licensing.activateLicenseKey(licenseKey)
-  ctx.status = 200
+export async function deleteLicenseKey(ctx: UserCtx<void, void>) {
+  await licensing.keys.deleteLicenseKey()
+  ctx.status = 204
 }
 
-export const refresh = async (ctx: any) => {
-  await licensing.cache.refresh()
+// OFFLINE LICENSE
+
+export async function activateOfflineLicenseToken(
+  ctx: UserCtx<ActivateOfflineLicenseTokenRequest>
+) {
+  const { offlineLicenseToken } = ctx.request.body
+  await licensing.offline.activateOfflineLicenseToken(offlineLicenseToken)
   ctx.status = 200
 }
 
-export const getInfo = async (ctx: any) => {
-  const licenseInfo = await licensing.getLicenseInfo()
-  if (licenseInfo) {
-    licenseInfo.licenseKey = "*"
-    ctx.body = licenseInfo
+export async function getOfflineLicenseToken(
+  ctx: UserCtx<void, GetOfflineLicenseTokenResponse>
+) {
+  const offlineLicenseToken = await licensing.offline.getOfflineLicenseToken()
+  if (offlineLicenseToken) {
+    ctx.body = { offlineLicenseToken: "*" }
+    ctx.status = 200
+  } else {
+    ctx.status = 404
   }
+}
+
+export async function deleteOfflineLicenseToken(ctx: UserCtx<void, void>) {
+  await licensing.offline.deleteOfflineLicenseToken()
+  ctx.status = 204
+}
+
+export async function getOfflineLicenseIdentifier(
+  ctx: UserCtx<void, GetOfflineIdentifierResponse>
+) {
+  const identifierBase64 = await licensing.offline.getIdentifierBase64()
+  ctx.body = { identifierBase64 }
   ctx.status = 200
 }
 
-export const deleteInfo = async (ctx: any) => {
-  await licensing.deleteLicenseInfo()
+// LICENSES
+
+export const refresh = async (ctx: any) => {
+  await licensing.cache.refresh()
   ctx.status = 200
 }
 
+// USAGE
+
 export const getQuotaUsage = async (ctx: any) => {
   ctx.body = await quotas.getQuotaUsage()
+  ctx.status = 200
 }

package/src/api/controllers/system/environment.ts

@@ -1,10 +1,11 @@
 import { Ctx } from "@budibase/types"
 import env from "../../../environment"
+import { env as coreEnv } from "@budibase/backend-core"
 
 export const fetch = async (ctx: Ctx) => {
   ctx.body = {
     multiTenancy: !!env.MULTI_TENANCY,
-    offlineMode: !!env.OFFLINE_MODE,
+    offlineMode: !!coreEnv.OFFLINE_MODE,
     cloud: !env.SELF_HOSTED,
     accountPortalUrl: env.ACCOUNT_PORTAL_URL,
     disableAccountPortal: env.DISABLE_ACCOUNT_PORTAL,

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

@@ -1,13 +1,44 @@
 import Router from "@koa/router"
 import * as controller from "../../controllers/global/license"
+import { middleware } from "@budibase/backend-core"
+import Joi from "joi"
+
+const activateLicenseKeyValidator = middleware.joiValidator.body(
+  Joi.object({
+    licenseKey: Joi.string().required(),
+  }).required()
+)
+
+const activateOfflineLicenseValidator = middleware.joiValidator.body(
+  Joi.object({
+    offlineLicenseToken: Joi.string().required(),
+  }).required()
+)
 
 const router: Router = new Router()
 
 router
-  .post("/api/global/license/activate", controller.activate)
   .post("/api/global/license/refresh", controller.refresh)
-  .get("/api/global/license/info", controller.getInfo)
-  .delete("/api/global/license/info", controller.deleteInfo)
   .get("/api/global/license/usage", controller.getQuotaUsage)
+  // LICENSE KEY
+  .post(
+    "/api/global/license/key",
+    activateLicenseKeyValidator,
+    controller.activateLicenseKey
+  )
+  .get("/api/global/license/key", controller.getLicenseKey)
+  .delete("/api/global/license/key", controller.deleteLicenseKey)
+  // OFFLINE LICENSE
+  .post(
+    "/api/global/license/offline",
+    activateOfflineLicenseValidator,
+    controller.activateOfflineLicenseToken
+  )
+  .get("/api/global/license/offline", controller.getOfflineLicenseToken)
+  .delete("/api/global/license/offline", controller.deleteOfflineLicenseToken)
+  .get(
+    "/api/global/license/offline/identifier",
+    controller.getOfflineLicenseIdentifier
+  )
 
 export default router

package/src/api/routes/global/tests/license.spec.ts

@@ -1,4 +1,6 @@
-import { TestConfiguration } from "../../../../tests"
+import { TestConfiguration, mocks, structures } from "../../../../tests"
+const licensing = mocks.pro.licensing
+const quotas = mocks.pro.quotas
 
 describe("/api/global/license", () => {
   const config = new TestConfiguration()
@@ -12,18 +14,105 @@ describe("/api/global/license", () => {
   })
 
   afterEach(() => {
-    jest.clearAllMocks()
+    jest.resetAllMocks()
   })
 
-  describe("POST /api/global/license/activate", () => {
-    it("activates license", () => {})
+  describe("POST /api/global/license/refresh", () => {
+    it("returns 200", async () => {
+      const res = await config.api.license.refresh()
+      expect(res.status).toBe(200)
+      expect(licensing.cache.refresh).toBeCalledTimes(1)
+    })
   })
 
-  describe("POST /api/global/license/refresh", () => {})
+  describe("GET /api/global/license/usage", () => {
+    it("returns 200 + usage", async () => {
+      const usage = structures.quotas.usage()
+      quotas.getQuotaUsage.mockResolvedValue(usage)
+      const res = await config.api.license.getUsage()
+      expect(res.status).toBe(200)
+      expect(res.body).toEqual(usage)
+    })
+  })
+
+  describe("POST /api/global/license/key", () => {
+    it("returns 200", async () => {
+      const res = await config.api.license.activateLicenseKey({
+        licenseKey: "licenseKey",
+      })
+      expect(res.status).toBe(200)
+      expect(licensing.keys.activateLicenseKey).toBeCalledWith("licenseKey")
+    })
+  })
+
+  describe("GET /api/global/license/key", () => {
+    it("returns 404 when not found", async () => {
+      const res = await config.api.license.getLicenseKey()
+      expect(res.status).toBe(404)
+    })
+    it("returns 200 + license key", async () => {
+      licensing.keys.getLicenseKey.mockResolvedValue("licenseKey")
+      const res = await config.api.license.getLicenseKey()
+      expect(res.status).toBe(200)
+      expect(res.body).toEqual({
+        licenseKey: "*",
+      })
+    })
+  })
+
+  describe("DELETE /api/global/license/key", () => {
+    it("returns 204", async () => {
+      const res = await config.api.license.deleteLicenseKey()
+      expect(licensing.keys.deleteLicenseKey).toBeCalledTimes(1)
+      expect(res.status).toBe(204)
+    })
+  })
+
+  describe("POST /api/global/license/offline", () => {
+    it("activates offline license", async () => {
+      const res = await config.api.license.activateOfflineLicense({
+        offlineLicenseToken: "offlineLicenseToken",
+      })
+      expect(licensing.offline.activateOfflineLicenseToken).toBeCalledWith(
+        "offlineLicenseToken"
+      )
+      expect(res.status).toBe(200)
+    })
+  })
 
-  describe("GET /api/global/license/info", () => {})
+  describe("GET /api/global/license/offline", () => {
+    it("returns 404 when not found", async () => {
+      const res = await config.api.license.getOfflineLicense()
+      expect(res.status).toBe(404)
+    })
+    it("returns 200 + offline license token", async () => {
+      licensing.offline.getOfflineLicenseToken.mockResolvedValue(
+        "offlineLicenseToken"
+      )
+      const res = await config.api.license.getOfflineLicense()
+      expect(res.status).toBe(200)
+      expect(res.body).toEqual({
+        offlineLicenseToken: "*",
+      })
+    })
+  })
 
-  describe("DELETE /api/global/license/info", () => {})
+  describe("DELETE /api/global/license/offline", () => {
+    it("returns 204", async () => {
+      const res = await config.api.license.deleteOfflineLicense()
+      expect(res.status).toBe(204)
+      expect(licensing.offline.deleteOfflineLicenseToken).toBeCalledTimes(1)
+    })
+  })
 
-  describe("GET /api/global/license/usage", () => {})
+  describe("GET /api/global/license/offline/identifier", () => {
+    it("returns 200 + identifier base64", async () => {
+      licensing.offline.getIdentifierBase64.mockResolvedValue("base64")
+      const res = await config.api.license.getOfflineLicenseIdentifier()
+      expect(res.status).toBe(200)
+      expect(res.body).toEqual({
+        identifierBase64: "base64",
+      })
+    })
+  })
 })

package/src/environment.ts

@@ -61,7 +61,6 @@ const environment = {
   CHECKLIST_CACHE_TTL: parseIntSafe(process.env.CHECKLIST_CACHE_TTL) || 3600,
   SESSION_UPDATE_PERIOD: process.env.SESSION_UPDATE_PERIOD,
   ENCRYPTED_TEST_PUBLIC_API_KEY: process.env.ENCRYPTED_TEST_PUBLIC_API_KEY,
-  OFFLINE_MODE: process.env.OFFLINE_MODE,
   /**
    * Mock the email service in use - links to ethereal hosted emails are logged instead.
    */

package/src/tests/TestConfiguration.ts

@@ -1,8 +1,7 @@
 import mocks from "./mocks"
 
 // init the licensing mock
-import * as pro from "@budibase/pro"
-mocks.licenses.init(pro)
+mocks.licenses.init(mocks.pro)
 
 // use unlimited license by default
 mocks.licenses.useUnlimited()
@@ -238,21 +237,21 @@ class TestConfiguration {
 
       const db = context.getGlobalDB()
 
-      const id = dbCore.generateDevInfoID(this.user._id)
+      const id = dbCore.generateDevInfoID(this.user!._id)
       // TODO: dry
       this.apiKey = encryption.encrypt(
         `${this.tenantId}${dbCore.SEPARATOR}${utils.newid()}`
       )
       const devInfo = {
         _id: id,
-        userId: this.user._id,
+        userId: this.user!._id,
         apiKey: this.apiKey,
       }
       await db.put(devInfo)
     })
   }
 
-  async getUser(email: string): Promise<User> {
+  async getUser(email: string): Promise<User | undefined> {
     return context.doInTenant(this.getTenantId(), () => {
       return users.getGlobalUserByEmail(email)
     })
@@ -264,7 +263,7 @@ class TestConfiguration {
     }
     const response = await this._req(user, null, controllers.users.save)
     const body = response as SaveUserResponse
-    return this.getUser(body.email)
+    return this.getUser(body.email) as Promise<User>
   }
 
   // CONFIGS

package/src/tests/api/license.ts

@@ -1,17 +1,62 @@
 import TestConfiguration from "../TestConfiguration"
 import { TestAPI } from "./base"
+import {
+  ActivateLicenseKeyRequest,
+  ActivateOfflineLicenseTokenRequest,
+} from "@budibase/types"
 
 export class LicenseAPI extends TestAPI {
   constructor(config: TestConfiguration) {
     super(config)
   }
 
-  activate = async (licenseKey: string) => {
+  refresh = async () => {
     return this.request
-      .post("/api/global/license/activate")
-      .send({ licenseKey: licenseKey })
+      .post("/api/global/license/refresh")
+      .set(this.config.defaultHeaders())
+  }
+  getUsage = async () => {
+    return this.request
+      .get("/api/global/license/usage")
       .set(this.config.defaultHeaders())
       .expect("Content-Type", /json/)
       .expect(200)
   }
+  activateLicenseKey = async (body: ActivateLicenseKeyRequest) => {
+    return this.request
+      .post("/api/global/license/key")
+      .send(body)
+      .set(this.config.defaultHeaders())
+  }
+  getLicenseKey = async () => {
+    return this.request
+      .get("/api/global/license/key")
+      .set(this.config.defaultHeaders())
+  }
+  deleteLicenseKey = async () => {
+    return this.request
+      .delete("/api/global/license/key")
+      .set(this.config.defaultHeaders())
+  }
+  activateOfflineLicense = async (body: ActivateOfflineLicenseTokenRequest) => {
+    return this.request
+      .post("/api/global/license/offline")
+      .send(body)
+      .set(this.config.defaultHeaders())
+  }
+  getOfflineLicense = async () => {
+    return this.request
+      .get("/api/global/license/offline")
+      .set(this.config.defaultHeaders())
+  }
+  deleteOfflineLicense = async () => {
+    return this.request
+      .delete("/api/global/license/offline")
+      .set(this.config.defaultHeaders())
+  }
+  getOfflineLicenseIdentifier = async () => {
+    return this.request
+      .get("/api/global/license/offline/identifier")
+      .set(this.config.defaultHeaders())
+  }
 }

package/src/tests/mocks/index.ts

@@ -1,7 +1,11 @@
 import * as email from "./email"
 import { mocks } from "@budibase/backend-core/tests"
 
+import * as _pro from "@budibase/pro"
+const pro = jest.mocked(_pro, true)
+
 export default {
   email,
+  pro,
   ...mocks,
 }