@e22m4u/js-repository 0.1.13 → 0.1.15

package/.eslintignore

@@ -1,2 +1 @@
 *.d.ts
-docs

package/.husky/pre-commit

@@ -1,7 +1,5 @@
 npm run lint:fix
 npm run format
-
 npm run test
-npm run build:doc
 
 git add -A

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 e22m4u@gmail.com
+Copyright (c) 2023 e22m4u@yandex.ru
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -11,7 +11,7 @@
 - [Свойства](#Свойства)
 - [Валидаторы](#Валидаторы)
 - [Трансформеры](#Трансформеры)
-- [Пустое значение](#Пустое-значение)
+- [Пустые значения](#Пустые-значения)
 - [Репозиторий](#Репозиторий)
 - [Фильтрация](#Фильтрация)
 - [Связи](#Связи)
@@ -35,13 +35,55 @@ npm install @e22m4u/js-repository
 
 ## Описание
 
-Модуль позволяет объединить несколько баз данных в единую абстракцию «Схема».
+Модуль позволяет абстрагироваться от различных интерфейсов баз данных,
+представляя их как именованные *источники данных*, подключаемые к *моделям*.
+*Модель* же описывает таблицу базы, колонки которой являются свойствами
+модели. Свойства модели могут иметь определенный *тип* допустимого значения,
+набор *валидаторов* и *трансформеров*, через которые проходят данные перед
+записью в базу. Кроме того, *модель* может определять классические связи
+«один к одному», «один ко многим» и другие типы отношений между моделями.
+
+Непосредственно чтение и запись данных производится с помощью *репозитория*,
+который имеет каждая модель с объявленным *источником данных*. Репозиторий
+может фильтровать запрашиваемые документы, выполнять валидацию свойств
+согласно определению модели, и встраивать связанные данные в результат
+выборки.
 
 - *Источник данных* - определяет способ подключения к базе
 - *Модель* - описывает структуру документа и связи к другим моделям
 - *Репозиторий* - выполняет операции чтения и записи документов модели
 
-<img alt="Схема" src="https://gitflic.ru/project/e22m4u/js-repository/blob/raw?file=assets%2Fmermaid-diagram.png&commit=39e53768b4ea62cafe60522e14d1fa9ddd42ebd5">
+```mermaid
+flowchart TD
+
+  A[Схема]
+  subgraph Базы данных
+    B[Источник данных 1]
+    C[Источник данных 2]
+  end
+  A-->B
+  A-->C
+
+  subgraph Коллекции
+    D[Модель A]
+    E[Модель Б]
+    F[Модель В]
+    G[Модель Г]
+  end
+  B-->D
+  B-->E
+  C-->F
+  C-->G
+
+  H[Репозиторий A]
+  I[Репозиторий Б]
+  J[Репозиторий В]
+  K[Репозиторий Г]
+  D-->H
+  E-->I
+  F-->J
+  G-->K
+```
 
 ## Пример
 
@@ -70,7 +112,7 @@ schema.defineModel({
   },
 })
 
-// получение репозитория для модели "country"
+// получение репозитория модели "country"
 const countryRep = schema.getRepository('country');
 
 // добавление нового документа в коллекцию "country"
@@ -79,7 +121,7 @@ const country = await countryRep.create({
   population: 143400000,
 });
 
-// вывод результата
+// вывод нового документа
 console.log(country);
 // {
 //   "id": 1,
@@ -230,17 +272,17 @@ schema.defineModel({
 **unique**
 
 Если значением параметра `unique` является `true` или `'strict'`, то выполняется
-строгая проверка на уникальность. В этом режиме [пустые значения](#Пустое-значение)
+строгая проверка на уникальность. В этом режиме [пустые значения](#Пустые-значения)
 так же подлежат проверке, где `null` и `undefined` не могут повторяться более одного
 раза.
 
 Режим `'sparse'` проверяет только значения с полезной нагрузкой, исключая
-[пустые значения](#Пустое-значение), список которых отличается в зависимости
+[пустые значения](#Пустые-значения), список которых отличается в зависимости
 от типа свойства. Например, для типа `string` пустым значением будет `undefined`,
 `null` и `''` (пустая строка).
 
 - `unique: true | 'strict'` строгая проверка на уникальность
-- `unique: 'sparse'` исключить из проверки [пустые значения](#Пустое-значение)
+- `unique: 'sparse'` исключить из проверки [пустые значения](#Пустые-значения)
 - `unique: false | 'nonUnique'` не проверять на уникальность (по умолчанию)
 
 **Примеры**
@@ -303,7 +345,7 @@ schema.defineModel({
 
 Кроме проверки типа, дополнительные условия можно задать с помощью
 валидаторов, через которые будет проходить значение свойства перед
-записью в базу. Исключением являются [пустые значения](#Пустое-значение),
+записью в базу. Исключением являются [пустые значения](#Пустые-значения),
 которые не подлежат проверке.
 
 - `minLength: number` минимальная длинна строки или массива
@@ -335,7 +377,7 @@ schema.defineModel({
 С помощью трансформеров производится модификация значений определенных
 полей перед записью в базу. Трансформеры позволяют указать какие изменения
 нужно производить с входящими данными. Исключением являются
-[пустые значения](#Пустое-значение), которые не подлежат трансформации.
+[пустые значения](#Пустые-значения), которые не подлежат трансформации.
 
 - `trim` удаление пробельных символов с начала и конца строки
 - `toUpperCase` перевод строки в верхний регистр
@@ -365,7 +407,7 @@ schema.defineModel({
 });
 ```
 
-## Пустое значение
+## Пустые значения
 
 Разные типы свойств имеют свои наборы пустых значений. Эти наборы
 используются для определения наличия полезной нагрузки в значении

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Модуль для работы с базами данных для Node.js",
   "type": "module",
   "main": "src/index.js",
@@ -13,12 +13,11 @@
     "format": "prettier --write \"./src/**/*.js\"",
     "test": "npm run lint && c8 --reporter=text-summary mocha",
     "test:coverage": "npm run lint && c8 --reporter=text mocha",
-    "build:doc": "tsc && npx typedoc",
     "prepare": "husky"
   },
   "repository": {
     "type": "git",
-    "url": "https://gitflic.ru/project/e22m4u/js-repository.git"
+    "url": "https://github.com/e22m4u/js-repository.git"
   },
   "keywords": [
     "Repository",
@@ -30,34 +29,34 @@
   ],
   "author": "e22m4u <e22m4u@yandex.ru>",
   "license": "MIT",
-  "homepage": "https://gitflic.ru/project/e22m4u/js-repository",
+  "homepage": "https://github.com/e22m4u/js-repository",
   "dependencies": {
     "@e22m4u/js-format": "0.0.9",
     "@e22m4u/js-service": "0.0.8"
   },
   "devDependencies": {
-    "@commitlint/cli": "^18.6.1",
-    "@commitlint/config-conventional": "^18.6.2",
-    "@types/chai": "^4.3.11",
-    "@types/chai-as-promised": "^7.1.8",
-    "@types/mocha": "^10.0.6",
-    "@typescript-eslint/eslint-plugin": "^7.0.2",
-    "@typescript-eslint/parser": "^7.0.2",
-    "c8": "^9.1.0",
-    "chai": "^4.4.1",
-    "chai-as-promised": "^7.1.1",
-    "chai-spies": "^1.1.0",
-    "chai-subset": "^1.6.0",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-chai-expect": "^3.0.0",
-    "eslint-plugin-jsdoc": "^48.1.0",
-    "eslint-plugin-mocha": "^10.3.0",
-    "husky": "^9.0.11",
-    "mocha": "^10.3.0",
-    "prettier": "^3.2.5",
-    "ts-node": "^10.9.2",
-    "typedoc": "^0.25.8",
-    "typescript": "^5.3.3"
+    "@commitlint/cli": "~19.2.0",
+    "@commitlint/config-conventional": "~19.1.0",
+    "@types/chai": "~4.3.12",
+    "@types/chai-as-promised": "~7.1.8",
+    "@types/chai-spies": "~1.0.6",
+    "@types/mocha": "~10.0.6",
+    "@typescript-eslint/eslint-plugin": "~7.2.0",
+    "@typescript-eslint/parser": "~7.2.0",
+    "c8": "~9.1.0",
+    "chai": "~4.4.1",
+    "chai-as-promised": "~7.1.1",
+    "chai-spies": "~1.1.0",
+    "chai-subset": "~1.6.0",
+    "eslint": "~8.57.0",
+    "eslint-config-prettier": "~9.1.0",
+    "eslint-plugin-chai-expect": "~3.0.0",
+    "eslint-plugin-jsdoc": "~48.2.1",
+    "eslint-plugin-mocha": "~10.4.1",
+    "husky": "~9.0.11",
+    "mocha": "~10.3.0",
+    "prettier": "~3.2.5",
+    "ts-node": "~10.9.2",
+    "typescript": "~5.4.2"
   }
 }

package/src/adapter/decorator/data-transformation-decorator.js

@@ -22,32 +22,32 @@ export class DataTransformationDecorator extends Service {
     const transformer = this.getService(ModelDataTransformer);
 
     const create = adapter.create;
-    adapter.create = function (modelName, modelData, filter) {
-      modelData = transformer.transform(modelName, modelData);
+    adapter.create = async function (modelName, modelData, filter) {
+      modelData = await transformer.transform(modelName, modelData);
       return create.call(this, modelName, modelData, filter);
     };
 
     const replaceById = adapter.replaceById;
-    adapter.replaceById = function (modelName, id, modelData, filter) {
-      modelData = transformer.transform(modelName, modelData);
+    adapter.replaceById = async function (modelName, id, modelData, filter) {
+      modelData = await transformer.transform(modelName, modelData);
       return replaceById.call(this, modelName, id, modelData, filter);
     };
 
     const replaceOrCreate = adapter.replaceOrCreate;
-    adapter.replaceOrCreate = function (modelName, modelData, filter) {
-      modelData = transformer.transform(modelName, modelData);
+    adapter.replaceOrCreate = async function (modelName, modelData, filter) {
+      modelData = await transformer.transform(modelName, modelData);
       return replaceOrCreate.call(this, modelName, modelData, filter);
     };
 
     const patch = adapter.patch;
-    adapter.patch = function (modelName, modelData, where) {
-      modelData = transformer.transform(modelName, modelData, true);
+    adapter.patch = async function (modelName, modelData, where) {
+      modelData = await transformer.transform(modelName, modelData, true);
       return patch.call(this, modelName, modelData, where);
     };
 
     const patchById = adapter.patchById;
-    adapter.patchById = function (modelName, id, modelData, filter) {
-      modelData = transformer.transform(modelName, modelData, true);
+    adapter.patchById = async function (modelName, id, modelData, filter) {
+      modelData = await transformer.transform(modelName, modelData, true);
       return patchById.call(this, modelName, id, modelData, filter);
     };
   }

package/src/adapter/decorator/data-transformation-decorator.spec.js

@@ -4,38 +4,52 @@ import {Adapter} from '../adapter.js';
 import {Schema} from '../../schema.js';
 import {ModelDataTransformer} from '../../definition/index.js';
 
-const S = new Schema();
-S.defineModel({name: 'model'});
+const MODEL_NAME = 'myModel';
+const MODEL_DATA = {kind: 'modelData'};
+const TRANSFORMED_DATA = {kind: 'transformedData'};
+const WHERE_CLAUSE = {kind: {existed: true}};
+const FILTER_CLAUSE = {where: WHERE_CLAUSE};
+const DUMMY_ID = 1;
 
 class TestAdapter extends Adapter {
-  // eslint-disable-next-line no-unused-vars
   create(modelName, modelData, filter = undefined) {
+    expect(modelName).to.be.eq(MODEL_NAME);
+    expect(modelData).to.be.eql(TRANSFORMED_DATA);
+    expect(filter).to.be.eql(FILTER_CLAUSE);
     return Promise.resolve(modelData);
   }
-
-  // eslint-disable-next-line no-unused-vars
   replaceById(modelName, id, modelData, filter = undefined) {
+    expect(modelName).to.be.eq(MODEL_NAME);
+    expect(id).to.be.eq(DUMMY_ID);
+    expect(modelData).to.be.eql(TRANSFORMED_DATA);
+    expect(filter).to.be.eql(FILTER_CLAUSE);
     return Promise.resolve(modelData);
   }
-
-  // eslint-disable-next-line no-unused-vars
   replaceOrCreate(modelName, modelData, filter = undefined) {
+    expect(modelName).to.be.eq(MODEL_NAME);
+    expect(modelData).to.be.eql(TRANSFORMED_DATA);
+    expect(filter).to.be.eql(FILTER_CLAUSE);
     return Promise.resolve(modelData);
   }
-
-  // eslint-disable-next-line no-unused-vars
   patch(modelName, modelData, where = undefined) {
+    expect(modelName).to.be.eq(MODEL_NAME);
+    expect(modelData).to.be.eql(TRANSFORMED_DATA);
+    expect(where).to.be.eql(WHERE_CLAUSE);
     return Promise.resolve(modelData);
   }
-
-  // eslint-disable-next-line no-unused-vars
   patchById(modelName, id, modelData, filter = undefined) {
+    expect(modelName).to.be.eq(MODEL_NAME);
+    expect(id).to.be.eq(DUMMY_ID);
+    expect(modelData).to.be.eql(TRANSFORMED_DATA);
+    expect(filter).to.be.eql(FILTER_CLAUSE);
     return Promise.resolve(modelData);
   }
 }
 
+const S = new Schema();
+S.defineModel({name: MODEL_NAME});
 const A = S.getService(TestAdapter);
-const V = S.getService(ModelDataTransformer);
+const T = S.getService(ModelDataTransformer);
 const sandbox = chai.spy.sandbox();
 
 describe('DataTransformationDecorator', function () {
@@ -43,53 +57,137 @@ describe('DataTransformationDecorator', function () {
     sandbox.restore();
   });
 
-  it('overrides the "create" method and transforms a given data', async function () {
-    const modelData = {kind: 'modelData'};
-    const transformedData = {kind: 'transformedData'};
-    sandbox.on(V, 'transform', () => transformedData);
-    const res = await A.create('model', modelData);
-    expect(res).to.be.eql(transformedData);
-    expect(V.transform).to.be.called.once;
-    expect(V.transform).to.be.called.with.exactly('model', modelData);
+  describe('overrides the "create" method', function () {
+    it('transforms the given data', async function () {
+      sandbox.on(T, 'transform', () => TRANSFORMED_DATA);
+      const res = await A.create(MODEL_NAME, MODEL_DATA, FILTER_CLAUSE);
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(MODEL_NAME, MODEL_DATA);
+    });
+
+    it('resolves the transformation promise', async function () {
+      sandbox.on(T, 'transform', () => Promise.resolve(TRANSFORMED_DATA));
+      const res = await A.create(MODEL_NAME, MODEL_DATA, FILTER_CLAUSE);
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(MODEL_NAME, MODEL_DATA);
+    });
   });
 
-  it('overrides the "replaceById" method and transforms a given data', async function () {
-    const modelData = {kind: 'modelData'};
-    const transformedData = {kind: 'transformedData'};
-    sandbox.on(V, 'transform', () => transformedData);
-    const res = await A.replaceById('model', 1, modelData);
-    expect(res).to.be.eql(transformedData);
-    expect(V.transform).to.be.called.once;
-    expect(V.transform).to.be.called.with.exactly('model', modelData);
+  describe('overrides the "replaceById" method', function () {
+    it('transforms the given data', async function () {
+      sandbox.on(T, 'transform', () => TRANSFORMED_DATA);
+      const res = await A.replaceById(
+        MODEL_NAME,
+        DUMMY_ID,
+        MODEL_DATA,
+        FILTER_CLAUSE,
+      );
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(MODEL_NAME, MODEL_DATA);
+    });
+
+    it('resolves the transformation promise', async function () {
+      sandbox.on(T, 'transform', () => Promise.resolve(TRANSFORMED_DATA));
+      const res = await A.replaceById(
+        MODEL_NAME,
+        DUMMY_ID,
+        MODEL_DATA,
+        FILTER_CLAUSE,
+      );
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(MODEL_NAME, MODEL_DATA);
+    });
   });
 
-  it('overrides the "replaceOrCreate" method and transforms a given data', async function () {
-    const modelData = {kind: 'modelData'};
-    const transformedData = {kind: 'transformedData'};
-    sandbox.on(V, 'transform', () => transformedData);
-    const res = await A.replaceOrCreate('model', modelData);
-    expect(res).to.be.eql(transformedData);
-    expect(V.transform).to.be.called.once;
-    expect(V.transform).to.be.called.with.exactly('model', modelData);
+  describe('overrides the "replaceOrCreate" method', function () {
+    it('transforms the given data', async function () {
+      sandbox.on(T, 'transform', () => TRANSFORMED_DATA);
+      const res = await A.replaceOrCreate(
+        MODEL_NAME,
+        MODEL_DATA,
+        FILTER_CLAUSE,
+      );
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(MODEL_NAME, MODEL_DATA);
+    });
+
+    it('resolves the transformation promise', async function () {
+      sandbox.on(T, 'transform', () => Promise.resolve(TRANSFORMED_DATA));
+      const res = await A.replaceOrCreate(
+        MODEL_NAME,
+        MODEL_DATA,
+        FILTER_CLAUSE,
+      );
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(MODEL_NAME, MODEL_DATA);
+    });
   });
 
-  it('overrides the "patch" method and transforms a given data', async function () {
-    const modelData = {kind: 'modelData'};
-    const transformedData = {kind: 'transformedData'};
-    sandbox.on(V, 'transform', () => transformedData);
-    const res = await A.patch('model', modelData);
-    expect(res).to.be.eql(transformedData);
-    expect(V.transform).to.be.called.once;
-    expect(V.transform).to.be.called.with.exactly('model', modelData, true);
+  describe('overrides the "patch" method', function () {
+    it('transforms the given data', async function () {
+      sandbox.on(T, 'transform', () => TRANSFORMED_DATA);
+      const res = await A.patch(MODEL_NAME, MODEL_DATA, WHERE_CLAUSE);
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(
+        MODEL_NAME,
+        MODEL_DATA,
+        true,
+      );
+    });
+
+    it('resolves the transformation promise', async function () {
+      sandbox.on(T, 'transform', () => Promise.resolve(TRANSFORMED_DATA));
+      const res = await A.patch(MODEL_NAME, MODEL_DATA, WHERE_CLAUSE);
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(
+        MODEL_NAME,
+        MODEL_DATA,
+        true,
+      );
+    });
   });
 
-  it('overrides the "patchById" method and transforms a given data', async function () {
-    const modelData = {kind: 'modelData'};
-    const transformedData = {kind: 'transformedData'};
-    sandbox.on(V, 'transform', () => transformedData);
-    const res = await A.patchById('model', 1, modelData);
-    expect(res).to.be.eql(transformedData);
-    expect(V.transform).to.be.called.once;
-    expect(V.transform).to.be.called.with.exactly('model', modelData, true);
+  describe('overrides the "patchById" method', function () {
+    it('transforms the given data', async function () {
+      sandbox.on(T, 'transform', () => TRANSFORMED_DATA);
+      const res = await A.patchById(
+        MODEL_NAME,
+        DUMMY_ID,
+        MODEL_DATA,
+        FILTER_CLAUSE,
+      );
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(
+        MODEL_NAME,
+        MODEL_DATA,
+        true,
+      );
+    });
+
+    it('resolves the transformation promise', async function () {
+      sandbox.on(T, 'transform', () => Promise.resolve(TRANSFORMED_DATA));
+      const res = await A.patchById(
+        MODEL_NAME,
+        DUMMY_ID,
+        MODEL_DATA,
+        FILTER_CLAUSE,
+      );
+      expect(res).to.be.eql(TRANSFORMED_DATA);
+      expect(T.transform).to.be.called.once;
+      expect(T.transform).to.be.called.with.exactly(
+        MODEL_NAME,
+        MODEL_DATA,
+        true,
+      );
+    });
   });
 });

package/src/definition/model/model-data-transformer.d.ts

@@ -1,5 +1,6 @@
 import {ModelData} from '../../types.js';
 import {Service} from '@e22m4u/js-service';
+import {ValueOrPromise} from '../../types.js';
 
 /**
  * Model data transformer.
@@ -11,5 +12,5 @@ export declare class ModelDataTransformer extends Service {
    * @param modelName
    * @param modelData
    */
-  transform(modelName: string, modelData: ModelData): ModelData;
+  transform(modelName: string, modelData: ModelData): ValueOrPromise<ModelData>;
 }

package/src/definition/model/model-data-transformer.js

@@ -1,6 +1,7 @@
 import {Service} from '@e22m4u/js-service';
 import {cloneDeep} from '../../utils/index.js';
 import {isPureObject} from '../../utils/index.js';
+import {transformPromise} from '../../utils/index.js';
 import {EmptyValuesDefiner} from './properties/index.js';
 import {InvalidArgumentError} from '../../errors/index.js';
 import {ModelDefinitionUtils} from './model-definition-utils.js';
@@ -16,7 +17,7 @@ export class ModelDataTransformer extends Service {
    * @param {string} modelName
    * @param {object} modelData
    * @param {boolean} isPartial
-   * @returns {object}
+   * @returns {object|Promise<object>}
    */
   transform(modelName, modelData, isPartial = false) {
     if (!isPureObject(modelData))
@@ -33,25 +34,27 @@ export class ModelDataTransformer extends Service {
       );
     const propNames = Object.keys(isPartial ? modelData : propDefs);
     const transformedData = cloneDeep(modelData);
-    propNames.forEach(propName => {
+    return propNames.reduce((transformedDataOrPromise, propName) => {
       const propDef = propDefs[propName];
-      if (!propDef) return;
+      if (!propDef) return transformedDataOrPromise;
       const propType =
         modelDefinitionUtils.getDataTypeFromPropertyDefinition(propDef);
       const propValue = modelData[propName];
       const isEmpty = emptyValuesDefiner.isEmpty(propType, propValue);
-      if (isEmpty) return;
-      const newPropValue = this._transformPropertyValue(
+      if (isEmpty) return transformedDataOrPromise;
+      const newPropValueOrPromise = this._transformPropertyValue(
         modelName,
         propName,
         propDef,
         propValue,
       );
-      if (propValue !== newPropValue) {
-        transformedData[propName] = newPropValue;
-      }
-    });
-    return transformedData;
+      return transformPromise(newPropValueOrPromise, newPropValue => {
+        return transformPromise(transformedDataOrPromise, resolvedData => {
+          if (newPropValue !== propValue) resolvedData[propName] = newPropValue;
+          return resolvedData;
+        });
+      });
+    }, transformedData);
   }
 
   /**
@@ -80,15 +83,21 @@ export class ModelDataTransformer extends Service {
     if (transformDef && typeof transformDef === 'string') {
       return transformFn(propValue, transformDef);
     } else if (Array.isArray(transformDef)) {
-      return transformDef.reduce(
-        (value, transformerName) => transformFn(value, transformerName),
+      return transformDef.reduce((valueOrPromise, transformerName) => {
+        return transformPromise(valueOrPromise, value => {
+          return transformFn(value, transformerName);
+        });
+      }, propValue);
+    } else if (transformDef !== null && typeof transformDef === 'object') {
+      return Object.keys(transformDef).reduce(
+        (valueOrPromise, transformerName) => {
+          const transformerOptions = transformDef[transformerName];
+          return transformPromise(valueOrPromise, value => {
+            return transformFn(value, transformerName, transformerOptions);
+          });
+        },
         propValue,
       );
-    } else if (transformDef !== null && typeof transformDef === 'object') {
-      return Object.keys(transformDef).reduce((value, transformerName) => {
-        const transformerOptions = transformDef[transformerName];
-        return transformFn(value, transformerName, transformerOptions);
-      }, propValue);
     } else {
       throw new InvalidArgumentError(
         'The provided option "transform" of the property %v in the model %v ' +