@loopback/sequelize 0.3.0 → 0.5.0

package/src/sequelize/sequelize.repository.base.ts

@@ -7,12 +7,8 @@ import {
   AnyObject,
   BelongsToAccessor,
   BelongsToDefinition,
+  Command,
   Count,
-  createBelongsToAccessor,
-  createHasManyRepositoryFactory,
-  createHasManyThroughRepositoryFactory,
-  createHasOneRepositoryFactory,
-  createReferencesManyAccessor,
   DataObject,
   Entity,
   EntityCrudRepository,
@@ -29,14 +25,22 @@ import {
   Inclusion,
   InclusionFilter,
   InclusionResolver,
+  RelationType as LoopbackRelationType,
+  NamedParameters,
+  Options,
   PositionalParameters,
   PropertyDefinition,
   ReferencesManyAccessor,
   ReferencesManyDefinition,
-  RelationType as LoopbackRelationType,
   Where,
+  createBelongsToAccessor,
+  createHasManyRepositoryFactory,
+  createHasManyThroughRepositoryFactory,
+  createHasOneRepositoryFactory,
+  createReferencesManyAccessor,
 } from '@loopback/repository';
 import debugFactory from 'debug';
+import {nanoid} from 'nanoid';
 import {
   Attributes,
   DataType,
@@ -110,6 +114,29 @@ export class SequelizeCrudRepository<
     'sqlite3',
   ] as const;
 
+  /**
+   * Length of the `nanoid` generated for defaultFn's `shortid` and `nanoid` aliases.
+   */
+  public NANO_ID_LENGTH = 9;
+
+  /**
+   * The alias registry for `defaultFn` option used in model property definition.
+   *
+   * See: https://loopback.io/doc/en/lb4/Model.html#property-decorator
+   */
+  protected defaultFnRegistry: Record<string, unknown> = {
+    guid: DataTypes.UUIDV1,
+    uuid: DataTypes.UUIDV1,
+    uuidv4: DataTypes.UUIDV4,
+    now: DataTypes.NOW,
+    shortid: () => nanoid(this.NANO_ID_LENGTH),
+    nanoid: () => nanoid(this.NANO_ID_LENGTH),
+  };
+
+  protected getDefaultFnRegistry() {
+    return this.defaultFnRegistry;
+  }
+
   public readonly inclusionResolvers: Map<
     string,
     InclusionResolver<T, Entity>
@@ -121,17 +148,11 @@ export class SequelizeCrudRepository<
   public sequelizeModel: ModelStatic<Model<T>>;
 
   async create(entity: DataObject<T>, options?: AnyObject): Promise<T> {
-    let err = null;
-    const data = await this.sequelizeModel
-      .create(entity as MakeNullishOptional<T>, options)
-      .catch(error => {
-        err = error;
-      });
-
-    if (!data) {
-      throw new Error(err ?? 'Something went wrong');
-    }
-    return new this.entityClass(this.excludeHiddenProps(data.toJSON())) as T;
+    const data = await this.sequelizeModel.create(
+      entity as MakeNullishOptional<T>,
+      options,
+    );
+    return new this.entityClass(data.toJSON()) as T;
   }
 
   async createAll(
@@ -213,20 +234,15 @@ export class SequelizeCrudRepository<
     filter?: Filter<T>,
     options?: AnyObject,
   ): Promise<(T & Relations)[]> {
-    const data = await this.sequelizeModel
-      .findAll({
-        include: this.buildSequelizeIncludeFilter(filter?.include),
-        where: this.buildSequelizeWhere(filter?.where),
-        attributes: this.buildSequelizeAttributeFilter(filter?.fields),
-        order: this.buildSequelizeOrder(filter?.order),
-        limit: filter?.limit,
-        offset: filter?.offset ?? filter?.skip,
-        ...options,
-      })
-      .catch(err => {
-        debug('findAll() error:', err);
-        throw new Error(err);
-      });
+    const data = await this.sequelizeModel.findAll({
+      include: this.buildSequelizeIncludeFilter(filter?.include),
+      where: this.buildSequelizeWhere(filter?.where),
+      attributes: this.buildSequelizeAttributeFilter(filter?.fields),
+      order: this.buildSequelizeOrder(filter?.order),
+      limit: filter?.limit,
+      offset: filter?.offset ?? filter?.skip,
+      ...options,
+    });
 
     return this.includeReferencesIfRequested(
       data,
@@ -239,19 +255,14 @@ export class SequelizeCrudRepository<
     filter?: Filter<T>,
     options?: AnyObject,
   ): Promise<(T & Relations) | null> {
-    const data = await this.sequelizeModel
-      .findOne({
-        include: this.buildSequelizeIncludeFilter(filter?.include),
-        where: this.buildSequelizeWhere(filter?.where),
-        attributes: this.buildSequelizeAttributeFilter(filter?.fields),
-        order: this.buildSequelizeOrder(filter?.order),
-        offset: filter?.offset ?? filter?.skip,
-        ...options,
-      })
-      .catch(err => {
-        debug('findOne() error:', err);
-        throw new Error(err);
-      });
+    const data = await this.sequelizeModel.findOne({
+      include: this.buildSequelizeIncludeFilter(filter?.include),
+      where: this.buildSequelizeWhere(filter?.where),
+      attributes: this.buildSequelizeAttributeFilter(filter?.fields),
+      order: this.buildSequelizeOrder(filter?.order),
+      offset: filter?.offset ?? filter?.skip,
+      ...options,
+    });
 
     if (data === null) {
       return Promise.resolve(null);
@@ -347,10 +358,41 @@ export class SequelizeCrudRepository<
     return {count};
   }
 
-  async execute(..._args: PositionalParameters): Promise<AnyObject> {
-    throw new Error(
-      'RAW Query execution is currently NOT supported for Sequelize CRUD Repository.',
-    );
+  /**
+   * Execute a SQL command.
+   *
+   * **WARNING:** In general, it is always better to perform database actions
+   * through repository methods. Directly executing SQL may lead to unexpected
+   * results, corrupted data, security vulnerabilities and other issues.
+   *
+   * @example
+   *
+   * ```ts
+   * // MySQL
+   * const result = await repo.execute(
+   *   'SELECT * FROM Products WHERE size > ?',
+   *   [42]
+   * );
+   *
+   * // PostgreSQL
+   * const result = await repo.execute(
+   *   'SELECT * FROM Products WHERE size > $1',
+   *   [42]
+   * );
+   * ```
+   *
+   * @param command A parameterized SQL command or query.
+   * @param parameters List of parameter values to use.
+   * @param options Additional options, for example `transaction`.
+   * @returns A promise which resolves to the command output. The output type (data structure) is database specific and
+   * often depends on the command executed.
+   */
+  async execute(
+    command: Command,
+    parameters?: NamedParameters | PositionalParameters,
+    options?: Options,
+  ): Promise<AnyObject> {
+    return this.dataSource.execute(command, parameters, options);
   }
 
   protected toEntities(models: Model<T, T>[]): T[] {
@@ -442,6 +484,22 @@ export class SequelizeCrudRepository<
     });
   }
 
+  /**
+   * Checks if the resolver of the inclusion relation is registered
+   * in the inclusionResolver of the current repository
+   *
+   * @param include - LoopBack Inclusion filter
+   */
+  protected isInclusionAllowed(include: InclusionFilter): boolean {
+    const relationName =
+      typeof include === 'string' ? include : include.relation;
+    if (!relationName) {
+      return false;
+    }
+    const allowed = this.inclusionResolvers.has(relationName);
+    return allowed;
+  }
+
   /**
    * Build Sequelize compatible `include` filter
    * @param inclusionFilters - loopback style `where` condition
@@ -460,6 +518,25 @@ export class SequelizeCrudRepository<
       sourceModel = this.sequelizeModel;
     }
 
+    if (sourceModel === this.sequelizeModel) {
+      const invalidInclusions = inclusionFilters.filter(
+        inclusionFilter => !this.isInclusionAllowed(inclusionFilter),
+      );
+      if (invalidInclusions.length) {
+        const msg =
+          'Invalid "filter.include" entries: ' +
+          invalidInclusions
+            .map(inclusionFilter => JSON.stringify(inclusionFilter))
+            .join('; ');
+        const err = new Error(msg);
+        Object.assign(err, {
+          code: 'INVALID_INCLUSION_FILTER',
+          statusCode: 400,
+        });
+        throw err;
+      }
+    }
+
     const includable: Includeable[] = [];
 
     for (const filter of inclusionFilters) {
@@ -603,7 +680,7 @@ export class SequelizeCrudRepository<
       this.getSequelizeModelAttributes(entityClass.definition.properties),
       {
         timestamps: false,
-        tableName: entityClass.modelName.toLowerCase(),
+        tableName: this.getTableName(entityClass),
         freezeTableName: true,
       },
     );
@@ -683,6 +760,32 @@ export class SequelizeCrudRepository<
     return sourceModel;
   }
 
+  /**
+   * This function retrieves the table name associated with a given entity class.
+   * Different loopback connectors have different conventions for picking up table names,
+   * unless the name is specified in the @model decorator.
+   *
+   * The function follows the following cases to determine the table name:
+   * - It checks if the name property is specified in the @model decorator and uses it. (this takes precedence over all other cases)
+   * - If the dialect of the dataSource is PostgreSQL, it uses the lowercased version of the model class name.
+   * - If the dialect is MySQL or any other dialect, it uses the default model class name.
+   * @param {Entity} entityClass - The entity class for which the table name is being retrieved.
+   * @returns {string} - The table name associated with the entity class. Which is used when performing the query.
+   */
+  getTableName(entityClass = this.entityClass) {
+    let tableName = entityClass.name; // model class name
+
+    if (entityClass.definition.name !== tableName) {
+      // name is specified in decorator
+      tableName = entityClass.definition.name;
+    } else if (this.dataSource.sequelizeConfig.dialect === 'postgres') {
+      // postgres is being used and name is not specified in @model decorator
+      tableName = entityClass.modelName.toLowerCase();
+    }
+
+    return tableName;
+  }
+
   /**
    * Run CREATE TABLE query for the target sequelize model, Useful for quick testing
    * @param options Sequelize Sync Options
@@ -793,11 +896,18 @@ export class SequelizeCrudRepository<
         );
       }
 
+      let defaultValue = definition[propName].default;
+      const originalDefaultFn = definition[propName]['defaultFn'];
+
+      if (typeof originalDefaultFn === 'function') {
+        defaultValue = originalDefaultFn;
+      } else if (originalDefaultFn in this.getDefaultFnRegistry()) {
+        defaultValue = this.getDefaultFnRegistry()[originalDefaultFn];
+      }
+
       const columnOptions: ModelAttributeColumnOptions = {
         type: dataType,
-        ...('default' in definition[propName]
-          ? {defaultValue: definition[propName].default}
-          : {}),
+        defaultValue,
       };
 
       // Set column as `primaryKey` when id is set to true (which is loopback way to define primary key)
@@ -829,6 +939,11 @@ export class SequelizeCrudRepository<
    * Remove hidden properties specified in model from response body. (See:  https://github.com/sourcefuse/loopback4-sequelize/issues/3)
    * @param entity normalized entity. You can use `entity.toJSON()`'s value
    * @returns normalized entity excluding the hiddenProperties
+   *
+   * @deprecated To exclude hidden props from an entity instance, call the `.toJSON()` method on it.
+   * Alternatively it can be use by manually instantiating the model using `new EntityClass(data).toJSON()`.
+   *
+   * This function will be removed in next major release.
    */
   protected excludeHiddenProps(entity: T & Relations): T & Relations {
     const hiddenProps = this.entityClass.definition.settings.hiddenProperties;
@@ -862,6 +977,9 @@ export class SequelizeCrudRepository<
     if (!parentEntityClass) {
       parentEntityClass = this.entityClass;
     }
+    let parentEntityInstances = parentEntities.map(
+      sequelizeModel => new this.entityClass(sequelizeModel.toJSON()) as T,
+    );
     /**
      * All columns names defined in model with `@referencesMany`
      */
@@ -882,8 +1000,8 @@ export class SequelizeCrudRepository<
 
     // Validate data type of items in any column having references
     // For eg. convert ["1", "2"] into [1, 2] if `itemType` specified is `number[]`
-    const normalizedParentEntities = parentEntities.map(entity => {
-      const data = entity.toJSON();
+    parentEntityInstances = parentEntityInstances.map(entity => {
+      const data = entity as AnyObject;
       for (const columnName in data) {
         if (!allReferencesColumns.includes(columnName)) {
           // Column is not the one used for referencesMany relation. Eg. "programmingLanguageIds"
@@ -915,7 +1033,7 @@ export class SequelizeCrudRepository<
         data[columnName] = items as unknown as T[Extract<keyof T, string>];
       }
 
-      return data;
+      return data as T;
     });
 
     // Requested inclusions of referencesMany relation
@@ -951,14 +1069,11 @@ export class SequelizeCrudRepository<
     }
 
     if (referencesManyInclusions.length === 0) {
-      const entityClasses = normalizedParentEntities.map(
-        e => new parentEntityClass(e),
-      );
-      return entityClasses as (T & Relations)[];
+      return parentEntityInstances as (T & Relations)[];
     }
 
     for (const relation of referencesManyInclusions) {
-      normalizedParentEntities.forEach(entity => {
+      parentEntityInstances.forEach(entity => {
         if (!relation.definition.keyFrom) {
           return;
         }
@@ -1038,7 +1153,7 @@ export class SequelizeCrudRepository<
         relation.filter.scope?.include,
       );
 
-      normalizedParentEntities.forEach(entity => {
+      parentEntityInstances.forEach(entity => {
         const foreignKeys = entity[relation.definition.keyFrom as keyof T];
         const filteredChildModels = childModelData.filter(childModel => {
           if (Array.isArray(foreignKeys)) {
@@ -1056,15 +1171,14 @@ export class SequelizeCrudRepository<
               if (includeForeignKeyInResponse === false) {
                 delete safeCopy[foreignKey as keyof typeof safeCopy];
               }
-              return safeCopy;
+              return new targetLoopbackModel(safeCopy);
             },
           ),
         });
-        return new parentEntityClass(entity) as T & Relations;
       });
     }
 
-    return normalizedParentEntities as (T & Relations)[];
+    return parentEntityInstances as (T & Relations)[];
   }
 
   /**