@loopback/repository 1.10.1 → 1.13.1

package/src/repositories/legacy-juggler-bridge.ts

@@ -17,7 +17,7 @@ import {
 } from '../common-types';
 import {EntityNotFoundError} from '../errors';
 import {Entity, Model, PropertyType} from '../model';
-import {Filter, Where} from '../query';
+import {Filter, Inclusion, Where} from '../query';
 import {
   BelongsToAccessor,
   BelongsToDefinition,
@@ -28,9 +28,15 @@ import {
   HasManyRepositoryFactory,
   HasOneDefinition,
   HasOneRepositoryFactory,
+  includeRelatedModels,
+  InclusionResolver,
 } from '../relations';
+import {IsolationLevel, Transaction} from '../transaction';
 import {isTypeResolver, resolveType} from '../type-resolver';
-import {EntityCrudRepository} from './repository';
+import {
+  EntityCrudRepository,
+  TransactionalEntityRepository,
+} from './repository';
 
 export namespace juggler {
   /* eslint-disable @typescript-eslint/no-unused-vars */
@@ -40,6 +46,10 @@ export namespace juggler {
   export import PersistedModel = legacy.PersistedModel;
   export import KeyValueModel = legacy.KeyValueModel;
   export import PersistedModelClass = legacy.PersistedModelClass;
+  // eslint-disable-next-line no-shadow
+  export import Transaction = legacy.Transaction;
+  // eslint-disable-next-line no-shadow
+  export import IsolationLevel = legacy.IsolationLevel;
 }
 
 function isModelClass(
@@ -92,6 +102,11 @@ export class DefaultCrudRepository<
 > implements EntityCrudRepository<T, ID, Relations> {
   modelClass: juggler.PersistedModelClass;
 
+  public readonly inclusionResolvers: Map<
+    string,
+    InclusionResolver<T, Entity>
+  > = new Map();
+
   /**
    * Constructor of DefaultCrudRepository
    * @param entityClass - Legacy entity class
@@ -345,18 +360,30 @@ export class DefaultCrudRepository<
     filter?: Filter<T>,
     options?: Options,
   ): Promise<(T & Relations)[]> {
+    const include = filter && filter.include;
     const models = await ensurePromise(
-      this.modelClass.find(filter as legacy.Filter, options),
+      this.modelClass.find(this.normalizeFilter(filter), options),
     );
-    return this.toEntities(models);
+    const entities = this.toEntities(models);
+    return this.includeRelatedModels(entities, include, options);
   }
 
-  async findOne(filter?: Filter<T>, options?: Options): Promise<T | null> {
+  async findOne(
+    filter?: Filter<T>,
+    options?: Options,
+  ): Promise<(T & Relations) | null> {
     const model = await ensurePromise(
-      this.modelClass.findOne(filter as legacy.Filter, options),
+      this.modelClass.findOne(this.normalizeFilter(filter), options),
     );
     if (!model) return null;
-    return this.toEntity(model);
+    const entity = this.toEntity(model);
+    const include = filter && filter.include;
+    const resolved = await this.includeRelatedModels(
+      [entity],
+      include,
+      options,
+    );
+    return resolved[0];
   }
 
   async findById(
@@ -364,13 +391,20 @@ export class DefaultCrudRepository<
     filter?: Filter<T>,
     options?: Options,
   ): Promise<T & Relations> {
+    const include = filter && filter.include;
     const model = await ensurePromise(
-      this.modelClass.findById(id, filter as legacy.Filter, options),
+      this.modelClass.findById(id, this.normalizeFilter(filter), options),
     );
     if (!model) {
       throw new EntityNotFoundError(this.entityClass, id);
     }
-    return this.toEntity<T & Relations>(model);
+    const entity = this.toEntity(model);
+    const resolved = await this.includeRelatedModels(
+      [entity],
+      include,
+      options,
+    );
+    return resolved[0];
   }
 
   update(entity: T, options?: Options): Promise<void> {
@@ -460,4 +494,67 @@ export class DefaultCrudRepository<
   protected toEntities<R extends T>(models: juggler.PersistedModel[]): R[] {
     return models.map(m => this.toEntity<R>(m));
   }
+
+  /**
+   * Register an inclusion resolver for the related model name.
+   *
+   * @param relationName - Name of the relation defined on the source model
+   * @param resolver - Resolver function for getting related model entities
+   */
+  registerInclusionResolver(
+    relationName: string,
+    resolver: InclusionResolver<T, Entity>,
+  ) {
+    this.inclusionResolvers.set(relationName, resolver);
+  }
+
+  /**
+   * Returns model instances that include related models of this repository
+   * that have a registered resolver.
+   *
+   * @param entities - An array of entity instances or data
+   * @param include -Inclusion filter
+   * @param options - Options for the operations
+   */
+  protected async includeRelatedModels(
+    entities: T[],
+    include?: Inclusion<T>[],
+    options?: Options,
+  ): Promise<(T & Relations)[]> {
+    return includeRelatedModels<T, Relations>(this, entities, include, options);
+  }
+
+  /**
+   * Removes juggler's "include" filter as it does not apply to LoopBack 4
+   * relations.
+   *
+   * @param filter - Query filter
+   */
+  protected normalizeFilter(filter?: Filter<T>): legacy.Filter | undefined {
+    if (!filter) return undefined;
+    return {...filter, include: undefined} as legacy.Filter;
+  }
+}
+
+/**
+ * Default implementation of CRUD repository using legacy juggler model
+ * and data source with beginTransaction() method for connectors which
+ * support Transactions
+ */
+
+export class DefaultTransactionalRepository<
+  T extends Entity,
+  ID,
+  Relations extends object = {}
+> extends DefaultCrudRepository<T, ID, Relations>
+  implements TransactionalEntityRepository<T, ID, Relations> {
+  async beginTransaction(
+    options?: IsolationLevel | Options,
+  ): Promise<Transaction> {
+    const dsOptions: juggler.IsolationLevel | Options = options || {};
+    // juggler.Transaction still has the Promise/Callback variants of the
+    // Transaction methods
+    // so we need it cast it back
+    return (await this.dataSource.beginTransaction(dsOptions)) as Transaction;
+  }
 }

package/src/repositories/repository.ts

@@ -17,6 +17,8 @@ import {DataSource} from '../datasource';
 import {EntityNotFoundError} from '../errors';
 import {Entity, Model, ValueObject} from '../model';
 import {Filter, Where} from '../query';
+import {InclusionResolver} from '../relations/relation.types';
+import {IsolationLevel, Transaction} from '../transaction';
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
@@ -37,6 +39,31 @@ export interface ExecutableRepository<T extends Model> extends Repository<T> {
   ): Promise<AnyObject>;
 }
 
+/**
+ * A type for CRUD repositories that are backed by IDs and support
+ * Transactions
+ */
+export type TransactionalEntityRepository<
+  T extends Entity,
+  ID,
+  Relations extends object = {}
+> = TransactionalRepository<T> & EntityCrudRepository<T, ID>;
+/**
+ * Repository Interface for Repositories that support Transactions
+ *
+ * @typeParam T Generic type for the Entity
+ */
+export interface TransactionalRepository<T extends Entity>
+  extends Repository<T> {
+  /**
+   * Begin a new Transaction
+   * @param options - Options for the operations
+   * @returns Promise<Transaction> Promise that resolves to a new Transaction
+   * object
+   */
+  beginTransaction(options?: IsolationLevel | Options): Promise<Transaction>;
+}
+
 /**
  * Basic CRUD operations for ValueObject and Entity. No ID is required.
  */
@@ -114,6 +141,7 @@ export interface EntityCrudRepository<
 > extends EntityRepository<T, ID>, CrudRepository<T, Relations> {
   // entityClass should have type "typeof T", but that's not supported by TSC
   entityClass: typeof Entity & {prototype: T};
+  inclusionResolvers: Map<string, InclusionResolver<T, Entity>>;
 
   /**
    * Save an entity. If no id is present, create a new entity
@@ -220,6 +248,10 @@ export interface EntityCrudRepository<
 export class CrudRepositoryImpl<T extends Entity, ID>
   implements EntityCrudRepository<T, ID> {
   private connector: CrudConnector;
+  public readonly inclusionResolvers: Map<
+    string,
+    InclusionResolver<T, Entity>
+  > = new Map();
 
   constructor(
     public dataSource: DataSource,

package/src/transaction.ts

@@ -0,0 +1,34 @@
+// Copyright IBM Corp. 2019. All Rights Reserved.
+// Node module: @loopback/repository
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+/**
+ * Local transaction
+ */
+export interface Transaction {
+  /**
+   * Commit the transaction
+   */
+  commit(): Promise<void>;
+
+  /**
+   * Rollback the transaction
+   */
+  rollback(): Promise<void>;
+
+  /**
+   * The transaction Identifier
+   */
+  id: string;
+}
+
+/**
+ * Isolation level
+ */
+export enum IsolationLevel {
+  READ_COMMITTED = 'READ COMMITTED', // default
+  READ_UNCOMMITTED = 'READ UNCOMMITTED',
+  SERIALIZABLE = 'SERIALIZABLE',
+  REPEATABLE_READ = 'REPEATABLE READ',
+}