Infer data type from JSON schema

projects/ngx-pwa/local-storage/src/lib/testing/cleaning.ts

@@ -1,18 +1,19 @@
 import { StorageMap } from '../storages/storage-map.service';
 import { IndexedDBDatabase } from '../databases/indexeddb-database';
 import { MemoryDatabase } from '../databases/memory-database';
+import { SafeStorageMap } from '../storages/safe-storage-map.service';
 
 /**
  * Helper to clear all data in storage to avoid tests overlap
  * @param done Jasmine helper to explicit when the operation has ended to avoid tests overlap
  * @param storageService Service
  */
-export function clearStorage(done: DoneFn, storageService: StorageMap): void {
+export function clearStorage(done: DoneFn, storageService: StorageMap | SafeStorageMap): void {
 
   if (storageService.backingEngine === 'indexedDB') {
 
     // tslint:disable-next-line: no-string-literal
-    const indexedDBService = storageService['database'] as IndexedDBDatabase;
+    const indexedDBService = (storageService as SafeStorageMap)['database'] as IndexedDBDatabase;
 
     try {
 
@@ -82,7 +83,7 @@ export function clearStorage(done: DoneFn, storageService: StorageMap): void {
   } else if (storageService.backingEngine === 'memory') {
 
     // tslint:disable-next-line: no-string-literal
-    (storageService['database'] as MemoryDatabase)['memoryStorage'].clear();
+    ((storageService as SafeStorageMap)['database'] as MemoryDatabase)['memoryStorage'].clear();
 
     done();
 
@@ -103,13 +104,13 @@ export function clearStorage(done: DoneFn, storageService: StorageMap): void {
  * @param doneJasmine helper to explicit when the operation has ended to avoid tests overlap
  * @param storageService Service
  */
-export function closeAndDeleteDatabase(done: DoneFn, storageService: StorageMap): void {
+export function closeAndDeleteDatabase(done: DoneFn, storageService: StorageMap | SafeStorageMap): void {
 
   /* Only `indexedDB` is concerned */
   if (storageService.backingEngine === 'indexedDB') {
 
     // tslint:disable-next-line: no-string-literal
-    const indexedDBService = storageService['database'] as IndexedDBDatabase;
+    const indexedDBService = (storageService as SafeStorageMap)['database'] as IndexedDBDatabase;
 
     // tslint:disable-next-line: no-string-literal
     indexedDBService['database'].subscribe({

projects/ngx-pwa/local-storage/src/lib/validation/infer-from-json-schema.ts

@@ -0,0 +1,68 @@
+import { JSONSchema } from './json-schema';
+
+/**
+ * JSON schemas of primitive types
+ */
+type JSONSchemaPrimitive = { type: 'string' | 'integer' | 'number' | 'boolean' };
+
+/**
+ * Infer data from a JSON schemas describing a primitive type.
+ */
+type InferFromJSONSchemaPrimitive<Schema extends JSONSchemaPrimitive> =
+  /* Infer `const` and `enum` first, as they are more specific */
+  Schema extends { const: infer ConstType } ? ConstType :
+  Schema extends { enum: readonly (infer EnumType)[] } ? EnumType :
+  /* Infer primitive types */
+  Schema extends { type: 'string' } ? string :
+  Schema extends { type: 'integer' } ? number :
+  Schema extends { type: 'number' } ? number :
+  Schema extends { type: 'boolean' } ? boolean :
+  /* Default value, but not supposed to happen given the `JSONSchema` interface */
+  unknown;
+
+/**
+ * Infer the data type from a tuple JSON schema describing a tuple of primitive types.
+ */
+type InferFromJSONSchemaTupleOfPrimitive<Schemas extends readonly JSONSchemaPrimitive[]> = {
+  -readonly [Key in keyof Schemas]: Schemas[Key] extends JSONSchemaPrimitive ? InferFromJSONSchemaPrimitive<Schemas[Key]> : never
+};
+
+/**
+ * Infer the data type from a JSON schema describing a tuple:
+ * - with 1 or 2 values of any type (especially usefull for handling `Map`s),
+ * - with unlimited values but of primitive types only.
+ */
+type InferFromJSONSchemaTuple<Schemas extends readonly JSONSchema[]> =
+  /* Allows inference from any JSON schema up to 2 values */
+  Schemas extends readonly [JSONSchema] ? [InferFromJSONSchema<Schemas[0]>] :
+  Schemas extends readonly [JSONSchema, JSONSchema] ? [InferFromJSONSchema<Schemas[0]>, InferFromJSONSchema<Schemas[1]>] :
+  /* Beyond 2 values, infer from primitive types only to avoid too deep type inference */
+  Schemas extends readonly JSONSchemaPrimitive[] ? InferFromJSONSchemaTupleOfPrimitive<Schemas> :
+  unknown[]
+;
+
+/**
+ * Infer the data type from a JSON schema.
+ */
+export type InferFromJSONSchema<Schema extends JSONSchema> =
+  /* Infer primitive types */
+  Schema extends JSONSchemaPrimitive ? InferFromJSONSchemaPrimitive<Schema> :
+  /* Infer arrays */
+  Schema extends { type: 'array', items: infer ItemsType } ?
+    /* Classic array */
+    ItemsType extends JSONSchema ? InferFromJSONSchema<ItemsType>[] :
+    /* Tuples (ie. array with different value types) */
+    ItemsType extends readonly JSONSchema[] ? InferFromJSONSchemaTuple<ItemsType> :
+    /* Default value, but not supposed to happen given the `JSONSchema` interface */
+    unknown[] :
+  /* Infer objects */
+  Schema extends { type: 'object', properties: infer Properties, required?: readonly (infer RequiredProperties)[] } ?
+    {
+      -readonly [Key in keyof Pick<Properties, RequiredProperties extends keyof Properties ? RequiredProperties : never>]:
+      Properties[Key] extends JSONSchema ? InferFromJSONSchema<Properties[Key]> : never;
+    } & {
+      -readonly [Key in keyof Omit<Properties, RequiredProperties extends keyof Properties ? RequiredProperties : never>]?:
+      Properties[Key] extends JSONSchema ? InferFromJSONSchema<Properties[Key]> : never;
+    } :
+  /* Default type if inference failed */
+  unknown;

projects/ngx-pwa/local-storage/src/lib/validation/json-schema.ts

@@ -252,6 +252,19 @@ export interface JSONSchemaObject {
 
 }
 
+// TODO: documentation
+/**
+ * JSON schema to describe a custom value (useful for `Blob`).
+ */
+export interface JSONSchemaUnknown {
+
+  /**
+   * Type for an unknown value.
+   */
+  type: 'unknown';
+
+}
+
 /**
  * Subset of the JSON Schema standard.
  * Types are enforced to validate everything: each value **must** have a `type`.
@@ -284,5 +297,6 @@ export interface JSONSchemaObject {
  *   },
  *   required: ['firstName'],
  * };
+ *
  */
-export type JSONSchema = JSONSchemaString | JSONSchemaNumber | JSONSchemaInteger | JSONSchemaBoolean | JSONSchemaArray | JSONSchemaObject;
+export type JSONSchema = JSONSchemaString | JSONSchemaNumber | JSONSchemaInteger | JSONSchemaBoolean | JSONSchemaArray | JSONSchemaObject | JSONSchemaUnknown;

projects/ngx-pwa/local-storage/src/lib/validation/json-validator.ts

@@ -33,6 +33,9 @@ export class JSONValidator {
         return this.validateArray(data, schema);
       case 'object':
         return this.validateObject(data, schema);
+      // TODO: check how we handle this case (do not allow to bypass validation, or add a test)
+      case 'unknown':
+        return true;
 
     }
 

projects/ngx-pwa/local-storage/src/public_api.ts

@@ -4,13 +4,14 @@
 
 export {
   JSONSchema, JSONSchemaBoolean, JSONSchemaInteger, JSONSchemaNumber, JSONSchemaString,
-  JSONSchemaArray, JSONSchemaArrayOf, JSONSchemaObject
+  JSONSchemaArray, JSONSchemaArrayOf, JSONSchemaObject, JSONSchemaUnknown
 } from './lib/validation/json-schema';
 export { JSONValidator } from './lib/validation/json-validator';
 
 export { LocalDatabase } from './lib/databases/local-database';
 export { SERIALIZATION_ERROR, SerializationError } from './lib/databases/exceptions';
 
+export { SafeStorageMap } from './lib/storages/safe-storage-map.service';
 export { StorageMap } from './lib/storages/storage-map.service';
 export { LocalStorage } from './lib/storages/local-storage.service';
 export { ValidationError, VALIDATION_ERROR } from './lib/storages/exceptions';