Add licenseXService

presleyp · presleyp · commit ead0ab44619b · 2022-07-15T18:01:06.000Z
diff --git a/site/src/api/types.ts b/site/src/api/types.ts
@@ -14,3 +14,17 @@ export interface ReconnectingPTYRequest {
 export type WorkspaceBuildTransition = "start" | "stop" | "delete"
 
 export type Message = { message: string }
+
+export type LicensePermission = "audit" | "createUser" | "createOrg"
+
+export type LicenseFeatures = Record<LicensePermission, {
+  entitled: boolean
+  enabled: boolean
+  limit?: number
+  actual?: number
+}>
+
+export type LicenseData = {
+  features: LicenseFeatures
+  warnings: string[]
+}
diff --git a/site/src/xServices/StateContext.tsx b/site/src/xServices/StateContext.tsx
@@ -4,6 +4,7 @@ import { useNavigate } from "react-router"
 import { ActorRefFrom } from "xstate"
 import { authMachine } from "./auth/authXService"
 import { buildInfoMachine } from "./buildInfo/buildInfoXService"
+import { licenseMachine } from "./license/licenseXService"
 import { siteRolesMachine } from "./roles/siteRolesXService"
 import { usersMachine } from "./users/usersXService"
 
@@ -12,6 +13,7 @@ interface XServiceContextType {
   buildInfoXService: ActorRefFrom<typeof buildInfoMachine>
   usersXService: ActorRefFrom<typeof usersMachine>
   siteRolesXService: ActorRefFrom<typeof siteRolesMachine>
+  licenseXService: ActorRefFrom<typeof licenseMachine>
 }
 
 /**
@@ -39,6 +41,7 @@ export const XServiceProvider: React.FC = ({ children }) => {
           usersMachine.withConfig({ actions: { redirectToUsersPage } }),
         ),
         siteRolesXService: useInterpret(siteRolesMachine),
+        licenseXService: useInterpret(licenseMachine)
       }}
     >
       {children}
diff --git a/site/src/xServices/license/licenseSelectors.ts b/site/src/xServices/license/licenseSelectors.ts
@@ -0,0 +1,24 @@
+import { State } from "xstate"
+import { LicensePermission } from "../../api/types"
+import { LicenseContext, LicenseEvent } from "./licenseXService"
+type LicenseState = State<LicenseContext, LicenseEvent>
+
+export const selectLicenseVisibility = (state: LicenseState): Record<LicensePermission, boolean> => {
+  const features = state.context.licenseData.features
+  const featureNames = Object.keys(features) as LicensePermission[]
+  const visibilityPairs = featureNames.map((feature: LicensePermission) => {
+    return [feature, features[feature].enabled]
+  })
+  return Object.fromEntries(visibilityPairs)
+}
+
+export const selectLicenseEntitlement = (state: LicenseState): Record<LicensePermission, boolean> => {
+  const features = state.context.licenseData.features
+  const featureNames = Object.keys(features) as LicensePermission[]
+  const permissionPairs = featureNames.map((feature: LicensePermission) => {
+    const { entitled, limit, actual } = features[feature]
+    const limitCompliant = limit && actual && limit >= actual
+    return [feature, entitled && limitCompliant]
+  })
+  return Object.fromEntries(permissionPairs)
+}
diff --git a/site/src/xServices/license/licenseXService.ts b/site/src/xServices/license/licenseXService.ts
@@ -0,0 +1,94 @@
+import { assign, createMachine } from "xstate"
+import * as API from "../../api/api"
+import { LicenseData  } from "../../api/types"
+
+export const Language = {
+  getLicenseError: "Error getting license information.",
+}
+
+/* deserves more thought but this is one way to handle unlicensed cases */
+const defaultLicenseData = {
+  warnings: [],
+  features: {
+    audit: {
+      enabled: false,
+      entitled: false
+    },
+    createUser: {
+      enabled: true,
+      entitled: true,
+      limit: 0
+    },
+    createOrg: {
+      enabled: false,
+      entitled: false
+    }
+  }
+}
+
+export type LicenseContext = {
+  licenseData: LicenseData
+  getLicenseError?: Error | unknown
+}
+
+export type LicenseEvent = {
+  type: "GET_LICENSE_DATA"
+}
+
+export const licenseMachine = createMachine(
+  {
+    id: "licenseMachine",
+    initial: "idle",
+    schema: {
+      context: {} as LicenseContext,
+      events: {} as LicenseEvent,
+      services: {
+        getLicenseData: {
+          data: {} as LicenseData,
+        },
+      },
+    },
+    tsTypes: {} as import("./licenseXService.typegen").Typegen0,
+    context: {
+      licenseData: defaultLicenseData
+    },
+    states: {
+      idle: {
+        on: {
+          GET_LICENSE_DATA: "gettingLicenseData",
+        },
+      },
+      gettingLicenseData: {
+        entry: "clearGetLicenseError",
+        invoke: {
+          id: "getLicenseData",
+          src: "getLicenseData",
+          onDone: {
+            target: "idle",
+            actions: ["assignLicenseData"],
+          },
+          onError: {
+            target: "idle",
+            actions: ["assignGetLicenseError"],
+          },
+        },
+      },
+    },
+  },
+  {
+    actions: {
+      assignLicenseData: assign({
+        licenseData: (_, event) => event.data,
+      }),
+      assignGetLicenseError: assign({
+        getLicenseError: (_, event) => event.data,
+      }),
+      clearGetLicenseError: assign({
+        getLicenseError: (_) => undefined,
+      }),
+    },
+    services: {
+      getLicenseData: () => API.getLicenseData(),
+    },
+  },
+)
