feat(json-crdt): 🎸 add "map" schema type

Author: streamich

src/json-type/schema/SchemaBuilder.ts

@@ -5,6 +5,7 @@ import {
   ArraySchema,
   ObjectSchema,
   ObjectFieldSchema,
+  MapSchema,
   NoT,
   BinarySchema,
   AnySchema,
@@ -49,6 +50,10 @@ export class SchemaBuilder {
     return this.Object();
   }
 
+  get map() {
+    return this.Map(this.any);
+  }
+
   get bin() {
     return this.Binary(this.any);
   }
@@ -217,6 +222,10 @@ export class SchemaBuilder {
     };
   }
 
+  public Map<T extends Schema>(type: T, options?: Omit<NoT<MapSchema<T>>, 'type'>): MapSchema<T> {
+    return {__t: 'map', type, ...options};
+  }
+
   public Any(options: NoT<AnySchema> = {}): AnySchema {
     return {
       __t: 'any',

src/json-type/schema/__tests__/SchemaBuilder.spec.ts

@@ -59,6 +59,16 @@ describe('object', () => {
   });
 });
 
+describe('map', () => {
+  test('can create an simple object using shorthand', () => {
+    expect(s.map).toEqual({__t: 'map', type: {__t: 'any'}});
+  });
+
+  test('can define a map', () => {
+    expect(s.Map(s.Boolean())).toEqual({__t: 'map', type: {__t: 'bool'}});
+  });
+});
+
 describe('or', () => {
   test('can create an "or" type', () => {
     const type = s.Or(s.str, s.num);

src/json-type/schema/__tests__/TypeOf.spec.ts

@@ -119,6 +119,18 @@ test('can infer a simple object type', () => {
   const obj4: T4 = {baz: 123, bazOptional: false};
 });
 
+test('can infer a map type', () => {
+  const schema1 = s.map;
+  const schema2 = s.Map(s.str);
+  const schema3 = s.Map(s.Array(s.num));
+  type T1 = TypeOf<typeof schema1>;
+  type T2 = TypeOf<typeof schema2>;
+  type T3 = TypeOf<typeof schema3>;
+  const obj1: Record<string, unknown> = {};
+  const obj2: T2 = {foo: 'bar'};
+  const obj3: T3 = {bar: [1, 2, 3]};
+});
+
 test('can infer a simple union type', () => {
   const schema1 = s.Or(s.str, s.num);
   const schema2 = s.Or(s.str, s.num, s.bool);

src/json-type/schema/__tests__/type.spec.ts

@@ -1,6 +1,6 @@
 import {ObjectSchema, s} from '..';
 
-test('can generate a type', () => {
+test('can generate any type', () => {
   const address: ObjectSchema = {
     __t: 'obj',
     title: 'User address',
@@ -14,6 +14,7 @@ test('can generate a type', () => {
     s.prop('address', address),
     s.prop('timeCreated', s.Number()),
     s.prop('tags', s.Array(s.Or(s.Number(), s.String()))),
+    s.prop('elements', s.Map(s.str))
   );
 
   expect(userType).toMatchObject({
@@ -84,6 +85,15 @@ test('can generate a type', () => {
           },
         },
       },
+      {
+        key: 'elements',
+        type: {
+          __t: 'map',
+          type: {
+            __t: 'str',
+          },
+        },
+      },
     ],
   });
 });

src/json-type/schema/schema.ts

@@ -219,6 +219,16 @@ export interface ObjectOptionalFieldSchema<K extends string = string, V extends
   optional: true;
 }
 
+/**
+ * Represents an object, which is treated as a map. All keys are strings and all
+ * values are of the same type.
+ */
+export interface MapSchema<T extends TType = any> extends TType<Record<string, unknown>>, WithValidator {
+  __t: 'map';
+  /** Type of all values in the map. */
+  type: T;
+}
+
 /**
  * Reference to another type.
  */
@@ -276,7 +286,8 @@ export type JsonSchema =
   | TupleSchema
   | ObjectSchema
   | ObjectFieldSchema
-  | ObjectOptionalFieldSchema;
+  | ObjectOptionalFieldSchema
+  | MapSchema;
 
 export type Schema = JsonSchema | RefSchema | OrSchema | AnySchema | FunctionSchema | FunctionStreamingSchema;
 
@@ -304,6 +315,8 @@ export type TypeOfValue<T> = T extends BooleanSchema
   ? {[K in keyof U]: TypeOf<U[K]>}
   : T extends ObjectSchema<infer F>
   ? NoEmptyInterface<TypeFields<Mutable<F>>>
+  : T extends MapSchema<infer U>
+  ? Record<string, TypeOf<U>>
   : T extends BinarySchema
   ? Uint8Array
   : T extends FunctionSchema<infer Req, infer Res>