@loopback/repository 2.6.0 → 2.10.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@loopback/repository",
-  "version": "2.6.0",
-  "description": "Repository based persistence for LoopBack 4",
+  "version": "2.10.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,22 +18,24 @@
   "author": "IBM Corp.",
   "copyright.owner": "IBM Corp.",
   "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
-    "@loopback/build": "^5.4.2",
-    "@loopback/eslint-config": "^8.0.0",
-    "@loopback/testlab": "^3.1.6",
+    "@loopback/build": "^6.1.1",
+    "@loopback/eslint-config": "^8.0.4",
+    "@loopback/testlab": "^3.2.1",
     "@types/bson": "^4.0.2",
-    "@types/json-schema": "^7.0.4",
-    "@types/lodash": "^4.14.153",
-    "@types/node": "^10.17.24",
+    "@types/json-schema": "^7.0.5",
+    "@types/lodash": "^4.14.157",
+    "@types/node": "^10.17.27",
     "bson": "4.0.4"
   },
   "dependencies": {
-    "@loopback/context": "^3.8.2",
-    "@loopback/core": "^2.7.1",
+    "@loopback/core": "^2.9.2",
     "@types/debug": "^4.1.5",
     "debug": "^4.1.1",
-    "lodash": "^4.17.15",
+    "lodash": "^4.17.19",
     "loopback-datasource-juggler": "^4.21.2",
     "tslib": "^2.0.0"
   },
@@ -48,5 +50,5 @@
     "url": "https://github.com/strongloop/loopback-next.git",
     "directory": "packages/repository"
   },
-  "gitHead": "64afb3616e94b96703524aba8be722efefa7c2c5"
+  "gitHead": "5538896411bb56467ae52670a29d1aec1690be74"
 }

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,7 +27,7 @@ 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 * as loopbackContext from '@loopback/context';
+import * as loopbackContext from '@loopback/core';
 import * as loopbackCore from '@loopback/core';
 /* eslint-enable @typescript-eslint/no-unused-vars */
 
@@ -44,6 +44,12 @@ import * as loopbackCore from '@loopback/core';
  * 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,

package/src/model.ts

@@ -4,8 +4,14 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {AnyObject, DataObject, Options, PrototypeOf} from './common-types';
-import {JsonSchema} from './index';
-import {RelationMetadata} from './relations';
+import {
+  BelongsToDefinition,
+  HasManyDefinition,
+  HasOneDefinition,
+  JsonSchema,
+  RelationMetadata,
+  RelationType,
+} from './index';
 import {TypeResolver} from './type-resolver';
 import {Type} from './types';
 
@@ -145,6 +151,60 @@ export class ModelDefinition {
     return this;
   }
 
+  /**
+   * Define a new belongsTo relation.
+   * @param name - The name of the belongsTo relation.
+   * @param definition - The definition of the belongsTo relation.
+   */
+  belongsTo(
+    name: string,
+    definition: Omit<BelongsToDefinition, 'name' | 'type' | 'targetsMany'>,
+  ): this {
+    const meta: BelongsToDefinition = {
+      ...definition,
+      name,
+      type: RelationType.belongsTo,
+      targetsMany: false,
+    };
+    return this.addRelation(meta);
+  }
+
+  /**
+   * Define a new hasOne relation.
+   * @param name - The name of the hasOne relation.
+   * @param definition - The definition of the hasOne relation.
+   */
+  hasOne(
+    name: string,
+    definition: Omit<HasOneDefinition, 'name' | 'type' | 'targetsMany'>,
+  ): this {
+    const meta: HasOneDefinition = {
+      ...definition,
+      name,
+      type: RelationType.hasOne,
+      targetsMany: false,
+    };
+    return this.addRelation(meta);
+  }
+
+  /**
+   * Define a new hasMany relation.
+   * @param name - The name of the hasMany relation.
+   * @param definition - The definition of the hasMany relation.
+   */
+  hasMany(
+    name: string,
+    definition: Omit<HasManyDefinition, 'name' | 'type' | 'targetsMany'>,
+  ): this {
+    const meta: HasManyDefinition = {
+      ...definition,
+      name,
+      type: RelationType.hasMany,
+      targetsMany: true,
+    };
+    return this.addRelation(meta);
+  }
+
   /**
    * Get an array of names of ID properties, which are specified in
    * the model settings or properties with `id` attribute.
@@ -216,7 +276,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 +328,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.helpers.ts

@@ -4,6 +4,7 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import debugFactory from 'debug';
+import {camelCase} from 'lodash';
 import {InvalidRelationError} from '../../errors';
 import {isTypeResolver} from '../../type-resolver';
 import {BelongsToDefinition, RelationType} from '../relation.types';
@@ -14,7 +15,10 @@ const debug = debugFactory('loopback:repository:belongs-to-helpers');
  * Relation definition with optional metadata (e.g. `keyTo`) filled in.
  * @internal
  */
-export type BelongsToResolvedDefinition = BelongsToDefinition & {keyTo: string};
+export type BelongsToResolvedDefinition = BelongsToDefinition & {
+  keyFrom: string;
+  keyTo: string;
+};
 
 /**
  * Resolves given belongsTo metadata if target is specified to be a resolver.
@@ -34,11 +38,6 @@ export function resolveBelongsToMetadata(relationMeta: BelongsToDefinition) {
     throw new InvalidRelationError(reason, relationMeta);
   }
 
-  if (!relationMeta.keyFrom) {
-    const reason = 'keyFrom is required';
-    throw new InvalidRelationError(reason, relationMeta);
-  }
-
   const sourceModel = relationMeta.source;
   if (!sourceModel || !sourceModel.modelName) {
     const reason = 'source model must be defined';
@@ -49,12 +48,24 @@ export function resolveBelongsToMetadata(relationMeta: BelongsToDefinition) {
   const targetName = targetModel.modelName;
   debug('Resolved model %s from given metadata: %o', targetName, targetModel);
 
+  let keyFrom;
+  if (
+    relationMeta.keyFrom &&
+    relationMeta.source.definition.properties[relationMeta.keyFrom]
+  ) {
+    keyFrom = relationMeta.keyFrom;
+  } else {
+    keyFrom = camelCase(targetName + '_id');
+  }
+
   const targetProperties = targetModel.definition.properties;
   debug('relation metadata from %o: %o', targetName, targetProperties);
 
   if (relationMeta.keyTo && targetProperties[relationMeta.keyTo]) {
     // The explicit cast is needed because of a limitation of type inference
-    return relationMeta as BelongsToResolvedDefinition;
+    return Object.assign(relationMeta, {
+      keyFrom,
+    }) as BelongsToResolvedDefinition;
   }
 
   const targetPrimaryKey = targetModel.definition.idProperties()[0];
@@ -63,5 +74,5 @@ export function resolveBelongsToMetadata(relationMeta: BelongsToDefinition) {
     throw new InvalidRelationError(reason, relationMeta);
   }
 
-  return Object.assign(relationMeta, {keyTo: targetPrimaryKey});
+  return Object.assign(relationMeta, {keyFrom, keyTo: targetPrimaryKey});
 }

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,104 @@
+// 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,
+  getTargetIdsFromTargetModels,
+  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 getTargetIds(targetInstances: Target[]): TargetID[] {
+      return getTargetIdsFromTargetModels(meta, targetInstances);
+    }
+    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,
+      getTargetIds,
+      getThroughConstraintFromTarget,
+    );
+  };
+  return result;
+}