Implement mapOf setting type

platform/lib/schema/__tests__/MapOfSetting.test.ts

@@ -0,0 +1,68 @@
+import { mapOf, object, string, number } from '../';
+
+test('handles object as input', () => {
+  const setting = mapOf(string(), string());
+  const value = {
+    name: 'foo'
+  };
+  const expected = new Map([['name', 'foo']]);
+
+  expect(setting.validate(value)).toEqual(expected);
+});
+
+test('fails when not receiving expected value type', () => {
+  const setting = mapOf(string(), string());
+  const value = {
+    name: 123
+  };
+
+  expect(() => setting.validate(value)).toThrowErrorMatchingSnapshot();
+});
+
+test('fails when not receiving expected key type', () => {
+  const setting = mapOf(number(), string());
+  const value = {
+    name: 'foo'
+  };
+
+  expect(() => setting.validate(value)).toThrowErrorMatchingSnapshot();
+});
+
+test('returns default value if undefined', () => {
+  const obj = new Map([['foo', 'bar']]);
+
+  const setting = mapOf(string(), string(), {
+    defaultValue: obj
+  });
+
+  expect(setting.validate(undefined)).toEqual(obj);
+});
+
+test('mapOf within mapOf', () => {
+  const setting = mapOf(string(), mapOf(string(), number()));
+  const value = {
+    foo: {
+      bar: 123
+    }
+  };
+  const expected = new Map([['foo', new Map([['bar', 123]])]]);
+
+  expect(setting.validate(value)).toEqual(expected);
+});
+
+test('object within mapOf', () => {
+  const setting = mapOf(
+    string(),
+    object({
+      bar: number()
+    })
+  );
+  const value = {
+    foo: {
+      bar: 123
+    }
+  };
+  const expected = new Map([['foo', { bar: 123 }]]);
+
+  expect(setting.validate(value)).toEqual(expected);
+});

platform/lib/schema/__tests__/__snapshots__/MapOfSetting.test.ts.snap

@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`fails when not receiving expected key type 1`] = `"[name]: expected value of type [number] but got [string]"`;
+
+exports[`fails when not receiving expected value type 1`] = `"[name]: expected value of type [string] but got [number]"`;

platform/lib/schema/index.ts

@@ -436,6 +436,55 @@ export class ObjectSetting<P extends Props> extends Setting<
   }
 }
 
+function isMap<K, V>(o: any): o is Map<K, V> {
+  return o instanceof Map;
+}
+
+type MapOfOptions<K, V> = SettingOptions<Map<K, V>>;
+
+export class MapOfSetting<K, V> extends Setting<Map<K, V>> {
+  constructor(
+    private readonly keySetting: Setting<K>,
+    private readonly valueSetting: Setting<V>,
+    options: MapOfOptions<K, V> = {}
+  ) {
+    super(options);
+  }
+
+  process(obj: any, context?: string): Map<K, V> {
+    if (isPlainObject(obj)) {
+      const entries = Object.keys(obj).map(key => [key, obj[key]]);
+      return this.processEntries(entries);
+    }
+
+    if (isMap(obj)) {
+      return this.processEntries([...obj.entries()]);
+    }
+
+    throw new SettingError(
+      `expected value of type [Map] or [object] but got [${typeDetect(obj)}]`,
+      context
+    );
+  }
+
+  processEntries(entries: any[][], context?: string) {
+    const res = entries.map(([key, value]) => {
+      const validatedKey = this.keySetting.validate(
+        key,
+        toContext(context, String(key))
+      );
+      const validatedValue = this.valueSetting.validate(
+        value,
+        toContext(context, String(key))
+      );
+
+      return [validatedKey, validatedValue] as [K, V];
+    });
+
+    return new Map(res);
+  }
+}
+
 export function boolean(options?: SettingOptions<boolean>): Setting<boolean> {
   return new BooleanSetting(options);
 }
@@ -483,6 +532,14 @@ export function arrayOf<T>(
   return new ArraySetting(itemSetting, options);
 }
 
+export function mapOf<K, V>(
+  keySetting: Setting<K>,
+  valueSetting: Setting<V>,
+  options?: MapOfOptions<K, V>
+): Setting<Map<K, V>> {
+  return new MapOfSetting(keySetting, valueSetting, options);
+}
+
 export function oneOf<A, B, C, D>(
   types: [Setting<A>, Setting<B>, Setting<C>, Setting<D>],
   options?: SettingOptions<A | B | C | D>

platform/plugins/pid/PidFile.ts

@@ -47,4 +47,4 @@ export class PidFile {
     this.log.debug(`deleting pid file [${path}]`);
     unlinkSync(path);
   }
-}
+}