@vroskus/library-datahandler 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vroskus/library-datahandler",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Data Handler",
   "author": "Vilius Roškus <vilius@regattas.eu>",
   "license": "MIT",
@@ -9,6 +9,10 @@
     "url": "git+https://github.com/vroskus/library-datahandler.git"
   },
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
   "scripts": {
     "postinstall": "npm run build",
     "build": "tsc",
@@ -17,30 +21,30 @@
     "test:e2e": "echo 'No tests'"
   },
   "dependencies": {
-    "@types/lodash": "4.14.192",
-    "@types/sequelize": "4.28.14",
-    "@vroskus/library-error": "1.0.2",
+    "@vroskus/library-error": "1.0.7",
     "lodash": "4.17.21",
-    "mysql2": "3.1.2",
+    "mysql2": "3.2.0",
     "pg-hstore": "2.3.4",
     "pluralize": "8.0.0",
-    "sequelize": "6.29.0",
+    "sequelize": "6.31.0",
     "uuid": "9.0.0"
   },
   "devDependencies": {
     "@types/jest": "29.5.0",
+    "@types/lodash": "4.14.192",
     "@types/node": "18.15.11",
-    "@typescript-eslint/eslint-plugin": "5.53.0",
-    "@typescript-eslint/parser": "5.53.0",
-    "eslint": "8.34.0",
+    "@types/sequelize": "4.28.14",
+    "@typescript-eslint/eslint-plugin": "5.58.0",
+    "@typescript-eslint/parser": "5.58.0",
+    "eslint": "8.38.0",
     "eslint-config-airbnb-base": "15.0.0",
     "eslint-config-airbnb-typescript": "17.0.0",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-import-newlines": "1.3.1",
     "eslint-plugin-react": "7.32.2",
-    "eslint-plugin-sort": "2.4.0",
+    "eslint-plugin-sort": "2.7.1",
     "npm-check": "6.0.1",
-    "sqlite3": "5.1.4",
+    "sqlite3": "5.1.6",
     "typescript": "4.9.5"
   }
 }

package/.eslintrc

@@ -1,76 +0,0 @@
-{
-  "root": true,
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "requireConfigFile": false,
-    "project": ["tsconfig.json"]
-  },
-  "extends": [
-    "airbnb-base",
-    "airbnb-typescript",
-    "plugin:import/recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:sort/recommended"
-  ],
-  "plugins": [
-    "@typescript-eslint",
-    "import",
-    "import-newlines",
-    "react",
-    "sort"
-  ],
-  "rules": {
-    "complexity": ["error", 5],
-    "@typescript-eslint/ban-ts-comment": [1],
-    "@typescript-eslint/no-unused-vars": [2],
-    "curly": ["error", "all"],
-    "import/no-cycle": [0],
-    "no-await-in-loop": 0,
-    "no-console": "error",
-    "no-duplicate-imports": [0],
-    "no-loss-of-precision": [0],
-    "no-restricted-syntax": 0,
-    "no-unreachable-loop": [0],
-    "no-useless-backreference": [0],
-    "no-unused-private-class-members": [2],
-    "padding-line-between-statements": ["error", {
-      "blankLine": "always",
-      "prev": ["const", "let"],
-      "next": "*"
-    }, {
-      "blankLine": "any",
-      "prev": ["const", "let"],
-      "next": ["const", "let"]
-    }, {
-      "blankLine": "always",
-      "prev": ["if", "function", "for"],
-      "next": "*"
-    }, {
-      "blankLine": "always",
-      "prev": "*",
-      "next": "return"
-    }],
-    "object-curly-newline": ["error", {
-      "ObjectExpression": "always",
-      "ObjectPattern": "always",
-      "ImportDeclaration": "always",
-      "ExportDeclaration": "always"
-    }],
-    "function-call-argument-newline": ["error", "always"],
-    "object-property-newline": ["error", {
-      "allowMultiplePropertiesPerLine": false
-    }],
-    "import-newlines/enforce": ["error", {
-      "items": 1,
-      "forceSingleLine": false
-    }],
-    "sort/imports": [0],
-    "sort/exports": [0]
-  },
-  "env": {
-    "node": true,
-    "jest": true,
-    "es6": true
-  }
-}

package/src/helpers.ts

@@ -1,6 +0,0 @@
-export type $Helpers = Record<string, never>;
-
-const helpers: $Helpers = {
-};
-
-export default helpers;

package/src/index.ts

@@ -1,947 +0,0 @@
-// Helpers
-import {
-  Op,
-  Sequelize,
-} from 'sequelize';
-import _ from 'lodash';
-import pluralize from 'pluralize';
-import {
-  baseErrorKey,
-  CustomError,
-} from '@vroskus/library-error';
-import helpers from './helpers';
-
-// Types
-import type {
-  $Config,
-  $Include,
-  $QueryParams,
-  $Where,
-} from './types';
-
-import type {
-  $Helpers,
-} from './helpers';
-
-export * from './types';
-
-class DatabaseService<C extends $Config, MC extends {
-  Config: any;
-  Models: any;
-  Classes: any;
-  Shapes: any;
-}> {
-  models: MC['Classes'];
-
-  helpers: $Helpers;
-
-  stack: Sequelize;
-
-  Op: object;
-
-  constructor({
-    database,
-    dialect,
-    host,
-    logging,
-    password,
-    port,
-    storage,
-    username,
-  }: C, modelShapes: MC['Shapes']) {
-    const dbConfig = {
-      database,
-      define: {
-        charset: 'utf8',
-        dialectOptions: {
-          collate: 'utf8_general_ci',
-        },
-        timestamps: true,
-      },
-      dialect: dialect || 'mysql',
-      dialectOptions: {
-      },
-      host,
-      logging,
-      password,
-      port: Number(port),
-      storage,
-      username,
-    };
-
-    const stack = new Sequelize(
-      dbConfig.database,
-      dbConfig.username,
-      dbConfig.password,
-      dbConfig,
-    );
-
-    // Init models
-    const models: MC['Classes'] = _.mapValues(
-      modelShapes,
-      (f) => f(
-        Sequelize,
-        stack,
-        helpers,
-      ),
-    );
-
-    // Init models associations
-    Object.keys(models).forEach((modelName: keyof MC['Classes']) => {
-      if (models[modelName].associate) {
-        models[modelName].associate(models);
-      }
-
-      if (models[modelName].hooks) {
-        models[modelName].hooks(models);
-      }
-    });
-
-    this.models = models;
-
-    this.helpers = helpers;
-
-    this.stack = stack;
-
-    this.Op = Op;
-  }
-
-  async setupTestEnvironment(): Promise<void> {
-    await this.stack.sync({
-      force: true,
-    });
-  }
-
-  // getModel private method
-  #getModel<MN extends keyof MC['Config']>({
-    modelName,
-  }: {
-    modelName: MN;
-  }): MC['Classes'][MN] {
-    if (!_.has(
-      this.models,
-      modelName,
-    )) {
-      throw new CustomError(
-        'Invalid model name',
-        baseErrorKey.invalidModelNameError,
-        {
-          data: {
-            modelName,
-          },
-        },
-      );
-    }
-
-    return _.get(
-      this.models,
-      modelName,
-    );
-  }
-
-  // getModelInstance private method
-  async #getModelInstance<MN extends keyof MC['Config']>({
-    id,
-    modelName,
-  }: {
-    modelName: MN;
-    id: string;
-  }): Promise<MC['Models'][MN]> {
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const modelInstance = await model.findByPk(id);
-
-    if (modelInstance === null) {
-      throw new CustomError(
-        'Record was not found',
-        baseErrorKey.entityNotFoundError,
-        {
-          data: {
-            id,
-            modelName,
-          },
-        },
-      );
-    }
-
-    return modelInstance;
-  }
-
-  // mapQueryAssociations private method
-  #mapQueryAssociations<MN extends keyof MC['Config']>({
-    include: includeInput,
-    where: whereInput,
-  }: {
-    where: $Where<MC['Config'], MN>;
-    include: $Include<MC['Config'], MC['Classes'], MN>;
-  }): {
-      where: $Where<MC['Config'], MN>;
-      as?: string;
-      include: $Include<MC['Config'], MC['Classes'], MN>;
-    } {
-    let where = _.clone(whereInput);
-
-    const include = _.clone(includeInput);
-
-    _.forOwn(
-      where,
-      (value: string, key: string) => {
-        if (key.includes('.')) {
-          const associationName = key.substr(
-            0,
-            key.indexOf('.'),
-          );
-          const param = key.substr(key.indexOf('.') + 1);
-
-          const model = this.models[pluralize.singular(associationName)];
-
-          if (model) {
-            include.push({
-              as: associationName,
-              model,
-              ...this.#mapQueryAssociations({
-                include: [],
-                where: {
-                  [param]: value,
-                },
-              }),
-            });
-          } else {
-            include.push(associationName);
-          }
-
-          where = _.omit(
-            where,
-            [key],
-          );
-        }
-      },
-    );
-
-    return {
-      include,
-      where,
-    };
-  }
-
-  // prepareQueryParams private method
-  #prepareQueryParams<MN extends keyof MC['Config']>({
-    params,
-  }: {
-    params: $QueryParams<MC['Config'], MC['Classes'], MN>;
-  }): $QueryParams<MC['Config'], MC['Classes'], MN> {
-    const preparedParams = {
-      attributes: params.attributes,
-      include: params.include,
-      where: undefined,
-    };
-
-    if (params.where) {
-      const {
-        include,
-        where,
-      } = this.#mapQueryAssociations({
-        include: _.get(
-          preparedParams,
-          'include',
-          [],
-        ),
-        where: params.where,
-      });
-
-      preparedParams.where = where;
-      preparedParams.include = include;
-    }
-
-    return preparedParams;
-  }
-
-  // associate private method
-  async #associate({
-    action,
-    associationModelId,
-    associationModelName,
-    id,
-    modelName,
-    pivot,
-  }: {
-    action: 'add' | 'remove';
-    modelName: keyof MC['Config'];
-    id: string;
-    associationModelName: keyof MC['Config'];
-    associationModelId: string;
-    pivot?: object;
-  }) {
-    const actionMethod = `${action}${String(associationModelName)}`;
-
-    const modelInstance = await this.#getModelInstance({
-      id,
-      modelName,
-    });
-
-    const associationModel = await this.#getModelInstance({
-      id: associationModelId,
-      modelName: associationModelName,
-    });
-
-    const pivotData = pivot ? {
-      through: pivot,
-    } : {
-    };
-
-    if (typeof modelInstance[actionMethod] !== 'function') {
-      throw new CustomError(
-        'Association action method not found',
-        baseErrorKey.associationActionMethodNotFoundError,
-        {
-          data: {
-            action,
-            associationModelId,
-            associationModelName,
-            id,
-            modelName,
-            pivot,
-          },
-        },
-      );
-    }
-
-    return modelInstance[actionMethod](
-      associationModel,
-      pivotData,
-    );
-  }
-
-  // getOne method
-  async getOne<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: $QueryParams<MC['Config'], MC['Classes'], MN>;
-  }): Promise<MC['Models'][MN] | null> {
-    const model = this.#getModel({
-      modelName,
-    });
-    const request = this.#prepareQueryParams({
-      params,
-    });
-    const modelInstances = await model.findAll(request);
-
-    // If more then one record found
-    if (modelInstances.length > 1) {
-      throw new CustomError(
-        'Multiple records found',
-        baseErrorKey.multipleRecordsFoundError,
-        {
-          data: {
-            amount: modelInstances.length,
-            modelName,
-            request,
-          },
-        },
-      );
-    }
-
-    return _.head(modelInstances) || null;
-  }
-
-  // getFirst method
-  async getFirst<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: $QueryParams<MC['Config'], MC['Classes'], MN>;
-  }): Promise<MC['Models'][MN] | null> {
-    const model = this.#getModel({
-      modelName,
-    });
-    const request = this.#prepareQueryParams({
-      params,
-    });
-    const modelInstances = await model.findAll(request);
-
-    return _.first(modelInstances) || null;
-  }
-
-  // getLast method
-  async getLast<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: $QueryParams<MC['Config'], MC['Classes'], MN>;
-  }): Promise<MC['Models'][MN] | null> {
-    const model = this.#getModel({
-      modelName,
-    });
-    const request = this.#prepareQueryParams({
-      params,
-    });
-    const modelInstances = await model.findAll(request);
-
-    return _.last(modelInstances) || null;
-  }
-
-  // getMany method
-  async getMany<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: $QueryParams<MC['Config'], MC['Classes'], MN>;
-  }): Promise<Array<MC['Models'][MN]>> {
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const request = this.#prepareQueryParams({
-      params,
-    });
-
-    return model.findAll(request);
-  }
-
-  // createOne method
-  async createOne<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: MC['Config'][MN]['ModelCreateParams'];
-  }): Promise<MC['Models'][MN]> {
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const attributes = _.clone(params);
-
-    return model.create(attributes);
-  }
-
-  // createBundle method
-  async createBundle<MN extends keyof MC['Config']>({
-    include,
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: MC['Config'][MN]['ModelCreateParams'];
-    include: $Include<MC['Config'], MC['Classes'], MN>;
-  }): Promise<MC['Models'][MN]> {
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const attributes = _.clone(params);
-
-    return model.create(
-      attributes,
-      {
-        include,
-      },
-    );
-  }
-
-  // createMany method
-  async createMany<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: Array<MC['Config'][MN]['ModelCreateParams']>;
-  }): Promise<Array<MC['Models'][MN]>> {
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const attributes = _.clone(params);
-
-    return model.bulkCreate(attributes);
-  }
-
-  // upsertOne method
-  async upsertOne<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-    where,
-  }: {
-    modelName: MN;
-    params: MC['Config'][MN]['ModelUpsertParams'] | MC['Models'][MN];
-    where: $Where<MC['Config'], MN>;
-  }): Promise<MC['Models'][MN]> {
-    const attributes = _.omit(
-      params,
-      ['id', 'createdAt', 'updatedAt'],
-    );
-
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const request = this.#prepareQueryParams({
-      params: {
-        where,
-      },
-    });
-    const modelInstances = await model.findAll(request);
-
-    if (modelInstances.length > 1) {
-      throw new CustomError(
-        'Multiple records found',
-        baseErrorKey.multipleRecordsFoundError,
-        {
-          data: {
-            amount: modelInstances.length,
-            modelName,
-            request,
-          },
-        },
-      );
-    }
-
-    if (modelInstances.length === 0) {
-      return model.create(attributes);
-    }
-
-    if (typeof modelInstances[0].update === 'function') {
-      return modelInstances[0].update(attributes);
-    }
-
-    return modelInstances[0];
-  }
-
-  // updateOne method
-  async updateOne<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: MC['Config'][MN]['ModelUpdateParams'] | MC['Models'][MN];
-  }): Promise<MC['Models'][MN]> {
-    const {
-      // @ts-ignore
-      id,
-    } = params;
-
-    const modelInstance = await this.#getModelInstance({
-      id,
-      modelName,
-    });
-
-    const attributes: MC['Config'][MN]['ModelUpdateParams'] = _.omit(
-      params,
-      ['id', 'createdAt', 'updatedAt'],
-    );
-
-    if (typeof modelInstance.update === 'function') {
-      await modelInstance.update(attributes);
-    }
-
-    return modelInstance;
-  }
-
-  // toggleOne method
-  async toggleOne<MN extends keyof MC['Config']>({
-    modelName,
-    where,
-  }: {
-    modelName: MN;
-    where: $Where<MC['Config'], MN>;
-  }): Promise<MC['Models'][MN]> {
-    const attributes = _.omit(
-      where,
-      ['id', 'createdAt', 'updatedAt'],
-    );
-
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const request = this.#prepareQueryParams({
-      params: {
-        where,
-      },
-    });
-    let modelInstance = await model.findOne(request);
-
-    if (modelInstance !== null) {
-      await modelInstance.destroy();
-    } else {
-      modelInstance = await model.create(attributes);
-    }
-
-    return modelInstance;
-  }
-
-  // deleteOne method
-  async deleteOne<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: $QueryParams<MC['Config'], MC['Classes'], MN>;
-  }): Promise<MC['Models'][MN]> {
-    const model = this.#getModel({
-      modelName,
-    });
-    const request = this.#prepareQueryParams({
-      params,
-    });
-    const modelInstances = await model.findAll(request);
-
-    // If more then one record found
-    if (modelInstances.length > 1) {
-      throw new CustomError(
-        'Multiple records found',
-        baseErrorKey.multipleRecordsFoundError,
-        {
-          data: {
-            amount: modelInstances.length,
-            modelName,
-            request,
-          },
-        },
-      );
-    }
-
-    if (modelInstances.length === 0) {
-      throw new CustomError(
-        'Record was not found',
-        baseErrorKey.entityNotFoundError,
-        {
-          data: {
-            modelName,
-            request,
-          },
-        },
-      );
-    }
-
-    await modelInstances[0].destroy();
-
-    return modelInstances[0];
-  }
-
-  // deleteMany method
-  async deleteMany<MN extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: $QueryParams<MC['Config'], MC['Classes'], MN>;
-  }): Promise<Array<MC['Models'][MN]>> {
-    const model = this.#getModel({
-      modelName,
-    });
-    const request = this.#prepareQueryParams({
-      params,
-    });
-    const modelInstances = await model.findAll(request);
-
-    for (let index = 0; index < modelInstances.length; index += 1) {
-      if (modelInstances[index].destroy) {
-        await modelInstances[index].destroy();
-      }
-    }
-
-    return modelInstances;
-  }
-
-  // sync method
-  async sync<MN extends keyof MC['Config'], AM extends keyof MC['Config']>({
-    modelName,
-    params: {
-      associationModelId,
-      associationModelName,
-      items,
-    },
-  }: {
-    modelName: MN;
-    params: {
-      items: Array<MC['Config'][MN]['ModelUpsertParams']>;
-      associationModelName: AM;
-      associationModelId: string;
-    };
-  }): Promise<{
-      createdItemIds: Array<string>;
-      deletedItemIds: Array<string>;
-      syncedItems: Array<MC['Models'][MN]>;
-      updatedItemIds: Array<string>;
-    }> {
-    const actions: Array<Promise<MC['Models'][MN]>> = [];
-    const where = {
-      [`${String(associationModelName)}Id`]: associationModelId,
-    };
-
-    const model = this.#getModel({
-      modelName,
-    });
-
-    this.#getModel({
-      modelName: associationModelName,
-    });
-
-    const presentItems = await model.findAll({
-      where,
-    });
-
-    const presentItemIds: Array<string> = _.map(
-      presentItems,
-      'id',
-    );
-
-    const updatedItemIds: Array<string> = _.map(
-      _.filter(
-        items,
-        (item) => item.id,
-      ),
-      'id',
-    );
-
-    const deletedItemIds: Array<string> = _.without(
-      presentItemIds,
-      ...updatedItemIds,
-    );
-
-    const createdItemIds: Array<string> = [];
-    const syncedItems: Array<MC['Models'][MN]> = [];
-
-    items.forEach((item) => {
-      const request = {
-        modelName,
-        params: {
-          ...item,
-          ...where,
-        },
-        where: {
-          id: item.id || null,
-        },
-      };
-
-      const action = (async () => {
-        const upsertedItem = await this.upsertOne(request);
-
-        if (!item.id) {
-          createdItemIds.push(upsertedItem.id);
-        }
-
-        syncedItems.push(upsertedItem);
-      })();
-
-      actions.push(action);
-    });
-
-    deletedItemIds.forEach((id: string) => {
-      const request = {
-        modelName,
-        params: {
-          where: {
-            id,
-            ...where,
-          },
-        },
-      };
-
-      const action = this.deleteOne(request);
-
-      actions.push(action);
-    });
-
-    await Promise.all(actions);
-
-    return {
-      createdItemIds,
-      deletedItemIds,
-      syncedItems,
-      updatedItemIds,
-    };
-  }
-
-  // addAssociation method
-  async addAssociation<MN extends keyof MC['Config'], AM extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: {
-      id: string;
-      associationModelName: AM;
-      associationModelId: string;
-      pivot?: object;
-    };
-  }): Promise<MC['Models'][MN]> {
-    const {
-      associationModelId,
-      associationModelName,
-      id,
-      pivot,
-    } = params;
-
-    const result = await this.#associate({
-      action: 'add',
-      associationModelId,
-      associationModelName,
-      id,
-      modelName,
-      pivot,
-    });
-
-    if (!result || (result && result.length !== 1)) {
-      throw new CustomError(
-        'Already associatied records',
-        baseErrorKey.alreadyAssociatedRecordsError,
-        {
-          data: {
-            model1: modelName,
-            model1id: id,
-            model2: associationModelName,
-            model2id: associationModelId,
-          },
-        },
-      );
-    }
-
-    return result[0];
-  }
-
-  // removeAssociation method
-  async removeAssociation<MN extends keyof MC['Config'], AM extends keyof MC['Config']>({
-    modelName,
-    params,
-  }: {
-    modelName: MN;
-    params: {
-      id: string;
-      associationModelName: AM;
-      associationModelId: string;
-      pivot?: object;
-    };
-  }): Promise<boolean> {
-    const {
-      associationModelId,
-      associationModelName,
-      id,
-    } = params;
-
-    const result = await this.#associate({
-      action: 'remove',
-      associationModelId,
-      associationModelName,
-      id,
-      modelName,
-    });
-
-    if (!result || (result && result !== 1)) {
-      throw new CustomError(
-        'Not associatied records',
-        baseErrorKey.notAssociatedRecordsError,
-        {
-          data: {
-            model1: modelName,
-            model1id: id,
-            model2: associationModelName,
-            model2id: associationModelId,
-          },
-        },
-      );
-    }
-
-    return true;
-  }
-
-  // syncAssociations method
-  async syncAssociations<MN extends keyof MC['Config'], AM extends keyof MC['Config']>({
-    modelName,
-    params: {
-      associationModelIds,
-      associationModelName,
-      id,
-    },
-  }: {
-    modelName: MN;
-    params: {
-      id: string;
-      associationModelName: AM;
-      associationModelIds: Array<string>;
-    };
-  }): Promise<{
-      addedAssociationModelIds: Array<string>;
-      removedAssociationModelIds: Array<string>;
-    }> {
-    const actions: Array<Promise<MC['Models'][MN]>> = [];
-    const pluralAssociationModelName = pluralize.plural(associationModelName);
-
-    const model = this.#getModel({
-      modelName,
-    });
-
-    const modelInstance = await model.findOne({
-      include: [pluralAssociationModelName],
-      where: {
-        id,
-      },
-    });
-
-    const presentAssociationModelIds: Array<string> = _.map(
-      _.get(
-        modelInstance,
-        pluralAssociationModelName,
-        [],
-      ),
-      'id',
-    );
-
-    const addAssociationModelIds = _.without(
-      associationModelIds,
-      ...presentAssociationModelIds,
-    );
-
-    addAssociationModelIds.forEach((associationModelId: string) => {
-      const addAssociationRequest = {
-        modelName,
-        params: {
-          associationModelId,
-          associationModelName,
-          id,
-        },
-      };
-
-      const action = this.addAssociation(addAssociationRequest);
-
-      actions.push(action);
-    });
-
-    const removeAssociationModelIds = _.without(
-      presentAssociationModelIds,
-      ...associationModelIds,
-    );
-
-    removeAssociationModelIds.forEach((associationModelId: string) => {
-      const addAssociationRequest = {
-        modelName,
-        params: {
-          associationModelId,
-          associationModelName,
-          id,
-        },
-      };
-
-      const action = this.removeAssociation(addAssociationRequest);
-
-      actions.push(action);
-    });
-
-    await Promise.all(actions);
-
-    return {
-      addedAssociationModelIds: addAssociationModelIds,
-      removedAssociationModelIds: removeAssociationModelIds,
-    };
-  }
-}
-
-export default DatabaseService;

package/src/types.ts

@@ -1,46 +0,0 @@
-export type $Config = {
-  database: string;
-  dialect?: 'sqlite' | 'mysql';
-  host: string;
-  logging?: boolean;
-  password: string;
-  port: string;
-  storage?: string;
-  username: string;
-};
-
-export type $Where<
-MCC extends Record<MN, any>,
-MN extends keyof MCC,
-> = MCC[MN]['ModelQueryParams'] & {
-  [key: string]: string | Record<string, any> | void;
-};
-
-type $IncludeInside<
-MCC extends Record<MN, any>,
-MCS extends Record<MN, any>,
-MN extends keyof MCC,
-> = MN | {
-  model: MCS[MN];
-  as?: string;
-  where: $Where<MCC, MN>;
-};
-export type $Include<
-MCC extends Record<MN, any>,
-MCS extends Record<MN, any>,
-MN extends keyof MCC,
-> = Array<
-$IncludeInside<MCC, MCS, MN> | string
->;
-
-export type $QueryParams<
-MCC extends Record<MN, any>,
-MCS extends Record<MN, any>,
-MN extends keyof MCC,
-> = {
-  where?: $Where<MCC, MN>;
-  // attributes?: Array<$Keys<$ModelQueryParams<M>>>,
-  attributes?: Array<string>;
-  // include?: $Include<$Keys<$ModelAssociations<M>>>,
-  include?: $Include<MCC, MCS, any>;
-};

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "./dist/",
-    "types": ["node", "jest"],
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "declaration": true,
-    "noImplicitAny": false,
-    "removeComments": true,
-    "noLib": false,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "target": "es6",
-    "sourceMap": true,
-    "lib": [
-      "es6"
-    ]
-  },
-  "exclude": [
-    "node_modules",
-    "./dist/**/*"
-  ],
-   "include": [
-    "./src"
-  ]
-}