(feat): Add implicit conditions to configuration schema

packages/framework/esm-api/src/shared-api-objects/current-user.ts

@@ -1,6 +1,7 @@
 /** @module @category API */
 import { reportError } from "@openmrs/esm-error-handling";
 import { createGlobalStore } from "@openmrs/esm-state";
+import isUndefined from "lodash-es/isUndefined";
 import { Observable } from "rxjs";
 import { openmrsFetch, sessionEndpoint } from "../openmrs-fetch";
 import type {
@@ -122,15 +123,28 @@ function setUserLanguage(data: Session) {
 }
 
 function userHasPrivilege(
-  requiredPrivilege: string,
+  requiredPrivilege: string | string[],
   user: { privileges: Array<Privilege> }
 ) {
-  return user.privileges.find((p) => requiredPrivilege === p.display);
+  if (typeof requiredPrivilege === "string") {
+    return !isUndefined(
+      user.privileges.find((p) => requiredPrivilege === p.display)
+    );
+  } else if (Array.isArray(requiredPrivilege)) {
+    return requiredPrivilege.every(
+      (rp) => !isUndefined(user.privileges.find((p) => rp === p.display))
+    );
+  } else {
+    console.error(`Could not understand privileges "${requiredPrivilege}"`);
+  }
+
+  return true;
 }
 
 function isSuperUser(user: { roles: Array<Role> }) {
-  const superUserRole = "System Developer";
-  return user.roles.find((role) => role.display === superUserRole);
+  return !isUndefined(
+    user.roles.find((role) => role.display === "System Developer")
+  );
 }
 
 /**
@@ -179,7 +193,7 @@ export function clearCurrentUser() {
 }
 
 export function userHasAccess(
-  requiredPrivilege: string,
+  requiredPrivilege: string | string[],
   user: { privileges: Array<Privilege>; roles: Array<Role> }
 ) {
   return userHasPrivilege(requiredPrivilege, user) || isSuperUser(user);

packages/framework/esm-config/src/module-config/module-config.test.ts

@@ -201,6 +201,20 @@ describe("defineConfigSchema", () => {
     Config.defineConfigSchema("mod-mod", schema);
     expect(console.error).not.toHaveBeenCalled();
   });
+
+  it("logs an error if the schema attempts to include a key named 'Display conditions'", () => {
+    const schema = {
+      "Display conditions": {
+        _type: Type.Array,
+        _default: [],
+      },
+    };
+
+    Config.defineConfigSchema("mod-mod", schema);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/mod-mod.*\bDisplay conditions\b/)
+    );
+  });
 });
 
 describe("getConfig", () => {
@@ -301,7 +315,11 @@ describe("getConfig", () => {
     Config.provide(goodConfig);
     const result = await Config.getConfig("foo-module");
     expect(result).toStrictEqual({
-      bar: { a: { b: 0 }, c: 2, diff: 2 },
+      bar: {
+        a: { b: 0 },
+        c: 2,
+        diff: 2,
+      },
     });
   });
 
@@ -485,16 +503,14 @@ describe("getConfig", () => {
     Config.defineConfigSchema("object-def", {
       furi: {
         _type: Type.Object,
-        _elements: {
-          gohan: { _type: Type.String },
-        },
-        _default: {
-          kake: { gohan: "ok" },
-        },
+        _elements: { gohan: { _type: Type.String } },
+        _default: { kake: { gohan: "ok" } },
       },
     });
     const config = await Config.getConfig("object-def");
-    expect(config).toStrictEqual({ furi: { kake: { gohan: "ok" } } });
+    expect(config).toStrictEqual({
+      furi: { kake: { gohan: "ok" } },
+    });
   });
 
   it("interpolates freeform object element defaults", async () => {
@@ -823,9 +839,29 @@ describe("implementer tools config", () => {
           _description: "All the foo",
           _validators: [],
         },
+        "Display conditions": {
+          privileges: {
+            _default: [],
+            _description:
+              "The privilege(s) the user must have to use this extension",
+            _source: "default",
+            _type: Type.Array,
+            _value: [],
+          },
+        },
       },
       "bar-module": {
         bar: { _value: "baz", _source: "my config source", _default: "quinn" },
+        "Display conditions": {
+          privileges: {
+            _default: [],
+            _description:
+              "The privilege(s) the user must have to use this extension",
+            _source: "default",
+            _type: Type.Array,
+            _value: [],
+          },
+        },
       },
     });
   });
@@ -975,6 +1011,16 @@ describe("extension slot config", () => {
             remove: { _value: ["bar"], _source: "provided" },
           },
         },
+        "Display conditions": {
+          privileges: {
+            _default: [],
+            _description:
+              "The privilege(s) the user must have to use this extension",
+            _source: "default",
+            _type: Type.Array,
+            _value: [],
+          },
+        },
       },
     });
   });
@@ -1009,7 +1055,11 @@ describe("extension config", () => {
     updateConfigExtensionStore();
     Config.provide(moduleLevelConfig);
     const result = getExtensionConfig("barSlot", "fooExt").config;
-    expect(result).toStrictEqual({ bar: "qux", baz: "bazzy" });
+    expect(result).toStrictEqual({
+      bar: "qux",
+      baz: "bazzy",
+      "Display conditions": { privileges: [] },
+    });
     expect(console.error).not.toHaveBeenCalled();
   });
 
@@ -1027,7 +1077,11 @@ describe("extension config", () => {
     };
     Config.provide(configureConfig);
     const result = getExtensionConfig("barSlot", "fooExt#id0").config;
-    expect(result).toStrictEqual({ bar: "qux", baz: "quiz" });
+    expect(result).toStrictEqual({
+      bar: "qux",
+      baz: "quiz",
+      "Display conditions": { privileges: [] },
+    });
     expect(console.error).not.toHaveBeenCalled();
   });
 
@@ -1057,7 +1111,10 @@ describe("extension config", () => {
     const extensionAtBaseConfig = { fooExt: { qux: "quxolotl" } };
     Config.provide(extensionAtBaseConfig);
     const result = getExtensionConfig("barSlot", "fooExt").config;
-    expect(result).toStrictEqual({ qux: "quxolotl" });
+    expect(result).toStrictEqual({
+      qux: "quxolotl",
+      "Display conditions": { privileges: [] },
+    });
     expect(console.error).not.toHaveBeenCalled();
   });
 
@@ -1078,7 +1135,10 @@ describe("extension config", () => {
     };
     Config.provide(configureConfig);
     const result = getExtensionConfig("barSlot", "fooExt#id2").config;
-    expect(result).toStrictEqual({ qux: "quxotic" });
+    expect(result).toStrictEqual({
+      qux: "quxotic",
+      "Display conditions": { privileges: [] },
+    });
   });
 
   it("validates the extension configure config, with extension config schema", () => {

packages/framework/esm-config/src/module-config/module-config.ts

@@ -1,5 +1,5 @@
 /** @module @category Config */
-import { clone, reduce, mergeDeepRight, equals } from "ramda";
+import { clone, reduce, mergeDeepRight, equals, omit } from "ramda";
 import {
   Config,
   ConfigObject,
@@ -27,7 +27,6 @@ import {
   implementerToolsConfigStore,
   temporaryConfigStore,
   getExtensionSlotsConfigStore,
-  ExtensionsConfigStore,
 } from "./state";
 import type {} from "@openmrs/esm-globals";
 import { TemporaryConfigStore } from "..";
@@ -192,9 +191,14 @@ function computeExtensionConfigs(
  */
 export function defineConfigSchema(moduleName: string, schema: ConfigSchema) {
   validateConfigSchema(moduleName, schema);
+  const enhancedSchema = mergeDeepRight(
+    schema,
+    displayConditionsSchema
+  ) as ConfigSchema;
+
   const state = configInternalStore.getState();
   configInternalStore.setState({
-    schemas: { ...state.schemas, [moduleName]: schema },
+    schemas: { ...state.schemas, [moduleName]: enhancedSchema },
   });
 }
 
@@ -220,14 +224,20 @@ export function defineExtensionConfigSchema(
   schema: ConfigSchema
 ) {
   validateConfigSchema(extensionName, schema);
+  const enhancedSchema = mergeDeepRight(
+    schema,
+    displayConditionsSchema
+  ) as ConfigSchema;
+
   const state = configInternalStore.getState();
   if (state.schemas[extensionName]) {
     console.warn(
       `Config schema for extension ${extensionName} already exists. If there are multiple extensions with this same name, one will probably crash.`
     );
   }
+
   configInternalStore.setState({
-    schemas: { ...state.schemas, [extensionName]: schema },
+    schemas: { ...state.schemas, [extensionName]: enhancedSchema },
   });
 }
 
@@ -256,7 +266,8 @@ export function getConfig(moduleName: string): Promise<Config> {
     const store = getConfigStore(moduleName);
     function update(state: ConfigStore) {
       if (state.loaded && state.config) {
-        resolve(state.config);
+        const config = omit(["Display conditions"], state.config);
+        resolve(config);
         unsubscribe && unsubscribe();
       }
     }
@@ -362,7 +373,7 @@ function getSchemaWithValuesAndSources(schema) {
       return obj;
     }, {});
   } else {
-    // Schema is bad; error will have been logged during schema validation
+    // at this point, the schema is bad and an error will have been logged during schema validation
     return {};
   }
 }
@@ -492,6 +503,12 @@ function validateConfigSchema(
     const thisKeyPath = keyPath + (keyPath && ".") + key;
     const schemaPart = schema[key] as ConfigSchema;
 
+    if (thisKeyPath === "Display conditions") {
+      console.error(
+        `${moduleName} declares a configuration option called "Display conditions"; the "Display conditions" option is a reserved name. ${updateMessage}`
+      );
+    }
+
     if (!isOrdinaryObject(schemaPart)) {
       console.error(
         `${moduleName} has bad config schema definition for key '${thisKeyPath}'. ${updateMessage}`
@@ -863,3 +880,16 @@ function getExtensionNameFromId(extensionId: string) {
   const [extensionName] = extensionId.split("#");
   return extensionName;
 }
+
+/**
+ * The displayConditionsSchema is implicitly included in every configuration schema
+ */
+const displayConditionsSchema: ConfigSchema = {
+  "Display conditions": {
+    privileges: {
+      _description: "The privilege(s) the user must have to use this extension",
+      _type: Type.Array,
+      _default: [],
+    },
+  },
+};

packages/framework/esm-config/src/types.ts

@@ -27,6 +27,11 @@ export interface Config extends Object {
 
 export interface ConfigObject extends Object {
   [key: string]: any;
+  "Display conditions"?: DisplayConditionsConfigObject;
+}
+
+export interface DisplayConditionsConfigObject {
+  privileges?: string[];
 }
 
 export type ConfigValue =

packages/framework/esm-extensions/src/extensions.test.ts

@@ -1,5 +1,15 @@
+import { createGlobalStore } from "@openmrs/esm-state";
 import { attach, registerExtensionSlot } from "./extensions";
 
+const mockSessionStore = createGlobalStore("mock-session-store", {
+  loaded: false,
+  session: null,
+});
+
+jest.mock("@openmrs/esm-api", () => ({
+  getSessionStore: jest.fn(() => mockSessionStore),
+}));
+
 describe("extensions system", () => {
   it("shouldn't crash when a slot is registered before the extensions that go in it", () => {
     attach("mario-slot", "mario-hat");

packages/framework/esm-extensions/src/extensions.ts

@@ -8,6 +8,7 @@
  * - connected (computed from assigned using connectivity and online / offline)
  */
 
+import { getSessionStore, LoggedInUser, userHasAccess } from "@openmrs/esm-api";
 import {
   ExtensionsConfigStore,
   ExtensionSlotConfigObject,
@@ -19,6 +20,7 @@ import {
   getExtensionSlotsConfigStore,
 } from "@openmrs/esm-config";
 import isEqual from "lodash-es/isEqual";
+import isUndefined from "lodash-es/isUndefined";
 import {
   getExtensionInternalStore,
   ExtensionSlotState,
@@ -301,6 +303,8 @@ function getAssignedExtensionsFromSlotData(
   const attachedIds = internalState.slots[slotName].attachedIds;
   const assignedIds = calculateAssignedIds(config, attachedIds);
   const extensions: Array<AssignedExtension> = [];
+  let user: LoggedInUser | undefined = undefined;
+
   for (let id of assignedIds) {
     const { config: extensionConfig } = getExtensionConfigFromStore(
       extensionConfigStoreState,
@@ -311,6 +315,27 @@ function getAssignedExtensionsFromSlotData(
     const extension = internalState.extensions[name];
     // if the extension has not been registered yet, do not include it
     if (extension) {
+      const requiredPrivileges =
+        extensionConfig?.["Display conditions"]?.privileges ??
+        extension.privileges;
+      if (
+        requiredPrivileges &&
+        (typeof requiredPrivileges === "string" ||
+          (Array.isArray(requiredPrivileges) && requiredPrivileges.length > 0))
+      ) {
+        if (isUndefined(user)) {
+          user = getSessionStore().getState().session?.user;
+        }
+
+        if (!user) {
+          continue;
+        }
+
+        if (!userHasAccess(requiredPrivileges, user)) {
+          continue;
+        }
+      }
+
       extensions.push({
         id,
         name,
@@ -325,6 +350,12 @@ function getAssignedExtensionsFromSlotData(
   return extensions;
 }
 
+/**
+ * Gets the list of extensions assigned to a given slot
+ *
+ * @param slotName The slot to load the assigned extensions for
+ * @returns An array of extensions assigned to the named slot
+ */
 export function getAssignedExtensions(
   slotName: string
 ): Array<AssignedExtension> {