add NdbDocument type restrictions

Author: sandroschmid

src/denormalizer-interface.ts

@@ -1,11 +1,13 @@
-import { Depth, ValidKey } from '@normalized-db/core';
+import { Depth, NdbDocument, ValidKey } from '@normalized-db/core';
 
 export interface IDenormalizer {
-  applyAll<T>(type: string, data: T[], depth?: number | Depth): Promise<T[]>;
+  applyAll<T extends NdbDocument>(type: string, data: T[], depth?: number | Depth): Promise<T[]>;
 
-  applyAllKeys<Key extends ValidKey, T>(type: string, keys: Key[], depth?: number | Depth): Promise<T[]>;
+  applyAllKeys<Key extends ValidKey, T extends NdbDocument>(type: string,
+                                                            keys: Key[],
+                                                            depth?: number | Depth): Promise<T[]>;
 
-  apply<T>(type: string, data: T, depth?: number | Depth): Promise<T>;
+  apply<T extends NdbDocument>(type: string, data: T, depth?: number | Depth): Promise<T>;
 
-  applyKey<Key extends ValidKey, T>(type: string, key: Key, depth?: number | Depth): Promise<T>;
+  applyKey<Key extends ValidKey, T extends NdbDocument>(type: string, key: Key, depth?: number | Depth): Promise<T>;
 }

src/denormalizer.ts

@@ -1,4 +1,7 @@
-import { Depth, FetchCallback, ISchema, isNull, KeyMap, NormalizedData, ValidKey } from '@normalized-db/core';
+import {
+  Depth, FetchCallback, ISchema, isNull, KeyMap, NdbDocument, NormalizedData,
+  ValidKey
+} from '@normalized-db/core';
 import { IDenormalizer } from './denormalizer-interface';
 import { BasicDenormalizer } from './implementation/basic-denormalizer';
 import { ReverseReferenceDenormalizer } from './implementation/reverse-reference-denormalizer';
@@ -19,19 +22,23 @@ export class Denormalizer implements IDenormalizer {
     this._implementation = this.buildDenormalizer();
   }
 
-  public applyAll<T>(type: string, data: T[], depth?: number | Depth): Promise<T[]> {
+  public applyAll<T extends NdbDocument>(type: string, data: T[], depth?: number | Depth): Promise<T[]> {
     return this._implementation.applyAll<T>(type, data, depth);
   }
 
-  public applyAllKeys<Key extends ValidKey, T>(type: string, keys: Key[], depth?: number | Depth): Promise<T[]> {
+  public applyAllKeys<Key extends ValidKey, T extends NdbDocument>(type: string,
+                                                                   keys: Key[],
+                                                                   depth?: number | Depth): Promise<T[]> {
     return this._implementation.applyAllKeys<Key, T>(type, keys, depth);
   }
 
-  public apply<T>(type: string, data: T, depth?: number | Depth): Promise<T> {
+  public apply<T extends NdbDocument>(type: string, data: T, depth?: number | Depth): Promise<T> {
     return this._implementation.apply<T>(type, data, depth);
   }
 
-  public applyKey<Key extends ValidKey, T>(type: string, key: Key, depth?: number | Depth): Promise<T> {
+  public applyKey<Key extends ValidKey, T extends NdbDocument>(type: string,
+                                                               key: Key,
+                                                               depth?: number | Depth): Promise<T> {
     return this._implementation.applyKey<Key, T>(type, key, depth);
   }
 

src/implementation/basic-denormalizer.ts

@@ -1,18 +1,6 @@
 import {
-  deepClone,
-  Depth,
-  FetchCallback,
-  InvalidTypeError,
-  ISchema,
-  isNull,
-  isObject,
-  IStore,
-  IStoreTargetItem,
-  KeyMap,
-  NormalizedData,
-  NotFoundError,
-  TypeMismatchError,
-  ValidKey
+  deepClone, Depth, FetchCallback, InvalidTypeError, ISchema, isNull, isObject, IStore, IStoreTargetItem, KeyMap,
+  NdbDocument, NormalizedData, NotFoundError, TypeMismatchError, ValidKey
 } from '@normalized-db/core';
 import { IDenormalizer } from '../denormalizer-interface';
 
@@ -42,17 +30,19 @@ export class BasicDenormalizer implements IDenormalizer {
     }
   }
 
-  public async applyAll<T>(type: string, data: T[], depth?: number | Depth): Promise<T[]> {
+  public async applyAll<T extends NdbDocument>(type: string, data: T[], depth?: number | Depth): Promise<T[]> {
     this.validateType(type);
     return await this.denormalizeArray(type, data, depth);
   }
 
-  public async applyAllKeys<Key extends ValidKey, T>(type: string, keys: Key[], depth?: number | Depth): Promise<T[]> {
+  public async applyAllKeys<Key extends ValidKey, T extends NdbDocument>(type: string,
+                                                                         keys: Key[],
+                                                                         depth?: number | Depth): Promise<T[]> {
     this.validateType(type);
     return await Promise.all(keys.map(async key => await this.applyKey<Key, T>(type, key, depth)));
   }
 
-  public async apply<T>(type: string, data: T, depth?: number | Depth): Promise<T> {
+  public async apply<T extends NdbDocument>(type: string, data: T, depth?: number | Depth): Promise<T> {
     this.validateType(type);
 
     if (isObject(data)) {
@@ -62,7 +52,9 @@ export class BasicDenormalizer implements IDenormalizer {
     }
   }
 
-  public async applyKey<Key extends ValidKey, T>(type: string, key: Key, depth?: number | Depth): Promise<T> {
+  public async applyKey<Key extends ValidKey, T extends NdbDocument>(type: string,
+                                                                     key: Key,
+                                                                     depth?: number | Depth): Promise<T> {
     this.validateType(type);
 
     if (!this._keys[type].has(key)) {
@@ -91,12 +83,12 @@ export class BasicDenormalizer implements IDenormalizer {
     return await this.apply(type, deepClone(data), depth);
   }
 
-  protected async denormalizeArray(type: string, data: any[], depth: number | Depth): Promise<any> {
+  protected async denormalizeArray(type: string, data: NdbDocument[], depth: number | Depth): Promise<any> {
     // TODO: check for arrays, empty objects
     return await Promise.all(data.map(item => this.denormalizeObject(type, item, depth)));
   }
 
-  protected async denormalizeObject(type: string, data: any, depth: number | Depth): Promise<any> {
+  protected async denormalizeObject(type: string, data: NdbDocument, depth: number | Depth): Promise<any> {
     const config = this._schema.getConfig(type);
     if (!isNull(config.targets)) {
       await this.denormalizeTargets(type, data, config, depth);
@@ -105,7 +97,10 @@ export class BasicDenormalizer implements IDenormalizer {
     return data;
   }
 
-  protected async denormalizeTargets(type: string, data: any, config: IStore, depth: number | Depth): Promise<void> {
+  protected async denormalizeTargets(type: string,
+                                     data: NdbDocument,
+                                     config: IStore,
+                                     depth: number | Depth): Promise<void> {
     const promises = Object.keys(config.targets)
       .filter(field => field in data && !isNull(data[field]))
       .map(async field => {
@@ -167,7 +162,7 @@ export class BasicDenormalizer implements IDenormalizer {
     return isArray ? result : result[0];
   }
 
-  protected applyTarget(type: string, data: any, depth?: number | Depth): Promise<any> {
+  protected applyTarget(type: string, data: NdbDocument, depth?: number | Depth): Promise<NdbDocument> {
     return this.apply(type, data, depth);
   }
 

src/implementation/reverse-reference-denormalizer.ts

@@ -1,10 +1,10 @@
-import { Depth } from '@normalized-db/core';
+import { Depth, NdbDocument } from '@normalized-db/core';
 import { BasicDenormalizer } from './basic-denormalizer';
 
 export class ReverseReferenceDenormalizer extends BasicDenormalizer {
 
-  protected async applyTarget(type: string, data: any | any[], depth?: number | Depth): Promise<any[]> {
-    const denormalizedTarget = await super.applyTarget(type, data, depth);
+  protected async applyTarget(type: string, data: NdbDocument, depth?: number | Depth): Promise<NdbDocument> {
+    const denormalizedTarget: any = await super.applyTarget(type, data, depth);
     if ('_refs' in denormalizedTarget) {
       delete denormalizedTarget['_refs'];
     }