@loopback/repository 2.11.1 → 3.1.0

package/src/relations/has-many/has-many-through.inclusion.resolver.ts

@@ -0,0 +1,135 @@
+// 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 {Filter, Inclusion} from '@loopback/filter';
+import debugFactory from 'debug';
+import {AnyObject, Options} from '../../common-types';
+import {Entity} from '../../model';
+import {EntityCrudRepository} from '../../repositories/repository';
+import {
+  findByForeignKeys,
+  flattenTargetsOfOneToManyRelation,
+  StringKeyOf,
+} from '../relation.helpers';
+import {Getter, HasManyDefinition, InclusionResolver} from '../relation.types';
+import {resolveHasManyMetadata} from './has-many.helpers';
+
+const debug = debugFactory(
+  'loopback:repository:has-many-through-inclusion-resolver',
+);
+
+/**
+ * Creates InclusionResolver for HasManyThrough relation.
+ * Notice that this function only generates the inclusionResolver.
+ * It doesn't register it for the source repository.
+ *
+ *
+ * @param meta - metadata of the hasMany relation (including through)
+ * @param getThroughRepo - through repository getter i.e. where through
+ * instances are
+ * @param getTargetRepo - target repository getter i.e where target instances
+ * are
+ */
+export function createHasManyThroughInclusionResolver<
+  Through extends Entity,
+  ThroughID,
+  ThroughRelations extends object,
+  Target extends Entity,
+  TargetID,
+  TargetRelations extends object
+>(
+  meta: HasManyDefinition,
+  getThroughRepo: Getter<
+    EntityCrudRepository<Through, ThroughID, ThroughRelations>
+  >,
+  getTargetRepo: Getter<
+    EntityCrudRepository<Target, TargetID, TargetRelations>
+  >,
+): InclusionResolver<Entity, Target> {
+  const relationMeta = resolveHasManyMetadata(meta);
+
+  return async function fetchHasManyThroughModels(
+    entities: Entity[],
+    inclusion: Inclusion,
+    options?: Options,
+  ): Promise<((Target & TargetRelations)[] | undefined)[]> {
+    if (!entities.length) return [];
+
+    debug('Fetching target models for entities:', entities);
+    debug('Relation metadata:', relationMeta);
+
+    const sourceKey = relationMeta.keyFrom;
+    const sourceIds = entities.map(e => (e as AnyObject)[sourceKey]);
+    const targetKey = relationMeta.keyTo as StringKeyOf<Target>;
+    if (!relationMeta.through) {
+      throw new Error(
+        `relationMeta.through must be defined on ${relationMeta}`,
+      );
+    }
+    const throughKeyTo = relationMeta.through.keyTo as StringKeyOf<Through>;
+    const throughKeyFrom = relationMeta.through.keyFrom as StringKeyOf<Through>;
+
+    debug('Parameters:', {
+      sourceKey,
+      sourceIds,
+      targetKey,
+      throughKeyTo,
+      throughKeyFrom,
+    });
+
+    debug(
+      'sourceId types',
+      sourceIds.map(i => typeof i),
+    );
+
+    const throughRepo = await getThroughRepo();
+    const targetRepo = await getTargetRepo();
+
+    // find through models
+    const throughFound = await findByForeignKeys(
+      throughRepo,
+      throughKeyFrom,
+      sourceIds,
+      {}, // scope will be applied at the target level
+      options,
+    );
+
+    const throughResult = flattenTargetsOfOneToManyRelation(
+      sourceIds,
+      throughFound,
+      throughKeyFrom,
+    );
+
+    const result = [];
+
+    // convert from through entities to the target entities
+    for (const entityList of throughResult) {
+      if (entityList) {
+        // get target ids from the through entities by foreign key
+        const targetIds = entityList.map(entity => entity[throughKeyTo]);
+
+        // the explicit types and casts are needed
+        const targetEntityList = await findByForeignKeys<
+          Target,
+          TargetRelations,
+          StringKeyOf<Target>
+        >(
+          targetRepo,
+          targetKey,
+          (targetIds as unknown) as [],
+          inclusion.scope as Filter<Target>,
+          options,
+        );
+        result.push(targetEntityList);
+      } else {
+        // no entities found, add undefined to results
+        result.push(entityList);
+      }
+    }
+
+    debug('fetchHasManyThroughModels result', result);
+    return result;
+  };
+}

package/src/relations/has-many/has-many.inclusion-resolver.ts

@@ -3,10 +3,10 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
+import {Filter, Inclusion} from '@loopback/filter';
 import debugFactory from 'debug';
 import {AnyObject, Options} from '../../common-types';
 import {Entity} from '../../model';
-import {Filter, Inclusion} from '../../query';
 import {EntityCrudRepository} from '../../repositories/repository';
 import {
   findByForeignKeys,

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

@@ -4,9 +4,9 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {Getter} from '@loopback/core';
+import {Filter, Where} from '@loopback/filter';
 import {Count, DataObject, Options} from '../../common-types';
 import {Entity} from '../../model';
-import {Filter, Where} from '../../query';
 import {
   constrainDataObject,
   constrainFilter,

package/src/relations/has-one/has-one.inclusion-resolver.ts

@@ -3,9 +3,9 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
+import {Filter, Inclusion} from '@loopback/filter';
 import {AnyObject, Options} from '../../common-types';
 import {Entity} from '../../model';
-import {Filter, Inclusion} from '../../query';
 import {EntityCrudRepository} from '../../repositories/repository';
 import {
   findByForeignKeys,

package/src/relations/has-one/has-one.repository.ts

@@ -4,10 +4,10 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {Getter} from '@loopback/core';
+import {Filter} from '@loopback/filter';
 import {Count, DataObject, Options} from '../../common-types';
 import {EntityNotFoundError} from '../../errors';
 import {Entity} from '../../model';
-import {Filter} from '../../query';
 import {
   constrainDataObject,
   constrainFilter,

package/src/relations/relation.helpers.ts

@@ -24,7 +24,7 @@ const debug = debugFactory('loopback:repository:relation-helpers');
  * @param targetRepository - The target repository where the related model instances are found
  * @param fkName - Name of the foreign key
  * @param fkValues - One value or array of values of the foreign key to be included
- * @param scope - Additional scope constraints (not currently supported)
+ * @param scope - Additional scope constraints
  * @param options - Options for the operations
  */
 export async function findByForeignKeys<
@@ -151,10 +151,7 @@ function isInclusionAllowed<T extends Entity, Relations extends object = {}>(
  * @param targetKey - name of the target key
  *
  */
-export function flattenTargetsOfOneToOneRelation<
-  SourceWithRelations extends Entity,
-  Target extends Entity
->(
+export function flattenTargetsOfOneToOneRelation<Target extends Entity>(
   sourceIds: unknown[],
   targetEntities: Target[],
   targetKey: StringKeyOf<Target>,

package/src/relations/relation.types.ts

@@ -3,9 +3,9 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
+import {Inclusion} from '@loopback/filter';
 import {Options} from '../common-types';
 import {Entity} from '../model';
-import {Inclusion} from '../query';
 import {TypeResolver} from '../type-resolver';
 
 export enum RelationType {

package/src/repositories/constraint-utils.ts

@@ -3,10 +3,10 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
+import {Filter, FilterBuilder, Where, WhereBuilder} from '@loopback/filter';
 import {cloneDeep} from 'lodash';
 import {AnyObject, DataObject} from '../common-types';
 import {Entity} from '../model';
-import {Filter, FilterBuilder, Where, WhereBuilder} from '../query';
 
 /**
  * A utility function which takes a filter and enforces constraint(s)

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

@@ -4,6 +4,7 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {Getter} from '@loopback/core';
+import {Filter, FilterExcludingWhere, Inclusion, Where} from '@loopback/filter';
 import assert from 'assert';
 import legacy from 'loopback-datasource-juggler';
 import {
@@ -23,7 +24,6 @@ import {
   PropertyType,
   rejectNavigationalPropertiesInData,
 } from '../model';
-import {Filter, FilterExcludingWhere, Inclusion, Where} from '../query';
 import {
   BelongsToAccessor,
   BelongsToDefinition,
@@ -54,9 +54,9 @@ export namespace juggler {
   export import PersistedModel = legacy.PersistedModel;
   export import KeyValueModel = legacy.KeyValueModel;
   export import PersistedModelClass = legacy.PersistedModelClass;
-  // eslint-disable-next-line no-shadow
+  // eslint-disable-next-line @typescript-eslint/no-shadow
   export import Transaction = legacy.Transaction;
-  // eslint-disable-next-line no-shadow
+  // eslint-disable-next-line @typescript-eslint/no-shadow
   export import IsolationLevel = legacy.IsolationLevel;
 }
 
@@ -763,10 +763,11 @@ export class DefaultCrudRepository<
  */
 
 export class DefaultTransactionalRepository<
-  T extends Entity,
-  ID,
-  Relations extends object = {}
-> extends DefaultCrudRepository<T, ID, Relations>
+    T extends Entity,
+    ID,
+    Relations extends object = {}
+  >
+  extends DefaultCrudRepository<T, ID, Relations>
   implements TransactionalEntityRepository<T, ID, Relations> {
   async beginTransaction(
     options?: IsolationLevel | Options,

package/src/repositories/repository.ts

@@ -3,6 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
+import {Filter, FilterExcludingWhere, Where} from '@loopback/filter';
 import {
   AnyObject,
   Command,
@@ -16,7 +17,6 @@ import {CrudConnector} from '../connectors';
 import {DataSource} from '../datasource';
 import {EntityNotFoundError} from '../errors';
 import {Entity, Model, ValueObject} from '../model';
-import {Filter, FilterExcludingWhere, Where} from '../query';
 import {InclusionResolver} from '../relations/relation.types';
 import {IsolationLevel, Transaction} from '../transaction';
 
@@ -138,7 +138,8 @@ export interface EntityCrudRepository<
   T extends Entity,
   ID,
   Relations extends object = {}
-> extends EntityRepository<T, ID>, CrudRepository<T, Relations> {
+> 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>>;

package/dist/query.d.ts

@@ -1,382 +0,0 @@
-import { AnyObject } from './common-types';
-/**
- * Operators for where clauses
- */
-export declare type Operators = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'inq' | 'nin' | 'between' | 'exists' | 'and' | 'or' | 'like' | 'nlike' | 'ilike' | 'nilike' | 'regexp';
-/**
- * Matching predicate comparison
- */
-export declare type PredicateComparison<PT> = {
-    eq?: PT;
-    neq?: PT;
-    gt?: PT;
-    gte?: PT;
-    lt?: PT;
-    lte?: PT;
-    inq?: PT[];
-    nin?: PT[];
-    between?: [PT, PT];
-    exists?: boolean;
-    like?: PT;
-    nlike?: PT;
-    ilike?: PT;
-    nilike?: PT;
-    regexp?: string | RegExp;
-};
-/**
- * Value types for `{propertyName: value}`
- */
-export declare type ShortHandEqualType = string | number | boolean | Date;
-/**
- * Key types of a given model, excluding operators
- */
-export declare type KeyOf<MT extends object> = Exclude<Extract<keyof MT, string>, Operators>;
-/**
- * Condition clause
- *
- * @example
- * ```ts
- * {
- *   name: {inq: ['John', 'Mary']},
- *   status: 'ACTIVE',
- *   age: {gte: 40}
- * }
- * ```
- */
-export declare type Condition<MT extends object> = {
-    [P in KeyOf<MT>]?: PredicateComparison<MT[P]> | (MT[P] & ShortHandEqualType);
-};
-/**
- * Where clause
- *
- * @example
- * ```ts
- * {
- *   name: {inq: ['John', 'Mary']},
- *   status: 'ACTIVE'
- *   and: [...],
- *   or: [...],
- * }
- * ```
- */
-export declare type Where<MT extends object = AnyObject> = Condition<MT> | AndClause<MT> | OrClause<MT>;
-/**
- * And clause
- *
- * @example
- * ```ts
- * {
- *   and: [...],
- * }
- * ```
- */
-export interface AndClause<MT extends object> {
-    and: Where<MT>[];
-}
-/**
- * Or clause
- *
- * @example
- * ```ts
- * {
- *   or: [...],
- * }
- * ```
- */
-export interface OrClause<MT extends object> {
-    or: Where<MT>[];
-}
-/**
- * Order by direction
- */
-export declare type Direction = 'ASC' | 'DESC';
-/**
- * Order by
- *
- * Example:
- * `{afieldname: 'ASC'}`
- */
-export declare type Order<MT = AnyObject> = {
-    [P in keyof MT]: Direction;
-};
-/**
- * Selection of fields
- *
- * Example:
- * `{afieldname: true}`
- */
-export declare type Fields<MT = AnyObject> = {
-    [P in keyof MT]?: boolean;
-};
-/**
- * Inclusion of related items
- *
- * Note: scope means filter on related items
- *
- * Example:
- * `{relation: 'aRelationName', scope: {<AFilterObject>}}`
- */
-export interface Inclusion {
-    relation: string;
-    scope?: Filter<AnyObject>;
-}
-/**
- * Query filter object
- */
-export interface Filter<MT extends object = AnyObject> {
-    /**
-     * The matching criteria
-     */
-    where?: Where<MT>;
-    /**
-     * To include/exclude fields
-     */
-    fields?: Fields<MT>;
-    /**
-     * Sorting order for matched entities. Each item should be formatted as
-     * `fieldName ASC` or `fieldName DESC`.
-     * For example: `['f1 ASC', 'f2 DESC', 'f3 ASC']`.
-     *
-     * We might want to use `Order` in the future. Keep it as `string[]` for now
-     * for compatibility with LoopBack 3.x.
-     */
-    order?: string[];
-    /**
-     * Maximum number of entities
-     */
-    limit?: number;
-    /**
-     * Skip N number of entities
-     */
-    skip?: number;
-    /**
-     * Offset N number of entities. An alias for `skip`
-     */
-    offset?: number;
-    /**
-     * To include related objects
-     */
-    include?: Inclusion[];
-}
-/**
- * Filter without `where` property
- */
-export declare type FilterExcludingWhere<MT extends object = AnyObject> = Omit<Filter<MT>, 'where'>;
-/**
- * TypeGuard for Filter
- * @param candidate
- */
-export declare function isFilter<MT extends object>(candidate: any): candidate is Filter<MT>;
-/**
- * A builder for Where object. It provides fluent APIs to add clauses such as
- * `and`, `or`, and other operators.
- *
- * @example
- * ```ts
- * const whereBuilder = new WhereBuilder();
- * const where = whereBuilder
- *   .eq('a', 1)
- *   .and({x: 'x'}, {y: {gt: 1}})
- *   .and({b: 'b'}, {c: {lt: 1}})
- *   .or({d: 'd'}, {e: {neq: 1}})
- *   .build();
- * ```
- */
-export declare class WhereBuilder<MT extends object = AnyObject> {
-    where: Where<MT>;
-    constructor(w?: Where<MT>);
-    private add;
-    /**
-     * @deprecated
-     * Starting from TypeScript 3.2, we don't have to cast any more. This method
-     * should be considered as `deprecated`.
-     *
-     * Cast an `and`, `or`, or condition clause to Where
-     * @param clause - And/Or/Condition clause
-     */
-    cast(clause: AndClause<MT> | OrClause<MT> | Condition<MT>): Where<MT>;
-    /**
-     * Add an `and` clause.
-     * @param w - One or more where objects
-     */
-    and(...w: (Where<MT> | Where<MT>[])[]): this;
-    /**
-     * Add an `or` clause.
-     * @param w - One or more where objects
-     */
-    or(...w: (Where<MT> | Where<MT>[])[]): this;
-    /**
-     * Add an `=` condition
-     * @param key - Property name
-     * @param val - Property value
-     */
-    eq<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `!=` condition
-     * @param key - Property name
-     * @param val - Property value
-     */
-    neq<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `>` condition
-     * @param key - Property name
-     * @param val - Property value
-     */
-    gt<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `>=` condition
-     * @param key - Property name
-     * @param val - Property value
-     */
-    gte<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `<` condition
-     * @param key - Property name
-     * @param val - Property value
-     */
-    lt<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `<=` condition
-     * @param key - Property name
-     * @param val - Property value
-     */
-    lte<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `inq` condition
-     * @param key - Property name
-     * @param val - An array of property values
-     */
-    inq<K extends KeyOf<MT>>(key: K, val: MT[K][]): this;
-    /**
-     * Add a `nin` condition
-     * @param key - Property name
-     * @param val - An array of property values
-     */
-    nin<K extends KeyOf<MT>>(key: K, val: MT[K][]): this;
-    /**
-     * Add a `between` condition
-     * @param key - Property name
-     * @param val1 - Property value lower bound
-     * @param val2 - Property value upper bound
-     */
-    between<K extends KeyOf<MT>>(key: K, val1: MT[K], val2: MT[K]): this;
-    /**
-     * Add a `exists` condition
-     * @param key - Property name
-     * @param val - Exists or not
-     */
-    exists<K extends KeyOf<MT>>(key: K, val?: boolean): this;
-    /**
-     * Add a where object. For conflicting keys with the existing where object,
-     * create an `and` clause.
-     * @param where - Where filter
-     */
-    impose(where: Where<MT>): this;
-    /**
-     * Add a `like` condition
-     * @param key - Property name
-     * @param val - Regexp condition
-     */
-    like<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `nlike` condition
-     * @param key - Property name
-     * @param val - Regexp condition
-     */
-    nlike<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `ilike` condition
-     * @param key - Property name
-     * @param val - Regexp condition
-     */
-    ilike<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `nilike` condition
-     * @param key - Property name
-     * @param val - Regexp condition
-     */
-    nilike<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    /**
-     * Add a `regexp` condition
-     * @param key - Property name
-     * @param val - Regexp condition
-     */
-    regexp<K extends KeyOf<MT>>(key: K, val: string | RegExp): this;
-    /**
-     * Get the where object
-     */
-    build(): Where<MT>;
-}
-/**
- * A builder for Filter. It provides fleunt APIs to add clauses such as
- * `fields`, `order`, `where`, `limit`, `offset`, and `include`.
- *
- * @example
- * ```ts
- * const filterBuilder = new FilterBuilder();
- * const filter = filterBuilder
- *   .fields('id', a', 'b')
- *   .limit(10)
- *   .offset(0)
- *   .order(['a ASC', 'b DESC'])
- *   .where({id: 1})
- *   .build();
- * ```
- */
-export declare class FilterBuilder<MT extends object = AnyObject> {
-    filter: Filter<MT>;
-    constructor(f?: Filter<MT>);
-    /**
-     * Set `limit`
-     * @param limit - Maximum number of records to be returned
-     */
-    limit(limit: number): this;
-    /**
-     * Set `offset`
-     * @param offset - Offset of the number of records to be returned
-     */
-    offset(offset: number): this;
-    /**
-     * Alias to `offset`
-     * @param skip
-     */
-    skip(skip: number): this;
-    /**
-     * Describe what fields to be included/excluded
-     * @param f - A field name to be included, an array of field names to be
-     * included, or an Fields object for the inclusion/exclusion
-     */
-    fields(...f: (Fields<MT> | (keyof MT)[] | keyof MT)[]): this;
-    private validateOrder;
-    /**
-     * Describe the sorting order
-     * @param o - A field name with optional direction, an array of field names,
-     * or an Order object for the field/direction pairs
-     */
-    order(...o: (string | string[] | Order<MT>)[]): this;
-    /**
-     * Declare `include`
-     * @param i - A relation name, an array of relation names, or an `Inclusion`
-     * object for the relation/scope definitions
-     */
-    include(...i: (string | string[] | Inclusion)[]): this;
-    /**
-     * Declare a where clause
-     * @param w - Where object
-     */
-    where(w: Where<MT>): this;
-    /**
-     * Add a Filter or Where constraint object. If it is a filter object, create
-     * an `and` clause for conflicting keys with its where object. For any other
-     * properties, throw an error. If it's not a Filter, coerce it to a filter,
-     * and carry out the same logic.
-     *
-     * @param constraint - a constraint object to merge with own filter object
-     */
-    impose(constraint: Filter<MT> | Where<MT>): this;
-    /**
-     * Return the filter object
-     */
-    build(): Filter<MT>;
-}
-export declare function filterTemplate(strings: TemplateStringsArray, ...keys: any[]): (ctx: AnyObject) => any;