@loopback/repository 2.5.1 → 2.9.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@loopback/repository",
-  "version": "2.5.1",
-  "description": "Repository based persistence for LoopBack 4",
+  "version": "2.9.0",
+  "description": "Define and implement a common set of interfaces for interacting with databases",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "engines": {
-    "node": ">=10"
+    "node": ">=10.16"
   },
   "scripts": {
     "acceptance": "lb-mocha \"dist/__tests__/acceptance/**/*.js\"",
@@ -18,19 +18,21 @@
   "author": "IBM Corp.",
   "copyright.owner": "IBM Corp.",
   "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
-    "@loopback/build": "^5.4.1",
-    "@loopback/eslint-config": "^7.0.1",
-    "@loopback/testlab": "^3.1.5",
+    "@loopback/build": "^6.1.0",
+    "@loopback/eslint-config": "^8.0.3",
+    "@loopback/testlab": "^3.2.0",
     "@types/bson": "^4.0.2",
-    "@types/json-schema": "^7.0.4",
-    "@types/lodash": "^4.14.152",
-    "@types/node": "^10.17.24",
+    "@types/json-schema": "^7.0.5",
+    "@types/lodash": "^4.14.157",
+    "@types/node": "^10.17.26",
     "bson": "4.0.4"
   },
   "dependencies": {
-    "@loopback/context": "^3.8.1",
-    "@loopback/core": "^2.7.0",
+    "@loopback/core": "^2.9.1",
     "@types/debug": "^4.1.5",
     "debug": "^4.1.1",
     "lodash": "^4.17.15",
@@ -48,5 +50,5 @@
     "url": "https://github.com/strongloop/loopback-next.git",
     "directory": "packages/repository"
   },
-  "gitHead": "62aea854bf85c5a5995b59e6908fe5409f7eea96"
+  "gitHead": "b89db3d3b8be6a36e63e91c2331d217fda7538de"
 }

package/src/decorators/metadata.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {InspectionOptions, MetadataInspector} from '@loopback/context';
+import {InspectionOptions, MetadataInspector} from '@loopback/core';
 import {ModelDefinition, RelationDefinitionMap} from '../model';
 import {RELATIONS_KEY} from '../relations';
 import {

package/src/decorators/model.decorator.ts

@@ -9,7 +9,7 @@ import {
   MetadataInspector,
   MetadataMap,
   PropertyDecoratorFactory,
-} from '@loopback/context';
+} from '@loopback/core';
 import {
   ModelDefinition,
   ModelDefinitionSyntax,

package/src/decorators/repository.decorator.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Context, inject, Injection} from '@loopback/context';
+import {Context, inject, Injection} from '@loopback/core';
 import assert from 'assert';
 import {Class} from '../common-types';
 import {DataSource} from '../datasource';

package/src/define-model-class.ts

@@ -79,10 +79,10 @@ export function defineModelClass<
 export type DynamicModelCtor<
   BaseCtor extends typeof Model,
   Props extends object
-> = BaseCtor & {
+> = {
   /** Model constructor accepting partial model data. */
   new (data?: DataObject<PrototypeOf<BaseCtor> & Props>): PrototypeOf<
     BaseCtor
   > &
     Props;
-};
+} & BaseCtor;

package/src/mixins/repository.mixin.ts

@@ -8,7 +8,7 @@ import {
   BindingFromClassOptions,
   BindingScope,
   createBindingFromClass,
-} from '@loopback/context';
+} from '@loopback/core';
 import {
   Application,
   Component,
@@ -27,35 +27,9 @@ const debug = debugFactory('loopback:repository:mixin');
 
 // FIXME(rfeng): Workaround for https://github.com/microsoft/rushstack/pull/1867
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import {
-  BindingAddress,
-  BindingFilter,
-  JSONObject,
-  Provider,
-  Context,
-  ContextSubscriptionManager,
-  ContextEvent,
-  Interceptor,
-  InterceptorBindingOptions,
-  ResolutionOptions,
-  BindingKey,
-  ValueOrPromise,
-  ContextEventObserver,
-  ContextObserver,
-  Subscription,
-  BindingComparator,
-  ContextView,
-  ResolutionSession,
-  BindingCreationPolicy,
-  ContextInspectOptions,
-} from '@loopback/context';
-import {
-  Server,
-  ApplicationConfig,
-  ApplicationMetadata,
-  LifeCycleObserver,
-  ServiceOptions,
-} from '@loopback/core';
+import * as loopbackContext from '@loopback/core';
+import * as loopbackCore from '@loopback/core';
+/* eslint-enable @typescript-eslint/no-unused-vars */
 
 /**
  * A mixin class for Application that creates a .repository()
@@ -70,6 +44,12 @@ import {
  * Please note: the members in the mixin function are documented in a dummy class
  * called <a href="#RepositoryMixinDoc">RepositoryMixinDoc</a>
  *
+ * @param superClass - Application class
+ * @returns A new class that extends the super class with repository related
+ * methods
+ *
+ * @typeParam T - Type of the application class as the target for the mixin
+ *
  */
 export function RepositoryMixin<T extends MixinTarget<Application>>(
   superClass: T,
@@ -214,35 +194,66 @@ export function RepositoryMixin<T extends MixinTarget<Application>>(
      */
     // Unfortunately, TypeScript does not allow overriding methods inherited
     // from mapped types. https://github.com/microsoft/TypeScript/issues/38496
-    // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     public component<C extends Component = Component>(
       componentCtor: Constructor<C>,
       nameOrOptions?: string | BindingFromClassOptions,
     ) {
       const binding = super.component(componentCtor, nameOrOptions);
-      this.mountComponentRepositories(componentCtor);
+      const instance = this.getSync<C & RepositoryComponent>(binding.key);
+      this.mountComponentRepositories(instance);
+      this.mountComponentModels(instance);
       return binding;
     }
 
     /**
      * Get an instance of a component and mount all it's
      * repositories. This function is intended to be used internally
-     * by component()
+     * by `component()`.
+     *
+     * NOTE: Calling `mountComponentRepositories` with a component class
+     * constructor is deprecated. You should instantiate the component
+     * yourself and provide the component instance instead.
      *
-     * @param component - The component to mount repositories of
+     * @param componentInstanceOrClass - The component to mount repositories of
+     * @internal
      */
-    mountComponentRepositories(component: Class<unknown>) {
-      const componentKey = `${CoreBindings.COMPONENTS}.${component.name}`;
-      const compInstance = this.getSync<{
-        repositories?: Class<Repository<Model>>[];
-      }>(componentKey);
+    mountComponentRepositories(
+      // accept also component class to preserve backwards compatibility
+      // TODO(semver-major) Remove support for component class constructor
+      componentInstanceOrClass: Class<unknown> | RepositoryComponent,
+    ) {
+      const component = resolveComponentInstance(this);
 
-      if (compInstance.repositories) {
-        for (const repo of compInstance.repositories) {
+      if (component.repositories) {
+        for (const repo of component.repositories) {
           this.repository(repo);
         }
       }
+
+      // `Readonly<Application>` is a hack to remove protected members
+      // and thus allow `this` to be passed as a value for `ctx`
+      function resolveComponentInstance(ctx: Readonly<Application>) {
+        if (typeof componentInstanceOrClass !== 'function')
+          return componentInstanceOrClass;
+
+        const componentName = componentInstanceOrClass.name;
+        const componentKey = `${CoreBindings.COMPONENTS}.${componentName}`;
+        return ctx.getSync<RepositoryComponent>(componentKey);
+      }
+    }
+
+    /**
+     * Bind all model classes provided by a component.
+     * @param component
+     * @internal
+     */
+    mountComponentModels(component: RepositoryComponent) {
+      if (!component.models) return;
+      for (const m of component.models) {
+        this.model(m);
+      }
     }
 
     /**
@@ -287,6 +298,24 @@ export function RepositoryMixin<T extends MixinTarget<Application>>(
   };
 }
 
+/**
+ * This interface describes additional Component properties
+ * allowing components to contribute Repository-related artifacts.
+ */
+export interface RepositoryComponent {
+  /**
+   * An optional list of Repository classes to bind for dependency injection
+   * via `app.repository()` API.
+   */
+  repositories?: Class<Repository<Model>>[];
+
+  /**
+   * An optional list of Model classes to bind for dependency injection
+   * via `app.model()` API.
+   */
+  models?: Class<Model>[];
+}
+
 /**
  * Normalize name or options to `BindingFromClassOptions`
  * @param nameOrOptions - Name or options for binding from class

package/src/model.ts

@@ -216,7 +216,7 @@ function asObject(value: any, options?: Options): any {
  */
 export abstract class Model {
   static get modelName(): string {
-    return (this.definition && this.definition.name) || this.name;
+    return this.definition?.name || this.name;
   }
 
   static definition: ModelDefinition;
@@ -268,7 +268,7 @@ export abstract class Model {
     const def = (this.constructor as typeof Model).definition;
     const obj: AnyObject = {};
 
-    if (options && options.ignoreUnknownProperties === false) {
+    if (options?.ignoreUnknownProperties === false) {
       const hiddenProperties: string[] = def?.settings.hiddenProperties || [];
       for (const p in this) {
         if (!hiddenProperties.includes(p)) {

package/src/query.ts

@@ -442,6 +442,61 @@ export class WhereBuilder<MT extends object = AnyObject> {
     return this;
   }
 
+  /**
+   * Add a `like` condition
+   * @param key - Property name
+   * @param val - Regexp condition
+   */
+  like<K extends KeyOf<MT>>(key: K, val: MT[K]): this {
+    const w: Where<MT> = {};
+    w[key] = {like: val};
+    return this.add(w);
+  }
+
+  /**
+   * Add a `nlike` condition
+   * @param key - Property name
+   * @param val - Regexp condition
+   */
+  nlike<K extends KeyOf<MT>>(key: K, val: MT[K]): this {
+    const w: Where<MT> = {};
+    w[key] = {nlike: val};
+    return this.add(w);
+  }
+
+  /**
+   * Add a `ilike` condition
+   * @param key - Property name
+   * @param val - Regexp condition
+   */
+  ilike<K extends KeyOf<MT>>(key: K, val: MT[K]): this {
+    const w: Where<MT> = {};
+    w[key] = {ilike: val};
+    return this.add(w);
+  }
+
+  /**
+   * Add a `nilike` condition
+   * @param key - Property name
+   * @param val - Regexp condition
+   */
+  nilike<K extends KeyOf<MT>>(key: K, val: MT[K]): this {
+    const w: Where<MT> = {};
+    w[key] = {nilike: val};
+    return this.add(w);
+  }
+
+  /**
+   * Add a `regexp` condition
+   * @param key - Property name
+   * @param val - Regexp condition
+   */
+  regexp<K extends KeyOf<MT>>(key: K, val: string | RegExp): this {
+    const w: Where<MT> = {};
+    w[key] = {regexp: val};
+    return this.add(w);
+  }
+
   /**
    * Get the where object
    */

package/src/relations/belongs-to/belongs-to.decorator.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {MetadataInspector} from '@loopback/context';
+import {MetadataInspector} from '@loopback/core';
 import {property} from '../../decorators/model.decorator';
 import {Entity, EntityResolver, PropertyDefinition} from '../../model';
 import {relation} from '../relation.decorator';

package/src/relations/belongs-to/belongs-to.repository.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Getter} from '@loopback/context';
+import {Getter} from '@loopback/core';
 import {DataObject, Options} from '../../common-types';
 import {EntityNotFoundError} from '../../errors';
 import {Entity} from '../../model';

package/src/relations/has-many/has-many-through-repository.factory.ts

@@ -0,0 +1,100 @@
+// Copyright IBM Corp. 2020. 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 {
+  DataObject,
+  Entity,
+  EntityCrudRepository,
+  Getter,
+  HasManyDefinition,
+} from '../..';
+import {
+  createTargetConstraintFromThrough,
+  createThroughConstraintFromSource,
+  createThroughConstraintFromTarget,
+  getTargetKeysFromThroughModels,
+  resolveHasManyThroughMetadata,
+} from './has-many-through.helpers';
+import {
+  DefaultHasManyThroughRepository,
+  HasManyThroughRepository,
+} from './has-many-through.repository';
+
+/**
+ * a factory to generate hasManyThrough repository class.
+ *
+ * Warning: The hasManyThrough interface is experimental and is subject to change.
+ * If backwards-incompatible changes are made, a new major version may not be
+ * released.
+ */
+
+export type HasManyThroughRepositoryFactory<
+  TargetEntity extends Entity,
+  TargetID,
+  ThroughEntity extends Entity,
+  SourceID
+> = (
+  fkValue: SourceID,
+) => HasManyThroughRepository<TargetEntity, TargetID, ThroughEntity>;
+
+export function createHasManyThroughRepositoryFactory<
+  Target extends Entity,
+  TargetID,
+  Through extends Entity,
+  ThroughID,
+  SourceID
+>(
+  relationMetadata: HasManyDefinition,
+  targetRepositoryGetter: Getter<EntityCrudRepository<Target, TargetID>>,
+  throughRepositoryGetter: Getter<EntityCrudRepository<Through, ThroughID>>,
+): HasManyThroughRepositoryFactory<Target, TargetID, Through, SourceID> {
+  const meta = resolveHasManyThroughMetadata(relationMetadata);
+  const result = function (fkValue: SourceID) {
+    function getTargetConstraintFromThroughModels(
+      throughInstances: Through[],
+    ): DataObject<Target> {
+      return createTargetConstraintFromThrough<Target, Through>(
+        meta,
+        throughInstances,
+      );
+    }
+    function getTargetKeys(throughInstances: Through[]): TargetID[] {
+      return getTargetKeysFromThroughModels(meta, throughInstances);
+    }
+    function getThroughConstraintFromSource(): DataObject<Through> {
+      const constraint: DataObject<Through> = createThroughConstraintFromSource<
+        Through,
+        SourceID
+      >(meta, fkValue);
+      return constraint;
+    }
+
+    function getThroughConstraintFromTarget(
+      fkValues: TargetID[],
+    ): DataObject<Through> {
+      const constraint: DataObject<Through> = createThroughConstraintFromTarget<
+        Through,
+        TargetID
+      >(meta, fkValues);
+      return constraint;
+    }
+
+    return new DefaultHasManyThroughRepository<
+      Target,
+      TargetID,
+      EntityCrudRepository<Target, TargetID>,
+      Through,
+      ThroughID,
+      EntityCrudRepository<Through, ThroughID>
+    >(
+      targetRepositoryGetter,
+      throughRepositoryGetter,
+      getTargetConstraintFromThroughModels,
+      getTargetKeys,
+      getThroughConstraintFromSource,
+      getThroughConstraintFromTarget,
+    );
+  };
+  return result;
+}

package/src/relations/has-many/has-many-through.helpers.ts

@@ -1,7 +1,13 @@
+// Copyright IBM Corp. 2020. 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 debugFactory from 'debug';
 import {camelCase} from 'lodash';
 import {
   DataObject,
+  deduplicate,
   Entity,
   HasManyDefinition,
   InvalidRelationError,
@@ -21,10 +27,9 @@ export type HasManyThroughResolvedDefinition = HasManyDefinition & {
 };
 
 /**
- * Creates constraint used to query target
- * @param relationMeta - hasManyThrough metadata to resolve
- * @param throughInstances - Instances of through entities used to constrain the target
- * @internal
+ * Creates target constraint based on through models
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param throughInstances - an array of through instances
  *
  * @example
  * ```ts
@@ -38,33 +43,40 @@ export type HasManyThroughResolvedDefinition = HasManyDefinition & {
  *    keyTo: 'productId',
  *  },
  * };
-
- * createTargetConstraint(resolvedMetadata, [
+ * createTargetConstraintFromThrough(resolvedMetadata,[{
+        id: 2,
+        categoryId: 2,
+        productId: 8,
+      }]);
+ * >>> {id: 8}
+ * createTargetConstraintFromThrough(resolvedMetadata, [
       {
         id: 2,
         categoryId: 2,
         productId: 8,
       }, {
-        id: 2,
+        id: 1,
         categoryId: 2,
         productId: 9,
       }
   ]);
+
+  >>> {id: {inq: [9, 8]}}
  * ```
  */
-export function createTargetConstraint<
+export function createTargetConstraintFromThrough<
   Target extends Entity,
   Through extends Entity
 >(
   relationMeta: HasManyThroughResolvedDefinition,
   throughInstances: Through[],
 ): DataObject<Target> {
-  const targetPrimaryKey = relationMeta.keyTo;
-  const targetFkName = relationMeta.through.keyTo;
-  const fkValues = throughInstances.map(
-    (throughInstance: Through) =>
-      throughInstance[targetFkName as keyof Through],
+  const fkValues = getTargetKeysFromThroughModels(
+    relationMeta,
+    throughInstances,
   );
+  const targetPrimaryKey = relationMeta.keyTo;
+
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const constraint: any = {
     [targetPrimaryKey]: fkValues.length === 1 ? fkValues[0] : {inq: fkValues},
@@ -73,11 +85,64 @@ export function createTargetConstraint<
 }
 
 /**
- * Creates constraint used to query through model
+ * Returns an array of target fks of the given throughInstances.
  *
- * @param relationMeta - hasManyThrough metadata to resolve
- * @param fkValue - Value of the foreign key of the source model used to constrain through
- * @param targetInstance - Instance of target entity used to constrain through
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param throughInstances - an array of through instances
+ *
+ * @example
+ * ```ts
+ * const resolvedMetadata = {
+ *  // .. other props
+ *  keyFrom: 'id',
+ *  keyTo: 'id',
+ *  through: {
+ *    model: () => CategoryProductLink,
+ *    keyFrom: 'categoryId',
+ *    keyTo: 'productId',
+ *  },
+ * };
+ * getTargetKeysFromThroughModels(resolvedMetadata,[{
+        id: 2,
+        categoryId: 2,
+        productId: 8,
+      }]);
+ * >>> [8]
+ * getTargetKeysFromThroughModels(resolvedMetadata, [
+      {
+        id: 2,
+        categoryId: 2,
+        productId: 8,
+      }, {
+        id: 1,
+        categoryId: 2,
+        productId: 9,
+      }
+  ]);
+  >>> [8, 9]
+ */
+export function getTargetKeysFromThroughModels<
+  Through extends Entity,
+  TargetID
+>(
+  relationMeta: HasManyThroughResolvedDefinition,
+  throughInstances: Through[],
+): TargetID[] {
+  const targetFkName = relationMeta.through.keyTo;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let fkValues: any = throughInstances.map(
+    (throughInstance: Through) =>
+      throughInstance[targetFkName as keyof Through],
+  );
+  fkValues = deduplicate(fkValues);
+  return fkValues as TargetID[];
+}
+
+/**
+ * Creates through constraint based on the source key
+ *
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param fkValue - foreign key of the source instance
  * @internal
  *
  * @example
@@ -92,18 +157,70 @@ export function createTargetConstraint<
  *    keyTo: 'productId',
  *  },
  * };
- * createThroughConstraint(resolvedMetadata, 1);
+ * createThroughConstraintFromSource(resolvedMetadata, 1);
+ *
+ * >>> {categoryId: 1}
  * ```
  */
-export function createThroughConstraint<Through extends Entity, ForeignKeyType>(
+export function createThroughConstraintFromSource<
+  Through extends Entity,
+  SourceID
+>(
   relationMeta: HasManyThroughResolvedDefinition,
-  fkValue: ForeignKeyType,
+  fkValue: SourceID,
 ): DataObject<Through> {
   const sourceFkName = relationMeta.through.keyFrom;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const constraint: any = {[sourceFkName]: fkValue};
   return constraint;
 }
+/**
+ * Creates through constraint based on the target foreign key
+ *
+ * @param relationMeta - resolved hasManyThrough metadata
+ * @param fkValue an array of the target instance foreign keys
+ * @internal
+ *
+ * @example
+ * ```ts
+ * const resolvedMetadata = {
+ *  // .. other props
+ *  keyFrom: 'id',
+ *  keyTo: 'id',
+ *  through: {
+ *    model: () => CategoryProductLink,
+ *    keyFrom: 'categoryId',
+ *    keyTo: 'productId',
+ *  },
+ * };
+ * createThroughConstraintFromTarget(resolvedMetadata, [3]);
+ *
+ * >>> {productId: 3}
+ *
+ * createThroughConstraintFromTarget(resolvedMetadata, [3,4]);
+ *
+ * >>> {productId: {inq:[3,4]}}
+ */
+export function createThroughConstraintFromTarget<
+  Through extends Entity,
+  TargetID
+>(
+  relationMeta: HasManyThroughResolvedDefinition,
+  fkValues: TargetID[],
+): DataObject<Through> {
+  if (fkValues === undefined || fkValues.length === 0) {
+    throw new Error('"fkValue" must be provided');
+  }
+  const targetFkName = relationMeta.through.keyTo;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const constraint: any =
+    fkValues.length === 1
+      ? {[targetFkName]: fkValues[0]}
+      : {[targetFkName]: {inq: fkValues}};
+
+  return constraint as DataObject<Through>;
+}
 
 /**
  * Resolves given hasMany metadata if target is specified to be a resolver.
@@ -142,7 +259,7 @@ export function resolveHasManyThroughMetadata(
     relationMeta.keyTo &&
     targetModelProperties[relationMeta.keyTo]
   ) {
-    // The explict cast is needed because of a limitation of type inference
+    // The explicit cast is needed because of a limitation of type inference
     return relationMeta as HasManyThroughResolvedDefinition;
   }