@openmrs/esm-config 3.2.1-pre.986 → 3.3.1-pre.1173

package/src/module-config/module-config.test.ts

@@ -11,13 +11,14 @@ import {
   configExtensionStore,
   ConfigInternalStore,
   configInternalStore,
-  getExtensionConfigStore,
+  getExtensionConfig,
+  getExtensionsConfigStore,
   ImplementerToolsConfigStore,
   implementerToolsConfigStore,
   temporaryConfigStore,
 } from "./state";
 import { Type } from "../types";
-import { getExtensionSlotConfigStore } from "..";
+import { getExtensionSlotsConfigStore } from "..";
 
 const mockConfigInternalStore =
   configInternalStore as MockedStore<ConfigInternalStore>;
@@ -844,7 +845,7 @@ describe("extension slot config", () => {
     // modules that define schemas.
     Config.provide({
       "foo-module": {
-        extensions: {
+        extensionSlots: {
           fooSlot: {
             add: ["bar", "baz"],
             remove: ["zap"],
@@ -854,7 +855,8 @@ describe("extension slot config", () => {
         },
       },
     });
-    const { config } = getExtensionSlotConfigStore("fooSlot").getState();
+    const { config } =
+      getExtensionSlotsConfigStore().getState().slots["fooSlot"];
     expect(config).toStrictEqual({
       add: ["bar", "baz"],
       remove: ["zap"],
@@ -874,7 +876,7 @@ describe("extension slot config", () => {
     });
     Config.provide({
       "foo-module": {
-        extensions: { fooSlot: { remove: ["bar"] } },
+        extensionSlots: { fooSlot: { remove: ["bar"] } },
       },
     });
     const config = await Config.getConfig("foo-module");
@@ -888,11 +890,12 @@ describe("extension slot config", () => {
     });
     Config.provide({
       "foo-module": {
-        extensions: { fooSlot: { remove: ["bar"] } },
+        extensionSlots: { fooSlot: { remove: ["bar"] } },
       },
     });
     await Config.getConfig("foo-module");
-    const { config } = getExtensionSlotConfigStore("fooSlot").getState();
+    const { config } =
+      getExtensionSlotsConfigStore().getState().slots["fooSlot"];
     expect(config).toStrictEqual({ remove: ["bar"] });
   });
 
@@ -902,14 +905,14 @@ describe("extension slot config", () => {
     });
     Config.provide({
       "foo-module": {
-        extensions: { fooSlot: { remove: ["bar"] } },
+        extensionSlots: { fooSlot: { remove: ["bar"] } },
       },
     });
     const config = implementerToolsConfigStore.getState().config;
     expect(config).toStrictEqual({
       "foo-module": {
         foo: { _default: 0, _value: 0, _source: "default" },
-        extensions: {
+        extensionSlots: {
           fooSlot: {
             remove: { _value: ["bar"], _source: "provided" },
           },
@@ -921,11 +924,13 @@ describe("extension slot config", () => {
   it("validates that no other keys are present for the slot", async () => {
     Config.provide({
       "foo-module": {
-        extensions: { fooSlot: { quitar: ["bar"] } },
+        extensionSlots: { fooSlot: { quitar: ["bar"] } },
       },
     });
     expect(console.error).toHaveBeenCalledWith(
-      expect.stringMatching(/foo-module.extensions.fooSlot.*invalid.*quitar/)
+      expect.stringMatching(
+        /foo-module.extensionSlots.fooSlot.*invalid.*quitar/
+      )
     );
   });
 });
@@ -933,99 +938,152 @@ describe("extension slot config", () => {
 describe("extension config", () => {
   beforeEach(() => {
     console.error = jest.fn();
+    Config.defineConfigSchema("ext-mod", {
+      bar: { _default: "barry" },
+      baz: { _default: "bazzy" },
+    });
   });
 
   afterEach(resetAll);
 
   it("returns the module config", async () => {
-    Config.defineConfigSchema("ext-mod", {
-      bar: { _default: "barry" },
-      baz: { _default: "bazzy" },
-    });
-    const testConfig = { "ext-mod": { bar: "qux" } };
-    Config.provide(testConfig);
-    configExtensionStore.setState({
-      mountedExtensions: [
-        {
-          slotModuleName: "slot-mod",
-          extensionModuleName: "ext-mod",
-          slotName: "barSlot",
-          extensionId: "fooExt",
-        },
-      ],
-    });
-    const config = getExtensionConfigStore(
-      "slot-mod",
-      "barSlot",
-      "fooExt"
-    ).getState().config;
-    expect(config).toStrictEqual({ bar: "qux", baz: "bazzy" });
+    const moduleLevelConfig = { "ext-mod": { bar: "qux" } };
+    updateConfigExtensionStore();
+    Config.provide(moduleLevelConfig);
+    const result = getExtensionConfig("barSlot", "fooExt").config;
+    expect(result).toStrictEqual({ bar: "qux", baz: "bazzy" });
     expect(console.error).not.toHaveBeenCalled();
   });
 
-  it("uses the 'configure' config if one is present", async () => {
-    Config.defineConfigSchema("ext-mod", {
-      bar: { _default: "barry" },
-      baz: { _default: "bazzy" },
-    });
-    const testConfig = {
+  it("uses the 'configure' config if one is present, with module config schema", () => {
+    updateConfigExtensionStore("fooExt#id0");
+    const configureConfig = {
       "ext-mod": { bar: "qux" },
       "slot-mod": {
-        extensions: {
+        extensionSlots: {
           barSlot: {
             configure: { "fooExt#id0": { baz: "quiz" } },
           },
         },
       },
     };
-    Config.provide(testConfig);
-    configExtensionStore.setState({
-      mountedExtensions: [
-        {
-          slotModuleName: "slot-mod",
-          extensionModuleName: "ext-mod",
-          slotName: "barSlot",
-          extensionId: "fooExt#id0",
+    Config.provide(configureConfig);
+    const result = getExtensionConfig("barSlot", "fooExt#id0").config;
+    expect(result).toStrictEqual({ bar: "qux", baz: "quiz" });
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it("validates the extension configure config, with module config schema", () => {
+    updateConfigExtensionStore("fooExt#id1");
+    const badConfig = {
+      "ext-mod": { bar: "qux" },
+      "slot-mod": {
+        extensionSlots: {
+          barSlot: {
+            configure: { "fooExt#id1": { beef: "bad" } },
+          },
         },
-      ],
+      },
+    };
+    Config.provide(badConfig);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/unknown config key 'ext-mod.beef' provided.*/i)
+    );
+  });
+
+  it("returns the extension config if an extension config schema is defined", async () => {
+    updateConfigExtensionStore("fooExt");
+    Config.defineExtensionConfigSchema("fooExt", {
+      qux: { _default: "quxxy" },
     });
-    const config = getExtensionConfigStore(
-      "slot-mod",
-      "barSlot",
-      "fooExt#id0"
-    ).getState().config;
-    expect(config).toStrictEqual({ bar: "qux", baz: "quiz" });
+    const extensionAtBaseConfig = { fooExt: { qux: "quxolotl" } };
+    Config.provide(extensionAtBaseConfig);
+    const result = getExtensionConfig("barSlot", "fooExt").config;
+    expect(result).toStrictEqual({ qux: "quxolotl" });
     expect(console.error).not.toHaveBeenCalled();
   });
 
-  it("validates the extension slot config", async () => {
-    Config.defineConfigSchema("ext-mod", {
-      bar: { _default: "barry" },
-      baz: { _default: "bazzy" },
+  it("uses the 'configure' config if one is present, with extension config schema", () => {
+    updateConfigExtensionStore("fooExt#id2");
+    Config.defineExtensionConfigSchema("fooExt", {
+      qux: { _default: "quxxy" },
     });
-    const testConfig = {
-      "ext-mod": { bar: "qux" },
+    const configureConfig = {
+      fooExt: { qux: "quxolotl" },
       "slot-mod": {
-        extensions: {
+        extensionSlots: {
           barSlot: {
-            configure: { "fooExt#id0": { beef: "bad" } },
+            configure: { "fooExt#id2": { qux: "quxotic" } },
           },
         },
       },
     };
-    Config.provide(testConfig);
-    configExtensionStore.setState({
-      mountedExtensions: [
-        {
-          slotModuleName: "slot-mod",
-          extensionModuleName: "ext-mod",
-          slotName: "barSlot",
-          extensionId: "fooExt#id0",
+    Config.provide(configureConfig);
+    const result = getExtensionConfig("barSlot", "fooExt#id2").config;
+    expect(result).toStrictEqual({ qux: "quxotic" });
+  });
+
+  it("validates the extension configure config, with extension config schema", () => {
+    updateConfigExtensionStore("fooExt#id3");
+    Config.defineExtensionConfigSchema("fooExt", {
+      qux: { _default: "quxxy" },
+    });
+    const configureConfig = {
+      "slot-mod": {
+        extensionSlots: {
+          barSlot: {
+            configure: { "fooExt#id3": { no: "bad" } },
+          },
         },
-      ],
+      },
+    };
+    Config.provide(configureConfig);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/unknown config key 'fooExt.no' provided.*/i)
+    );
+  });
+
+  it("does not accept module config parameters for extension if extension config schema is defined", () => {
+    Config.defineExtensionConfigSchema("fooExt", {
+      qux: { _default: "quxxy" },
     });
+    const badConfigNoModuleConfigsForExtension = {
+      fooExt: {
+        bar: "no good",
+      },
+    };
+    Config.provide(badConfigNoModuleConfigsForExtension);
     expect(console.error).toHaveBeenCalledWith(
-      expect.stringMatching(/unknown config key 'ext-mod.beef' provided.*/i)
+      expect.stringMatching(/unknown config key 'fooExt.bar' provided.*/i)
+    );
+  });
+
+  it("does not accept extension config parameters for the module", () => {
+    updateConfigExtensionStore("fooExt#id5");
+    Config.defineExtensionConfigSchema("fooExt", {
+      qux: { _default: "quxxy" },
+    });
+    const badConfigNoExtensionConfigsForModule = {
+      "ext-mod": {
+        qux: "also bad",
+      },
+    };
+    Config.provide(badConfigNoExtensionConfigsForModule);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/unknown config key 'ext-mod.qux' provided.*/i)
     );
   });
 });
+
+function updateConfigExtensionStore(extensionId = "fooExt") {
+  configExtensionStore.setState({
+    mountedExtensions: [
+      {
+        slotModuleName: "slot-mod",
+        extensionModuleName: "ext-mod",
+        slotName: "barSlot",
+        extensionId,
+      },
+    ],
+  });
+}

package/src/module-config/module-config.ts

@@ -1,4 +1,5 @@
-import { clone, reduce, mergeDeepRight } from "ramda";
+/** @module @category Config */
+import { clone, reduce, mergeDeepRight, equals } from "ramda";
 import {
   Config,
   ConfigObject,
@@ -22,10 +23,11 @@ import {
   ConfigStore,
   configExtensionStore,
   getConfigStore,
-  getExtensionConfigStore,
-  getExtensionSlotConfigStore,
+  getExtensionsConfigStore,
   implementerToolsConfigStore,
   temporaryConfigStore,
+  getExtensionSlotsConfigStore,
+  ExtensionsConfigStore,
 } from "./state";
 import type {} from "@openmrs/esm-globals";
 import { TemporaryConfigStore } from "..";
@@ -46,7 +48,8 @@ import { TemporaryConfigStore } from "..";
  * the correct set of output stores are updated.
  *
  * All `compute...` functions except `computeExtensionConfigs` are pure
- * (or are supposed to be). `computeExtensionConfigs` calls `getGlobalStore`,
+ * (or are supposed to be), other than the fact that they all `setState`
+ * store values at the end. `computeExtensionConfigs` calls `getGlobalStore`,
  * which creates stores.
  */
 computeModuleConfig(
@@ -87,27 +90,27 @@ computeExtensionConfigs(
   configExtensionStore.getState(),
   temporaryConfigStore.getState()
 );
-configInternalStore.subscribe((configState) =>
+configInternalStore.subscribe((configState) => {
   computeExtensionConfigs(
     configState,
     configExtensionStore.getState(),
     temporaryConfigStore.getState()
-  )
-);
-configExtensionStore.subscribe((extensionState) =>
+  );
+});
+configExtensionStore.subscribe((extensionState) => {
   computeExtensionConfigs(
     configInternalStore.getState(),
     extensionState,
     temporaryConfigStore.getState()
-  )
-);
-temporaryConfigStore.subscribe((tempConfigState) =>
+  );
+});
+temporaryConfigStore.subscribe((tempConfigState) => {
   computeExtensionConfigs(
     configInternalStore.getState(),
     configExtensionStore.getState(),
     tempConfigState
-  )
-);
+  );
+});
 
 function computeModuleConfig(
   state: ConfigInternalStore,
@@ -125,9 +128,17 @@ function computeExtensionSlotConfigs(
   tempState: TemporaryConfigStore
 ) {
   const slotConfigs = getExtensionSlotConfigs(state, tempState);
-  for (let [slotName, config] of Object.entries(slotConfigs)) {
-    const slotStore = getExtensionSlotConfigStore(slotName);
-    slotStore.setState({ loaded: true, config });
+  const newSlotStoreEntries = Object.fromEntries(
+    Object.entries(slotConfigs).map(([slotName, config]) => [
+      slotName,
+      { loaded: true, config },
+    ])
+  );
+  const slotStore = getExtensionSlotsConfigStore();
+  const oldState = slotStore.getState();
+  const newState = { slots: { ...oldState.slots, ...newSlotStoreEntries } };
+  if (!equals(oldState, newState)) {
+    slotStore.setState(newState);
   }
 }
 
@@ -144,13 +155,9 @@ function computeExtensionConfigs(
   extensionState: ConfigExtensionStore,
   tempConfigState: TemporaryConfigStore
 ) {
+  const configs = {};
   for (let extension of extensionState.mountedExtensions) {
-    const extensionStore = getExtensionConfigStore(
-      extension.slotModuleName,
-      extension.slotName,
-      extension.extensionId
-    );
-    const config = getExtensionConfig(
+    const config = computeExtensionConfig(
       extension.slotModuleName,
       extension.extensionModuleName,
       extension.slotName,
@@ -158,8 +165,12 @@ function computeExtensionConfigs(
       configState,
       tempConfigState
     );
-    extensionStore.setState({ loaded: true, config });
+    configs[extension.slotName] = {
+      ...configs[extension.slotName],
+      [extension.extensionId]: { config, loaded: true },
+    };
   }
+  getExtensionsConfigStore().setState({ configs });
 }
 
 /*
@@ -167,6 +178,18 @@ function computeExtensionConfigs(
  *
  */
 
+/**
+ * This defines a configuration schema for a module. The schema tells the
+ * configuration system how the module can be configured. It specifies
+ * what makes configuration valid or invalid.
+ *
+ * See [Configuration System](http://o3-dev.docs.openmrs.org/#/main/config)
+ * for more information about defining a config schema.
+ *
+ * @param moduleName Name of the module the schema is being defined for. Generally
+ *   should be the one in which the `defineConfigSchema` call takes place.
+ * @param schema The config schema for the module
+ */
 export function defineConfigSchema(moduleName: string, schema: ConfigSchema) {
   validateConfigSchema(moduleName, schema);
   const state = configInternalStore.getState();
@@ -175,6 +198,39 @@ export function defineConfigSchema(moduleName: string, schema: ConfigSchema) {
   });
 }
 
+/**
+ * This defines a configuration schema for an extension. When a schema is defined
+ * for an extension, that extension will receive the configuration corresponding
+ * to that schema, rather than the configuration corresponding to the module
+ * in which it is defined.
+ *
+ * The schema tells the configuration system how the module can be configured.
+ * It specifies what makes configuration valid or invalid.
+ *
+ * See [Configuration System](http://o3-dev.docs.openmrs.org/#/main/config)
+ * for more information about defining a config schema.
+ *
+ * @param extensionName Name of the extension the schema is being defined for.
+ *   Should match the `name` of one of the `extensions` entries being returned
+ *   by `setupOpenMRS`.
+ * @param schema The config schema for the extension
+ */
+export function defineExtensionConfigSchema(
+  extensionName: string,
+  schema: ConfigSchema
+) {
+  validateConfigSchema(extensionName, schema);
+  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 },
+  });
+}
+
 export function provide(config: Config, sourceName = "provided") {
   const state = configInternalStore.getState();
   configInternalStore.setState({
@@ -216,6 +272,7 @@ export function getConfig(moduleName: string): Promise<Config> {
  * @param providedConfig  an object of config values (without the top-level module name)
  * @param keyPathContext  a dot-deparated string which helps the user figure out where
  *     the provided config came from
+ * @internal
  */
 export function processConfig(
   schema: ConfigSchema,
@@ -237,15 +294,16 @@ export function processConfig(
  * Returns the configuration for an extension. This configuration is specific
  * to the slot in which it is mounted, and its ID within that slot.
  *
- * The schema for that configuration is the schema for the module in which the
- * extension is defined.
+ * The schema for that configuration is the extension schema. If no extension
+ * schema has been provided, the schema used is the schema of the module in
+ * which the extension is defined.
  *
  * @param slotModuleName The name of the module which defines the extension slot
  * @param extensionModuleName The name of the module which defines the extension (and therefore the config schema)
  * @param slotName The name of the extension slot where the extension is mounted
  * @param extensionId The ID of the extension in its slot
  */
-function getExtensionConfig(
+function computeExtensionConfig(
   slotModuleName: string,
   extensionModuleName: string,
   slotName: string,
@@ -253,23 +311,28 @@ function getExtensionConfig(
   configState: ConfigInternalStore,
   tempConfigState: TemporaryConfigStore
 ) {
+  const extensionName = getExtensionNameFromId(extensionId);
+  const extensionConfigSchema = configState.schemas[extensionName];
+  const nameOfSchemaSource = extensionConfigSchema
+    ? extensionName
+    : extensionModuleName;
   const providedConfigs = getProvidedConfigs(configState, tempConfigState);
   const slotModuleConfig = mergeConfigsFor(slotModuleName, providedConfigs);
   const configOverride =
-    slotModuleConfig?.extensions?.[slotName]?.configure?.[extensionId] ?? {};
-  const extensionModuleConfig = mergeConfigsFor(
-    extensionModuleName,
-    providedConfigs
-  );
-  const extensionConfig = mergeConfigs([extensionModuleConfig, configOverride]);
-  const schema = configState.schemas[extensionModuleName]; // TODO: validate that a schema exists for the module
-  validateConfig(schema, extensionConfig, extensionModuleName);
+    slotModuleConfig?.extensionSlots?.[slotName]?.configure?.[extensionId] ??
+    {};
+  const extensionConfig = mergeConfigsFor(nameOfSchemaSource, providedConfigs);
+  const combinedConfig = mergeConfigs([extensionConfig, configOverride]);
+  // TODO: validate that a schema exists for the module
+  const schema =
+    extensionConfigSchema ?? configState.schemas[extensionModuleName];
+  validateConfig(schema, combinedConfig, nameOfSchemaSource);
   const config = setDefaults(
     schema,
-    extensionConfig,
+    combinedConfig,
     configState.devDefaultsAreOn
   );
-  delete config.extensions;
+  delete config.extensionSlots;
   return config;
 }
 
@@ -324,8 +387,8 @@ function getExtensionSlotConfigs(
     string,
     Record<string, ExtensionSlotConfig>
   > = Object.keys(allConfigs).reduce((obj, key) => {
-    if (allConfigs[key]?.extensions) {
-      obj[key] = allConfigs[key]?.extensions;
+    if (allConfigs[key]?.extensionSlots) {
+      obj[key] = allConfigs[key]?.extensionSlots;
     }
     return obj;
   }, {});
@@ -354,7 +417,7 @@ function validateExtensionSlotConfig(
   moduleName: string,
   slotName: string
 ): void {
-  const errorPrefix = `Extension slot config '${moduleName}.extensions.${slotName}`;
+  const errorPrefix = `Extension slot config '${moduleName}.extensionSlots.${slotName}`;
   const invalidKeys = Object.keys(config).filter(
     (k) => !["add", "remove", "order", "configure"].includes(k)
   );
@@ -510,7 +573,7 @@ function getConfigForModule(
   );
   validateConfig(schema, inputConfig, moduleName);
   const config = setDefaults(schema, inputConfig, configState.devDefaultsAreOn);
-  delete config.extensions;
+  delete config.extensionSlots;
   return config;
 }
 
@@ -544,7 +607,7 @@ const validateConfig = (
     const schemaPart = schema[key] as ConfigSchema;
 
     if (!schema.hasOwnProperty(key)) {
-      if (key !== "extensions") {
+      if (key !== "extensionSlots") {
         console.error(
           `Unknown config key '${thisKeyPath}' provided. Ignoring.`
         );
@@ -618,6 +681,8 @@ function checkType(keyPath: string, _type: Type | undefined, value: any) {
       Object: isObject,
       String: isString,
       UUID: isUuid,
+      PersonAttributeTypeUuid: isUuid,
+      PatientIdentifierTypeUuid: isUuid,
     };
     runValidators(keyPath, [validator[_type]], value);
   }
@@ -731,3 +796,12 @@ function hasObjectSchema(
 function isOrdinaryObject(value) {
   return typeof value === "object" && !Array.isArray(value) && value !== null;
 }
+
+/**
+ * Copied over from esm-extensions. It rightly belongs to that module, but esm-config
+ * cannot depend on esm-extensions.
+ */
+function getExtensionNameFromId(extensionId: string) {
+  const [extensionName] = extensionId.split("#");
+  return extensionName;
+}