Merge pull request #66 from Gnuxie/gnuxie/persistent-config-protection-settings

When we decided to go with the config recovery in the safe mode work the-draupnir-project/planning#1, we also decided we would unify the wrappers used for all persistent config to be based on a system that leveraged TypeBox to provide us with schema. So this PR replaces `ProtectionSettings` with the new `ConfigDescription` system. This branch was written and linked with the work to migrate draupnir's protection's to the new system too.    

This slightly longer because the types are not liberal enough in what they accept when they are describing interfaces. This is a general bitch throughout the code base and I don't really know how to address it yet.

Basically we need to allow interfaces for things like the methods on the `ConfigMirror` to accept arguments liberally. But the implementation needs to be as defensive as `unknown` etc. It's my fault for not really understanding variance properly.

There was also an issue where the command reader from Draupnir's interface-manager produced objects that are different to the transform types in the `ConfigDescription` schema. So we had to update the `ConfigMirror` to accept serialized representations of values as a workaround. Not a big deal but it's a thing.  

Aside from that I've been at a low point these past weeks.

Author: Gnuxie

src/Config/ConfigDescription.ts

@@ -2,7 +2,7 @@
 //
 // SPDX-License-Identifier: AFL-3.0
 
-import { TObject, TProperties, TSchema } from '@sinclair/typebox';
+import { TObject, TProperties, TSchema, Type } from '@sinclair/typebox';
 import { EDStatic } from '../Interface/Static';
 import { Ok, Result } from '@gnuxie/typescript-result';
 import { Value as TBValue } from '@sinclair/typebox/value';
@@ -17,11 +17,16 @@ export type UnknownProperties<T extends TSchema> = {
   [K in keyof StaticProperties<T>]: unknown;
 };
 
+export const UnknownConfig = Type.Object({}, { additionalProperties: true });
+export type UnknownConfig = typeof UnknownConfig;
+
 export type ConfigPropertyDescription = {
   path: string;
   name: string;
   description: string | undefined;
   default: unknown;
+  isArray: boolean;
+  isUniqueItems: boolean;
 };
 
 export type ConfigDescription<TConfigSchema extends TObject = TObject> = {
@@ -80,6 +85,8 @@ export class StandardConfigDescription<TConfigSchema extends TObject>
       path: '/' + name,
       description: schema.description,
       default: schema.default as unknown,
+      isUniqueItems: 'uniqueItems' in schema && schema.uniqueItems === true,
+      isArray: 'items' in schema,
     }));
   }
 
@@ -93,6 +100,8 @@ export class StandardConfigDescription<TConfigSchema extends TObject>
       path: '/' + key,
       description: schema.description,
       default: schema.default as unknown,
+      isUniqueItems: 'uniqueItems' in schema && schema.uniqueItems === true,
+      isArray: 'items' in schema,
     };
   }
 

src/Config/ConfigMirror.ts

@@ -12,21 +12,33 @@ import {
 import { ConfigDescription } from './ConfigDescription';
 import { EDStatic } from '../Interface/Static';
 import { ConfigPropertyError } from './ConfigParseError';
-import { Ok, Result } from '@gnuxie/typescript-result';
+import { Ok, Result, isError } from '@gnuxie/typescript-result';
 import { Value as TBValue } from '@sinclair/typebox/value';
+import { Value } from '../Interface/Value';
 
+// We should really have a conditional type here for unknown config.
 export interface ConfigMirror<TConfigSchema extends TObject = TObject> {
   readonly description: ConfigDescription<TConfigSchema>;
-  setValue(
+  setValue<TKey extends string>(
     config: EDStatic<TConfigSchema>,
-    key: keyof EDStatic<TConfigSchema>,
+    key: TKey,
     value: unknown
   ): Result<EDStatic<TConfigSchema>, ConfigPropertyError>;
-  addItem(
+  setSerializedValue<TKey extends string>(
+    config: EDStatic<TConfigSchema>,
+    key: TKey,
+    value: string
+  ): Result<EDStatic<TConfigSchema>, ConfigPropertyError>;
+  addItem<TKey extends string>(
     config: EDStatic<TConfigSchema>,
-    key: keyof EDStatic<TConfigSchema>,
+    key: TKey,
     value: unknown
   ): Result<EDStatic<TConfigSchema>, ConfigPropertyError>;
+  addSerializedItem<TKey extends string>(
+    config: EDStatic<TConfigSchema>,
+    key: TKey,
+    value: string
+  ): Result<EDStatic<TConfigSchema>, ConfigPropertyError>;
   // needed for when additionalProperties is true.
   removeProperty<TKey extends string>(
     key: TKey,
@@ -54,7 +66,7 @@ export class StandardConfigMirror<TConfigSchema extends TObject>
   }
   setValue(
     config: Evaluate<StaticDecode<TConfigSchema>>,
-    key: keyof Evaluate<StaticDecode<TConfigSchema>>,
+    key: string,
     value: unknown
   ): Result<Evaluate<StaticDecode<TConfigSchema>>, ConfigPropertyError> {
     const schema = this.description.schema.properties[key as keyof TProperties];
@@ -108,7 +120,7 @@ export class StandardConfigMirror<TConfigSchema extends TObject>
   }
   addItem(
     config: Evaluate<StaticDecode<TConfigSchema>>,
-    key: keyof Evaluate<StaticDecode<TConfigSchema>>,
+    key: string,
     value: unknown
   ): Result<Evaluate<StaticDecode<TConfigSchema>>, ConfigPropertyError> {
     const schema = this.description.schema.properties[key as keyof TProperties];
@@ -117,12 +129,15 @@ export class StandardConfigMirror<TConfigSchema extends TObject>
         `Property ${key.toString()} does not exist in schema`
       );
     }
-    const currentItems = config[key];
+    const currentItems = config[key as keyof EDStatic<TConfigSchema>];
     if (!Array.isArray(currentItems)) {
       throw new TypeError(`Property ${key.toString()} is not an array`);
     }
     const errors = [
-      ...TBValue.Errors(schema, [...(config[key] as unknown[]), value]),
+      ...TBValue.Errors(schema, [
+        ...(config[key as keyof EDStatic<TConfigSchema>] as unknown[]),
+        value,
+      ]),
     ];
     if (errors[0] !== undefined) {
       return ConfigPropertyError.Result(errors[0].message, {
@@ -131,7 +146,62 @@ export class StandardConfigMirror<TConfigSchema extends TObject>
         description: this.description as unknown as ConfigDescription,
       });
     }
-    return Ok(this.addUnparsedItem(config, key, value));
+    return Ok(
+      this.addUnparsedItem(config, key as keyof EDStatic<TConfigSchema>, value)
+    );
+  }
+  addSerializedItem<TKey extends string>(
+    config: EDStatic<TConfigSchema>,
+    key: TKey,
+    value: string
+  ): Result<EDStatic<TConfigSchema>, ConfigPropertyError> {
+    const propertySchema =
+      this.description.schema.properties[key as keyof TProperties];
+    if (propertySchema === undefined) {
+      throw new TypeError(
+        `Property ${key.toString()} does not exist in schema`
+      );
+    }
+    if (!('items' in propertySchema)) {
+      throw new TypeError(`Property ${key.toString()} is not an array`);
+    }
+    const itemSchema = (propertySchema as TArray).items;
+    const decodeResult = Value.Decode(itemSchema, value);
+    if (isError(decodeResult)) {
+      return ConfigPropertyError.Result(decodeResult.error.message, {
+        path: `/${key.toString()}`,
+        value,
+        description: this.description as unknown as ConfigDescription,
+      });
+    }
+    return Ok(
+      this.addUnparsedItem(
+        config,
+        key as unknown as keyof EDStatic<TConfigSchema>,
+        decodeResult.ok
+      )
+    );
+  }
+  setSerializedValue<TKey extends string>(
+    config: EDStatic<TConfigSchema>,
+    key: TKey,
+    value: string
+  ): Result<EDStatic<TConfigSchema>, ConfigPropertyError> {
+    const schema = this.description.schema.properties[key as keyof TProperties];
+    if (schema === undefined) {
+      throw new TypeError(
+        `Property ${key.toString()} does not exist in schema`
+      );
+    }
+    const decodeResult = Value.Decode(schema, value);
+    if (isError(decodeResult)) {
+      return ConfigPropertyError.Result(decodeResult.error.message, {
+        path: `/${key.toString()}`,
+        value,
+        description: this.description as unknown as ConfigDescription,
+      });
+    }
+    return this.setValue(config, key, decodeResult.ok);
   }
   removeProperty<TKey extends string>(
     key: TKey,

src/Protection/Protection.ts

@@ -20,11 +20,6 @@ import {
   StateChange,
 } from '../StateTracking/StateRevisionIssuer';
 import { ProtectedRoomsSet } from './ProtectedRoomsSet';
-import { UnknownSettings } from './ProtectionSettings/ProtectionSetting';
-import {
-  ProtectionSettings,
-  StandardProtectionSettings,
-} from './ProtectionSettings/ProtectionSettings';
 import {
   CapabilityInterfaceSet,
   CapabilityProviderSet,
@@ -42,6 +37,13 @@ import {
   MatrixRoomID,
   StringRoomID,
 } from '@the-draupnir-project/matrix-basic-types';
+import {
+  ConfigDescription,
+  StandardConfigDescription,
+  UnknownConfig,
+} from '../Config/ConfigDescription';
+import { TObject, Type } from '@sinclair/typebox';
+import { EDStatic } from '../Interface/Static';
 
 /**
  * @param description The description for the protection being constructed.
@@ -56,16 +58,16 @@ import {
  */
 export type ProtectionFactoryMethod<
   Context = unknown,
-  TSettings extends Record<string, unknown> = Record<string, unknown>,
+  TConfigSchema extends TObject = UnknownConfig,
   TCapabilitySet extends CapabilitySet = CapabilitySet,
 > = (
-  description: ProtectionDescription<Context, TSettings, TCapabilitySet>,
+  description: ProtectionDescription<Context, TConfigSchema, TCapabilitySet>,
   protectedRoomsSet: ProtectedRoomsSet,
   context: Context,
   capabilities: TCapabilitySet,
-  settings: TSettings
+  settings: EDStatic<TConfigSchema>
 ) => ActionResult<
-  Protection<ProtectionDescription<Context, TSettings, TCapabilitySet>>
+  Protection<ProtectionDescription<Context, TConfigSchema, TCapabilitySet>>
 >;
 
 /**
@@ -74,14 +76,18 @@ export type ProtectionFactoryMethod<
  */
 export interface ProtectionDescription<
   Context = unknown,
-  TSettings extends UnknownSettings<string> = UnknownSettings<string>,
+  TConfigSchema extends TObject = UnknownConfig,
   TCapabilitySet extends CapabilitySet = CapabilitySet,
 > {
   readonly name: string;
   readonly description: string;
   readonly capabilities: CapabilityInterfaceSet<TCapabilitySet>;
-  readonly factory: ProtectionFactoryMethod<Context, TSettings, TCapabilitySet>;
-  readonly protectionSettings: ProtectionSettings<TSettings>;
+  readonly factory: ProtectionFactoryMethod<
+    Context,
+    TConfigSchema,
+    TCapabilitySet
+  >;
+  readonly protectionSettings: ConfigDescription<TConfigSchema>;
   readonly defaultCapabilities: CapabilityProviderSet<TCapabilitySet>;
 }
 
@@ -197,17 +203,20 @@ const PROTECTIONS = new Map<string, ProtectionDescription>();
 
 export function registerProtection<
   Context = unknown,
-  TSettings extends UnknownSettings<string> = UnknownSettings<string>,
+  TConfigSchema extends TObject = UnknownConfig,
   TCapabilitySet extends CapabilitySet = CapabilitySet,
 >(
-  description: ProtectionDescription<Context, TSettings, TCapabilitySet>
-): ProtectionDescription<Context, TSettings, TCapabilitySet> {
+  description: ProtectionDescription<Context, TConfigSchema, TCapabilitySet>
+): ProtectionDescription<Context, TConfigSchema, TCapabilitySet> {
   if (PROTECTIONS.has(description.name)) {
     throw new TypeError(
       `There is already a protection registered with the name ${description.name}`
     );
   }
-  PROTECTIONS.set(description.name, description as ProtectionDescription);
+  PROTECTIONS.set(
+    description.name,
+    description as unknown as ProtectionDescription
+  );
   return description;
 }
 
@@ -220,25 +229,26 @@ export function findProtection(
 export function describeProtection<
   TCapabilitySet extends CapabilitySet = CapabilitySet,
   Context = unknown,
-  TSettings extends Record<string, unknown> = Record<string, unknown>,
+  TConfigSchema extends TObject = UnknownConfig,
 >({
   name,
   description,
   capabilityInterfaces,
   defaultCapabilities,
   factory,
-  protectionSettings = new StandardProtectionSettings<TSettings>(
-    {} as Record<keyof TSettings, never>,
-    {} as TSettings
-  ),
+  configSchema,
 }: {
   name: string;
   description: string;
-  factory: ProtectionDescription<Context, TSettings, TCapabilitySet>['factory'];
+  factory: ProtectionDescription<
+    Context,
+    TConfigSchema,
+    TCapabilitySet
+  >['factory'];
   capabilityInterfaces: GenericCapabilityDescription<TCapabilitySet>;
   defaultCapabilities: GenericCapabilityDescription<TCapabilitySet>;
-  protectionSettings?: ProtectionSettings<TSettings>;
-}): ProtectionDescription<Context, TSettings, TCapabilitySet> {
+  configSchema?: TConfigSchema;
+}): ProtectionDescription<Context, TConfigSchema, TCapabilitySet> {
   const capabilityInterfaceSet =
     findCapabilityInterfaceSet(capabilityInterfaces);
   const defaultCapabilitySet = findCapabilityProviderSet(defaultCapabilities);
@@ -248,10 +258,16 @@ export function describeProtection<
     capabilities: capabilityInterfaceSet,
     defaultCapabilities: defaultCapabilitySet,
     factory,
-    protectionSettings,
+    protectionSettings: new StandardConfigDescription(
+      configSchema ?? Type.Object({})
+    ),
   };
-  registerProtection(protectionDescription);
-  return protectionDescription;
+  registerProtection(protectionDescription as unknown as ProtectionDescription);
+  return protectionDescription as unknown as ProtectionDescription<
+    Context,
+    TConfigSchema,
+    TCapabilitySet
+  >;
 }
 
 export function getAllProtections(): IterableIterator<ProtectionDescription> {

src/Protection/ProtectionHandles.test.ts

@@ -2,7 +2,9 @@
 //
 // SPDX-License-Identifier: AFL-3.0
 
+import { Type } from '@sinclair/typebox';
 import { PowerLevelPermission } from '../Client/PowerLevelsMirror';
+import { StandardConfigDescription } from '../Config/ConfigDescription';
 import { Ok, isError } from '../Interface/Action';
 import { Logger } from '../Logging/Logger';
 import { PowerLevelsEventContent } from '../MatrixTypes/PowerLevels';
@@ -13,8 +15,6 @@ import {
 } from '../StateTracking/DeclareRoomState';
 import { randomRoomID, randomUserID } from '../TestUtilities/EventGeneration';
 import { ProtectionDescription } from './Protection';
-import { ProtectionSetting } from './ProtectionSettings/ProtectionSetting';
-import { StandardProtectionSettings } from './ProtectionSettings/ProtectionSettings';
 
 const log = new Logger('ProtectionHandles.test');
 
@@ -50,10 +50,7 @@ test('handlePermissionRequirementsMet is called when a new room is added with me
     description: 'test description',
     capabilities: {},
     defaultCapabilities: {},
-    protectionSettings: new StandardProtectionSettings(
-      new Map<never, ProtectionSetting<string, Record<never, never>>>(),
-      {}
-    ),
+    protectionSettings: new StandardConfigDescription(Type.Object({})),
     factory(
       description,
       _protectedRoomsSet,
@@ -76,7 +73,6 @@ test('handlePermissionRequirementsMet is called when a new room is added with me
   };
   const protectionAddResult = await protectedRoomsSet.protections.addProtection(
     protectionDescription,
-    {},
     protectedRoomsSet,
     undefined
   );