feat(repository): add KVRepository impl using legacy juggler

raymondfeng · raymondfeng · commit 30ce60e0bc4f · 2018-07-16T11:15:58.000-07:00
diff --git a/packages/repository/examples/juggler-bridge/note-with-repo-class.ts b/packages/repository/examples/juggler-bridge/note-with-repo-class.ts
@@ -14,10 +14,6 @@ import {
   ModelDefinition,
 } from '../../';
 
-class NoteController {
-  @repository('noteRepo') public noteRepo: EntityCrudRepository<Entity, number>;
-}
-
 const ds: juggler.DataSource = new juggler.DataSource({
   name: 'db',
   connector: 'memory',
@@ -28,6 +24,13 @@ class Note extends Entity {
     name: 'note',
     properties: {title: 'string', content: 'string'},
   });
+
+  title: string;
+  content?: string;
+}
+
+class NoteController {
+  @repository('noteRepo') public noteRepo: EntityCrudRepository<Note, number>;
 }
 
 class MyNoteRepository extends DefaultCrudRepository<Note, string> {
diff --git a/packages/repository/examples/juggler-bridge/note-with-repo-instance.ts b/packages/repository/examples/juggler-bridge/note-with-repo-instance.ts
@@ -16,14 +16,28 @@ import {
   ModelDefinition,
 } from '../../';
 
+const ds: juggler.DataSource = new juggler.DataSource({
+  name: 'db',
+  connector: 'memory',
+});
+
+class Note extends Entity {
+  static definition = new ModelDefinition({
+    name: 'note',
+    properties: {title: 'string', content: 'string'},
+  });
+
+  title: string;
+  content?: string;
+}
+
 // The Controller for Note
 class NoteController {
   constructor(
-    @repository('noteRepo')
-    public noteRepo: EntityCrudRepository<Entity, number>,
+    @repository('noteRepo') public noteRepo: EntityCrudRepository<Note, number>,
   ) {}
 
-  create(data: DataObject<Entity>, options?: Options) {
+  create(data: DataObject<Note>, options?: Options) {
     return this.noteRepo.create(data, options);
   }
 
@@ -32,18 +46,6 @@ class NoteController {
   }
 }
 
-const ds: juggler.DataSource = new juggler.DataSource({
-  name: 'db',
-  connector: 'memory',
-});
-
-class Note extends Entity {
-  static definition = new ModelDefinition({
-    name: 'note',
-    properties: {title: 'string', content: 'string'},
-  });
-}
-
 async function main() {
   // Create a context
   const ctx = new Context();
diff --git a/packages/repository/package.json b/packages/repository/package.json
@@ -32,7 +32,7 @@
     "@loopback/core": "^0.10.3",
     "@loopback/dist-util": "^0.3.3",
     "lodash": "^4.17.10",
-    "loopback-datasource-juggler": "^3.22.1"
+    "loopback-datasource-juggler": "^3.23.0"
   },
   "files": [
     "README.md",
diff --git a/packages/repository/src/common-types.ts b/packages/repository/src/common-types.ts
@@ -44,9 +44,15 @@ export interface AnyObject {
 }
 
 /**
- * Type alias for T or any object
+ * An extension of the built-in Partial<T> type which allows partial values
+ * in deeply nested properties too.
  */
-export type DataObject<T> = T | AnyObject;
+export type DeepPartial<T> = {[P in keyof T]?: DeepPartial<T[P]>};
+
+/**
+ * Type alias for strongly or weakly typed objects of T
+ */
+export type DataObject<T> = T | DeepPartial<T>;
 
 /**
  * Type alias for Node.js options object
diff --git a/packages/repository/src/model.ts b/packages/repository/src/model.ts
@@ -177,7 +177,7 @@ export abstract class Model {
     return obj;
   }
 
-  constructor(data?: Partial<Model>) {
+  constructor(data?: DataObject<Model>) {
     Object.assign(this, data);
   }
 }
diff --git a/packages/repository/src/repositories/constraint-utils.ts b/packages/repository/src/repositories/constraint-utils.ts
@@ -51,7 +51,7 @@ export function constrainWhere(
  */
 export function constrainDataObject<T extends Entity>(
   originalData: DataObject<T>,
-  constraint: Partial<T>,
+  constraint: DataObject<T>,
 ): DataObject<T> {
   const constrainedData = cloneDeep(originalData);
   for (const c in constraint) {
diff --git a/packages/repository/src/repositories/index.ts b/packages/repository/src/repositories/index.ts
@@ -5,6 +5,7 @@
 
 export * from './kv.repository';
 export * from './legacy-juggler-bridge';
+export * from './kv.repository.bridge';
 export * from './repository';
 export * from './relation.factory';
 export * from './relation.repository';
diff --git a/packages/repository/src/repositories/kv.repository.bridge.ts b/packages/repository/src/repositories/kv.repository.bridge.ts
@@ -0,0 +1,69 @@
+// Copyright IBM Corp. 2017,2018. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import * as legacy from 'loopback-datasource-juggler';
+
+import {Options, DataObject} from '../common-types';
+import {Model} from '../model';
+
+import {KVRepository, AsyncIterator, KVFilter} from './kv.repository';
+
+import {juggler, ensurePromise} from './legacy-juggler-bridge';
+
+/**
+ * An implementation of KVRepository based on legacy loopback-datasource-juggler
+ */
+export class DefaultKVRepository<T extends Model> implements KVRepository<T> {
+  kvModelClass: typeof juggler.KeyValueModel;
+
+  constructor(kvModelClass: typeof juggler.KeyValueModel) {
+    this.kvModelClass = kvModelClass;
+  }
+
+  delete(key: string, options?: Options): Promise<void> {
+    return ensurePromise(this.kvModelClass.delete(key, options));
+  }
+
+  deleteAll(options?: Options): Promise<void> {
+    return ensurePromise(this.kvModelClass.deleteAll(options));
+  }
+
+  get(key: string, options?: Options): Promise<T> {
+    const val = this.kvModelClass.get(key, options) as legacy.PromiseOrVoid<T>;
+    return ensurePromise<T>(val);
+  }
+
+  set(key: string, value: DataObject<T>, options?: Options): Promise<void> {
+    return ensurePromise<void>(this.kvModelClass.set(key, value, options));
+  }
+
+  expire(key: string, ttl: number, options?: Options): Promise<void> {
+    return ensurePromise<void>(this.kvModelClass.expire(key, ttl, options));
+  }
+
+  ttl(key: string, options?: Options): Promise<number> {
+    return ensurePromise<number>(this.kvModelClass.ttl(key, options));
+  }
+
+  keys(filter?: KVFilter, options?: Options): Promise<string[]> {
+    return ensurePromise<string[]>(this.kvModelClass.keys(filter, options));
+  }
+
+  iterateKeys(filter?: KVFilter, options?: Options): AsyncIterator<string> {
+    return new AsyncKeyIteratorImpl(
+      this.kvModelClass.iterateKeys(filter, options),
+    );
+  }
+}
+
+class AsyncKeyIteratorImpl implements AsyncIterator<string> {
+  constructor(private keys: legacy.AsyncKeyIterator) {}
+  next() {
+    const key = ensurePromise<string | undefined>(this.keys.next());
+    return key.then(k => {
+      return {done: k === undefined, value: k || ''};
+    });
+  }
+}
diff --git a/packages/repository/src/repositories/kv.repository.ts b/packages/repository/src/repositories/kv.repository.ts
@@ -6,7 +6,28 @@
 import {Repository} from './repository';
 import {Options, DataObject} from '../common-types';
 import {Model} from '../model';
-import {Filter} from '../query';
+
+/**
+ * Filter for keys
+ */
+export type KVFilter = {
+  /**
+   * Glob string to use to filter returned keys (i.e. `userid.*`). All
+   * connectors are required to support `*` and `?`. They may also support
+   * additional special characters that are specific to the backing database.
+   */
+  match: string;
+};
+
+/**
+ * Polyfill for AsyncIterator before es.next is ready
+ */
+// tslint:disable:no-any
+export interface AsyncIterator<T> {
+  next(value?: any): Promise<IteratorResult<T>>;
+  return?(value?: any): Promise<IteratorResult<T>>;
+  throw?(e?: any): Promise<IteratorResult<T>>;
+}
 
 /**
  * Key/Value operations for connector implementations
@@ -17,19 +38,16 @@ export interface KVRepository<T extends Model> extends Repository<T> {
    *
    * @param key Key for the entry
    * @param options Options for the operation
-   * @returns Promise<true> if an entry is deleted for the key, otherwise
-   * Promise<false>
    */
-  delete(key: string, options?: Options): Promise<boolean>;
+  delete(key: string, options?: Options): Promise<void>;
 
   /**
    * Delete all entries
    *
    * @param key Key for the entry
    * @param options Options for the operation
-   * @returns A promise of the number of entries deleted
    */
-  deleteAll(options?: Options): Promise<number>;
+  deleteAll(options?: Options): Promise<void>;
 
   /**
    * Get an entry by key
@@ -46,20 +64,16 @@ export interface KVRepository<T extends Model> extends Repository<T> {
    * @param key Key for the entry
    * @param value Value for the entry
    * @param options Options for the operation
-   * @returns Promise<true> if an entry is set for the key, otherwise
-   * Promise<false>
    */
-  set(key: string, value: DataObject<T>, options?: Options): Promise<boolean>;
+  set(key: string, value: DataObject<T>, options?: Options): Promise<void>;
 
   /**
    * Set up ttl for an entry by key
    *
    * @param key Key for the entry
    * @param options Options for the operation
-   * @returns Promise<true> if an entry is set for the key, otherwise
-   * Promise<false>
    */
-  expire(key: string, ttl: number, options?: Options): Promise<boolean>;
+  expire(key: string, ttl: number, options?: Options): Promise<void>;
 
   /**
    * Get ttl for an entry by key
@@ -68,23 +82,28 @@ export interface KVRepository<T extends Model> extends Repository<T> {
    * @param options Options for the operation
    * @returns A promise of the TTL value
    */
-  ttl?(key: string, ttl: number, options?: Options): Promise<number>;
+  ttl?(key: string, options?: Options): Promise<number>;
 
   /**
    * Fetch all keys
    *
-   * @param key Key for the entry
+   * @param filter Filter for keys
    * @param options Options for the operation
    * @returns A promise of an array of keys for all entries
    */
-  keys?(options?: Options): Promise<string[]>;
+  keys?(filter?: KVFilter, options?: Options): Promise<string[]>;
 
   /**
    * Get an Iterator for matching keys
    *
    * @param filter Filter for keys
    * @param options Options for the operation
-   * @returns A promise of an iterator of entries
+   * @returns An iterator of keys.
+   *
+   * FIXME(rfeng): It's probably better to return an object that supports async
+   * iteration ("iterable" if it has a Symbol.asyncIterator method that returns
+   * an AsyncIterator object) so that the return value can be used with
+   * `for-await-of`.
    */
-  iterateKeys?(filter?: Filter, options?: Options): Promise<Iterator<T>>;
+  iterateKeys?(filter?: KVFilter, options?: Options): AsyncIterator<string>;
 }
diff --git a/packages/repository/src/repositories/legacy-juggler-bridge.ts b/packages/repository/src/repositories/legacy-juggler-bridge.ts
@@ -13,6 +13,7 @@ import {
   Command,
   NamedParameters,
   PositionalParameters,
+  DataObject,
 } from '../common-types';
 import {Entity, ModelDefinition} from '../model';
 import {Filter, Where} from '../query';
@@ -31,6 +32,7 @@ export namespace juggler {
   export import ModelBase = legacy.ModelBase;
   export import ModelBaseClass = legacy.ModelBaseClass;
   export import PersistedModel = legacy.PersistedModel;
+  export import KeyValueModel = legacy.KeyValueModel;
   export import PersistedModelClass = legacy.PersistedModelClass;
 }
 
@@ -55,7 +57,7 @@ export function bindModel<T extends juggler.ModelBaseClass>(
  * @param p Promise or void
  */
 /* tslint:disable-next-line:no-any */
-function ensurePromise<T>(p: legacy.PromiseOrVoid<T>): Promise<T> {
+export function ensurePromise<T>(p: legacy.PromiseOrVoid<T>): Promise<T> {
   if (p && isPromiseLike(p)) {
     // Juggler uses promise-like Bluebird instead of native Promise
     // implementation. We need to convert the promise returned by juggler
@@ -161,12 +163,12 @@ export class DefaultCrudRepository<T extends Entity, ID>
     );
   }
 
-  async create(entity: Partial<T>, options?: Options): Promise<T> {
+  async create(entity: DataObject<T>, options?: Options): Promise<T> {
     const model = await ensurePromise(this.modelClass.create(entity, options));
     return this.toEntity(model);
   }
 
-  async createAll(entities: Partial<T>[], options?: Options): Promise<T[]> {
+  async createAll(entities: DataObject<T>[], options?: Options): Promise<T[]> {
     const models = await ensurePromise(
       this.modelClass.create(entities, options),
     );
@@ -215,7 +217,7 @@ export class DefaultCrudRepository<T extends Entity, ID>
   }
 
   updateAll(
-    data: Partial<T>,
+    data: DataObject<T>,
     where?: Where,
     options?: Options,
   ): Promise<number> {
@@ -224,14 +226,18 @@ export class DefaultCrudRepository<T extends Entity, ID>
     );
   }
 
-  updateById(id: ID, data: Partial<T>, options?: Options): Promise<boolean> {
+  updateById(id: ID, data: DataObject<T>, options?: Options): Promise<boolean> {
     const idProp = this.modelClass.definition.idName();
     const where = {} as Where;
     where[idProp] = id;
     return this.updateAll(data, where, options).then(count => count > 0);
   }
 
-  replaceById(id: ID, data: Partial<T>, options?: Options): Promise<boolean> {
+  replaceById(
+    id: ID,
+    data: DataObject<T>,
+    options?: Options,
+  ): Promise<boolean> {
     return ensurePromise(this.modelClass.replaceById(id, data, options)).then(
       result => !!result,
     );
diff --git a/packages/repository/src/repositories/relation.factory.ts b/packages/repository/src/repositories/relation.factory.ts
@@ -10,6 +10,7 @@ import {
   HasManyRepository,
   DefaultHasManyEntityCrudRepository,
 } from './relation.repository';
+import {DataObject} from '..';
 
 export type HasManyRepositoryFactory<SourceID, Target extends Entity> = (
   fkValue: SourceID,
@@ -43,10 +44,12 @@ export function createHasManyRepositoryFactory<
         'The foreign key property name (keyTo) must be specified',
       );
     }
+    // tslint:disable-next-line:no-any
+    const constraint: any = {[fkName]: fkValue};
     return new DefaultHasManyEntityCrudRepository<
       Target,
       TargetID,
       EntityCrudRepository<Target, TargetID>
-    >(targetRepository, {[fkName]: fkValue});
+    >(targetRepository, constraint as DataObject<Target>);
   };
 }
diff --git a/packages/repository/src/repositories/relation.repository.ts b/packages/repository/src/repositories/relation.repository.ts
diff --git a/packages/repository/test/unit/repositories/kv.repository.bridge.unit.ts b/packages/repository/test/unit/repositories/kv.repository.bridge.unit.ts
diff --git a/packages/repository/test/unit/repositories/relation.repository.unit.ts b/packages/repository/test/unit/repositories/relation.repository.unit.ts
diff --git a/packages/service-proxy/package.json b/packages/service-proxy/package.json

Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ export abstract class Model {`
`177`	`177`	`return obj;`
`178`	`178`	`}`
`179`	`179`
`180`		`- constructor(data?: Partial<Model>) {`
	`180`	`+ constructor(data?: DataObject<Model>) {`
`181`	`181`	`Object.assign(this, data);`
`182`	`182`	`}`
`183`	`183`	`}`