@nestlize/repository 0.1.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kiril Yakymchuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,182 @@
+# 🧱 Abstract Sequelize Repository for NestJS
+
+Abstract repository pattern implementation for Sequelize ORM in NestJS projects.
+
+- [Quick start](#-quick-start)
+- [Purpose](#-purpose)
+- [Methods](#-irepository-methods)
+- [Configuration](#-irepositoryoptions)
+
+Supports:
+
+* ✅ Custom DTO typing or Sequelize creation attributes
+* ✅ Custom error handling
+* ✅ Soft delete support (`paranoid: true`)
+* ✅ Pagination
+* ✅ Optional UUID auto-generation
+* ✅ Injected logger
+* ✅ Simplified transaction handling
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @nestlize/repository
+# or
+yarn add @nestlize/repository
+# or
+pnpm add @nestlize/repository
+```
+
+---
+
+## 🧠 Purpose
+
+This package provides a reusable and extensible base repository class that works with `sequelize-typescript`. It reduces repetitive CRUD logic while keeping full flexibility for different entity needs.
+
+---
+
+## 🔧 Features
+
+| Feature               | Description                                                        |
+|-----------------------|--------------------------------------------------------------------|
+| ✅ Abstract class      | Extend `AbstractRepository` for each model                         |
+| ✅ Generic typing      | Supports custom DTOs or defaults to Sequelize `CreationAttributes` |
+| ✅ Soft delete         | Supports `paranoid` models with `force` option                     |
+| ✅ Transaction utility | `repository.transaction()` for scoped logic                        |
+| ✅ Logger injection    | Optional NestJS logger for better traceability                     |
+| ✅ Flexible options    | Configure `logger`, `autoGenerateId`, etc.                         |
+
+---
+
+## 🛠️ IRepositoryOptions
+
+Configuration options for the abstract repository:
+
+| Option           | Type                     | Default                 | Description                                           |
+|------------------|--------------------------|-------------------------|-------------------------------------------------------|
+| `logger`         | `Logger`                 | `NestJS default Logger` | Optional NestJS logger instance for internal logging  |
+
+---
+
+## 🛠️ IRepository Methods
+
+All methods return Promises.
+
+| Method                                         | Parameters                                                                                                                                          | Description                                     | 
+|------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------|
+| `create(dto, options?)`                        | `dto: CreationAttributes<TModel>`, `options?: CreateOptions<TModel>`                                                                                | Creates a new record                            |  
+| `insert(dto, options?)`                        | Same as `create`                                                                                                                                    | Alias for `create`                              |  
+| `insertMany(dtos, options?)`                   | `dtos: CreationAttributes<TModel>[]`, `options?: BulkCreateOptions<Attributes<TModel>>`                                                             | Creates multiple records                        |   
+| `findByPk(primaryKey, options?)`               | `primaryKey: string \| number`, `options?: Omit<FindOptions, 'where'>`                                                                              | Find record by primary key                      |   
+| `findOne(query?, options?)`                    | `query?: WhereOptions`, `options?: Omit<FindOptions, 'where'>`                                                                                      | Find single record by query                     |   
+| `findAll(query?, options?)`                    | `query?: WhereOptions`, `options?: Omit<FindOptions, 'where'>`                                                                                      | Find all matching records                       |   
+| `findAllPaginated(options?)`                   | `limit?: number`, `offset?: number`, `page?: number`, `query?: WhereOptions`, `options?: Omit<FindAndCountOptions, 'where' \| 'offset' \| 'limit'>` | Find paginated records and total count          |
+| `updateByPk(primaryKey, dto, options?)`        | `primaryKey: string \| number`, `dto: Partial<Attributes<TModel>>`, `options?: SaveOptions`                                                         | Update record by primary key                    |
+| `deleteByPk(primaryKey, options?)`             | `primaryKey: string \| number`, `options?: InstanceDestroyOptions`                                                                                  | Delete (soft/hard) record by primary key        |
+| `restoreByPk(primaryKey, options?)`            | `primaryKey: string \| number`, `options?: InstanceRestoreOptions`                                                                                  | Restore previously soft-deleted record          |
+| `transaction(runInTransaction)`                | `(transaction: Transaction) => Promise<R>`                                                                                                          | Execute callback within a Sequelize transaction |
+| `calculateOffset(limit: number, page: number)` | `limit: number, page: number`                                                                                                                       | Calculate offset for page pagination            |
+
+---
+
+## 🚀 Quick Start
+
+### 1. Define a model
+
+[`BaseModel`](src/base.model.ts) extends from sequelize `Model` class adding timestamps
+
+```ts
+import { BaseModel } from '@nestlize/repository'
+
+@Table({ tableName: 'users', paranoid: true })
+export class User extends BaseModel<User> {
+  @PrimaryKey
+  @Default(DataType.UUIDV4)
+  @Column
+  user_id: string;
+
+  @Column
+  name: string;
+
+  @Column
+  email: string;
+}
+```
+
+---
+
+### 2. Create repository
+
+```ts
+import { AbstractRepository } from '@nestlize/repository';
+
+@Injectable()
+export class UserRepository extends AbstractRepository<User> {
+  constructor(@InjectModel(User) userModel: typeof User) {
+    super(userModel);
+  }
+}
+```
+
+---
+
+### 3. Use in your service
+
+```ts
+@Injectable()
+export class UserService {
+  constructor(private readonly users: UserRepository) {}
+
+  async createUser(dto: CreateUserDto) {
+    return this.users.create(dto);
+  }
+
+  async getUsers() {
+    return this.users.findAll();
+  }
+
+  async updateUser(id: string, update: YourUpdateType) {
+    return this.users.updateByPk(id, update);
+  }
+}
+```
+
+---
+
+## ⚙️ Options
+
+You can pass options when instantiating:
+
+```ts
+{
+  logger: new MyCustomLogger('MyRepo'), // optional
+}
+```
+
+---
+
+## 💡 Transaction usage
+
+```ts
+await repo.transaction(async (transaction) => {
+  await repo.insert(data, { transaction });
+  await transaction.commit();
+});
+```
+
+---
+
+## 🏗️ Advanced Use
+
+* Override methods like `create()` or `updateByPk()` to apply custom hooks or validation.
+* Extend with filters, scopes, or relations as needed.
+
+---
+
+## 📜 License
+
+MIT © Kiril Yakymchuk
+
+---

package/index.d.ts

@@ -0,0 +1,352 @@
+import { Logger } from '@nestjs/common'
+import {
+  Transaction,
+  WhereOptions,
+  CreationAttributes,
+  CreateOptions,
+  Attributes,
+  InstanceDestroyOptions,
+  InstanceRestoreOptions,
+  SaveOptions,
+  FindOptions,
+  BulkCreateOptions,
+  FindAndCountOptions,
+} from 'sequelize'
+import { Model, ModelCtor } from 'sequelize-typescript'
+
+/**
+ * Options for the find with pagination.
+ *
+ * @template TModel Type of the Sequelize model.
+ */
+export interface PaginationOptions<TModel extends Model> {
+  /**
+   * Sets the amount of returned records.
+   */
+  limit?: number
+
+  /**
+   * Amount of records to skip from the start.
+   */
+  offset?: number
+
+  /**
+   * Used for page pagination instead of offset.
+   */
+  page?: number
+
+  /**
+   * A Sequelize where clause.
+   */
+  query?: WhereOptions<Attributes<TModel>>
+
+  /**
+   * Optional Sequelize find options, excluding 'where', 'offset' and 'limit'.
+   */
+  findOptions?: Omit<
+    FindAndCountOptions<Attributes<TModel>>,
+    'where' | 'offset' | 'limit'
+  >
+}
+
+/**
+ * Configuration options for the abstract repository.
+ */
+export interface IRepositoryOptions {
+  /**
+   * Optional NestJS logger instance used for internal logging.
+   */
+  logger?: Logger
+}
+
+/**
+ * Generic interface defining basic repository operations
+ * such as CRUD and transaction management.
+ *
+ * @template TModel Type of the Sequelize model.
+ */
+export interface IRepository<TModel extends Model> {
+  /**
+   * Creates a new record in the database.
+   *
+   * @param dto The data to create record with.
+   * @param options Optional Sequelize create options.
+   * @returns A promise resolving to the created model instance.
+   */
+  create(
+    dto: CreationAttributes<TModel>,
+    options?: CreateOptions<TModel>,
+  ): Promise<TModel>
+
+  /**
+   * Creates a new record in the database. Alias for `create`
+   *
+   * @param dto The data to create record with.
+   * @param options Optional Sequelize create options.
+   * @returns A promise resolving to the created model instance.
+   */
+  insert(
+    dto: CreationAttributes<TModel>,
+    options?: CreateOptions<TModel>,
+  ): Promise<TModel>
+
+  /**
+   * Creates multiple new records in the database.
+   *
+   * @param dtos The array of data to create records with.
+   * @param options Optional Sequelize create options.
+   * @returns A promise resolving to the created models instances.
+   */
+  insertMany(
+    dtos: CreationAttributes<TModel>[],
+    options?: BulkCreateOptions<Attributes<TModel>>,
+  ): Promise<TModel[]>
+
+  /**
+   * Finds a record by its primary key
+   *
+   * @param primaryKey The value of the primary key.
+   * @param options Optional Sequelize find options, excluding 'where'.
+   * @returns A Promise resolving the found record or null.
+   */
+  findByPk(
+    primaryKey: string | number,
+    options?: Omit<FindOptions<Attributes<TModel>>, 'where'>,
+  ): Promise<TModel | null>
+
+  /**
+   * Finds a single record by matching the provided query
+   *
+   * @param query A Sequelize where clause.
+   * @param options Optional Sequelize find options, excluding 'where'.
+   * @returns A Promise resolving the found record or null.
+   */
+  findOne(
+    query?: WhereOptions<Attributes<TModel>>,
+    options?: Omit<FindOptions<Attributes<TModel>>, 'where'>,
+  ): Promise<TModel | null>
+
+  /**
+   * Finds all records matching the provided query
+   *
+   * @param query A Sequelize where clause.
+   * @param options Optional Sequelize find options, excluding 'where'.
+   * @returns A Promise resolving the found records or empty erray.
+   */
+  findAll(
+    query?: WhereOptions<Attributes<TModel>>,
+    options?: Omit<FindOptions<Attributes<TModel>>, 'where'>,
+  ): Promise<TModel[]>
+
+  /**
+   * Find first amount of records set by limit and count all existing records
+   *
+   * @param options Pagination options.
+   *
+   * @returns A Promise resolving `rows`(found records) and `count`(amout of existing records).
+   */
+  findAllPaginated(
+    options: PaginationOptions<TModel>,
+  ): Promise<{ rows: TModel[]; count: number }>
+
+  /**
+   * Updates a records by its primary key.
+   *
+   * @param primaryKey The value of the primary key.
+   * @param dto Partial data to update the record with.
+   * @param options Optional Sequelize save options.
+   * @returns A Promise resolving the updated record or null.
+   */
+  updateByPk(
+    primaryKey: string | number,
+    dto: Partial<Attributes<TModel>>,
+    options?: SaveOptions<Attributes<TModel>>,
+  ): Promise<TModel | null>
+
+  /**
+   * Deletes (soft or hard) a record by its primary key.
+   *
+   * @param primaryKey The value of the primary key.
+   * @param options Optional Sequelize destroy options.
+   * @returns A Promise resolving the deleted record or null.
+   */
+  deleteByPk(
+    primaryKey: string | number,
+    options?: InstanceDestroyOptions,
+  ): Promise<TModel | null>
+
+  /**
+   * Restores a preiously soft-deleted record by its primary key.
+   *
+   * @param primaryKey The value of the primary key.
+   * @param options Optional Sequelize restore options.
+   * @returns A Promise resolving the found record or null.
+   */
+  restoreByPk(
+    primaryKey: string | number,
+    options?: InstanceRestoreOptions,
+  ): Promise<TModel | null>
+
+  /**
+   * Executes a callback function withing a Sequelize transaction.
+   *
+   * @param runInTransaction The callback to execute, receiving the transaction object.
+   * @returns A promise resolving to the result of the callback.
+   */
+  transaction<R>(
+    runInTransaction: (transaction: Transaction) => Promise<R>,
+  ): Promise<R>
+
+  /**
+   * Calculate offset for page pagination
+   *
+   * @param limit Amount of records to return per page
+   * @param page Target page number
+   * @returns Number, amount of records to skip (offset)
+   */
+  calculateOffset(limit: number, page: number): number
+}
+
+/**
+ * Base model class based on sequelize `Model` class
+ * adding timestamps.
+ *
+ * @template TModelAttributes Type of the Model class. Default is `any`
+ * @template TCreationAttributes Type of the Model creation attributes. Default is Model class
+ */
+export declare class BaseModel<
+  TModelAttributes extends {} = any,
+  TCreationAttributes extends {} = TModelAttributes,
+> extends Model<TModelAttributes, TCreationAttributes> {
+  /**
+   * Model creation time
+   */
+  createdAt: Date
+
+  /**
+   * Model update time. Default is `createdAt` timestamp
+   */
+  updatedAt: Date
+
+  /**
+   * Model deletion time
+   *
+   * @default null
+   */
+  deletedAt: Date | null
+}
+
+/**
+ * Base abstract class providing default implementations of common
+ * repository operations. Designed to be extended for model-specific logic.
+ *
+ * @template TModel Type of the Sequelize model.
+ */
+export declare class AbstractRepository<
+  TModel extends Model,
+> implements IRepository<TModel> {
+  /**
+   * Logger instance used for logging errors.
+   */
+  protected readonly logger: Logger
+
+  /**
+   * Constructs the abstract repository.
+   *
+   * @param model The Sequelize model constructor.
+   * @param options Optional configuration options.
+   */
+  constructor(model: ModelCtor<TModel>, options?: IRepositoryOptions)
+
+  /**
+   * @inheritdoc
+   */
+  create(
+    dto: CreationAttributes<TModel>,
+    options?: CreateOptions<TModel>,
+  ): Promise<TModel>
+
+  /**
+   * @inheritdoc
+   */
+  insert(
+    dto: CreationAttributes<TModel>,
+    options?: CreateOptions<TModel>,
+  ): Promise<TModel>
+
+  /**
+   * @inheritdoc
+   */
+  insertMany(
+    dtos: CreationAttributes<TModel>[],
+    options?: BulkCreateOptions<Attributes<TModel>>,
+  ): Promise<TModel[]>
+
+  /**
+   * @inheritdoc
+   */
+  findByPk(
+    primaryKey: string | number,
+    options?: Omit<FindOptions<Attributes<TModel>>, 'where'>,
+  ): Promise<TModel | null>
+
+  /**
+   * @inheritdoc
+   */
+  findOne(
+    query?: WhereOptions<Attributes<TModel>>,
+    options?: Omit<FindOptions<Attributes<TModel>>, 'where'>,
+  ): Promise<TModel | null>
+
+  /**
+   * @inheritdoc
+   */
+  findAll(
+    query?: WhereOptions<Attributes<TModel>>,
+    options?: Omit<FindOptions<Attributes<TModel>>, 'where'>,
+  ): Promise<TModel[]>
+
+  /**
+   * @inheritdoc
+   */
+  findAllPaginated(
+    options: PaginationOptions<TModel>,
+  ): Promise<{ rows: TModel[]; count: number }>
+
+  /**
+   * @inheritdoc
+   */
+  updateByPk(
+    primaryKey: string | number,
+    dto: Partial<Attributes<TModel>>,
+    options?: SaveOptions<Attributes<TModel>>,
+  ): Promise<TModel | null>
+
+  /**
+   * @inheritdoc
+   */
+  deleteByPk(
+    primaryKey: string | number,
+    options?: InstanceDestroyOptions,
+  ): Promise<TModel | null>
+
+  /**
+   * @inheritdoc
+   */
+  restoreByPk(
+    primaryKey: string | number,
+    options?: InstanceRestoreOptions,
+  ): Promise<TModel | null>
+
+  /**
+   * @inheritdoc
+   */
+  transaction<R>(
+    runInTransaction: (transaction: Transaction) => Promise<R>,
+  ): Promise<R>
+
+  /**
+   * @inheritDoc
+   */
+  calculateOffset(limit: number, page: number): number
+}

package/index.js

@@ -0,0 +1,182 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRepository = exports.BaseModel = void 0;
+const common_1 = require("@nestjs/common");
+const sequelize_typescript_1 = require("sequelize-typescript");
+class BaseModel extends sequelize_typescript_1.Model {
+}
+exports.BaseModel = BaseModel;
+__decorate([
+    sequelize_typescript_1.CreatedAt,
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], BaseModel.prototype, "createdAt", void 0);
+__decorate([
+    sequelize_typescript_1.UpdatedAt,
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], BaseModel.prototype, "updatedAt", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Default)(null),
+    sequelize_typescript_1.AllowNull,
+    sequelize_typescript_1.DeletedAt,
+    (0, sequelize_typescript_1.Column)({ type: sequelize_typescript_1.DataType.DATE }),
+    __metadata("design:type", Object)
+], BaseModel.prototype, "deletedAt", void 0);
+class AbstractRepository {
+    constructor(model, options = {}) {
+        this.model = model;
+        const { logger = new common_1.Logger(this.constructor.name) } = options;
+        if (new.target === AbstractRepository) {
+            throw new Error('AbstractRepository cannot be instantiated directly');
+        }
+        this.logger = logger;
+    }
+    async create(dto, options) {
+        try {
+            return await this.model.create(dto, options);
+        }
+        catch (error) {
+            this.logger.error(`insert: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async insert(dto, options) {
+        return this.create(dto, options);
+    }
+    async insertMany(dtos, options) {
+        try {
+            return await this.model.bulkCreate(dtos, options);
+        }
+        catch (error) {
+            this.logger.error(`insertMany: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async findByPk(primaryKey, options) {
+        try {
+            return await this.model.findByPk(primaryKey, options);
+        }
+        catch (error) {
+            this.logger.error(`findByPk: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async findOne(query, options) {
+        try {
+            return await this.model.findOne({
+                where: query,
+                ...options,
+            });
+        }
+        catch (error) {
+            this.logger.error(`findOne: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async findAll(query, options) {
+        try {
+            return await this.model.findAll({
+                where: query,
+                ...options,
+            });
+        }
+        catch (error) {
+            this.logger.error(`findAll: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async findAllPaginated(options) {
+        try {
+            let { limit = 10, offset = 0, page, query, findOptions } = options;
+            if (!offset && page) {
+                offset = this.calculateOffset(limit, page);
+            }
+            return await this.model.findAndCountAll({
+                where: query,
+                limit,
+                offset,
+                ...findOptions,
+            });
+        }
+        catch (error) {
+            this.logger.error(`findAllPaginated: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async updateByPk(primaryKey, dto, options) {
+        try {
+            const entity = await this.findByPk(primaryKey);
+            if (!entity) {
+                return null;
+            }
+            entity.set(dto);
+            return await entity.save(options);
+        }
+        catch (error) {
+            this.logger.error(`updatedByPk: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async deleteByPk(primaryKey, options) {
+        try {
+            const entity = await this.findByPk(primaryKey, {
+                paranoid: !options?.force,
+            });
+            if (!entity) {
+                return null;
+            }
+            if (options?.force && entity.getDataValue('deletedAt') !== undefined) {
+                entity.setDataValue('deletedAt', new Date());
+            }
+            await entity.destroy(options);
+            return entity;
+        }
+        catch (error) {
+            this.logger.error(`deleteByPk: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async restoreByPk(primaryKey, options) {
+        try {
+            const entity = await this.findByPk(primaryKey, {
+                ...options,
+                paranoid: false,
+            });
+            if (!entity) {
+                return null;
+            }
+            await entity.restore(options);
+            return entity;
+        }
+        catch (error) {
+            this.logger.error(`restoreByPk: ${error}`);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async transaction(runInTransaction) {
+        return this.model.sequelize.transaction(async (transaction) => {
+            try {
+                return await runInTransaction(transaction);
+            }
+            catch (error) {
+                this.logger.error(`transaction: ${error}`);
+                throw new common_1.InternalServerErrorException();
+            }
+        });
+    }
+    calculateOffset(limit, page) {
+        return limit * (page - 1);
+    }
+}
+exports.AbstractRepository = AbstractRepository;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@nestlize/repository",
+  "version": "0.1.13",
+  "description": "Abstract repository and other database tools for Nest and Sequelize.js ORM",
+  "keywords": [
+    "sequelize.js",
+    "abstract",
+    "repository",
+    "orm",
+    "nest"
+  ],
+  "homepage": "https://github.com/stbestichhh/nest-sequelize-repository#readme",
+  "bugs": {
+    "url": "https://github.com/stbestichhh/nest-sequelize-repository/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stbestichhh/nest-sequelize-repository.git"
+  },
+  "license": "MIT",
+  "author": "Kiril Yakymchuk <stbestich@gmail.com>",
+  "type": "commonjs",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "tsc",
+    "fmt": "prettier --write .",
+    "fmt:check": "prettier -c .",
+    "test": "jest",
+    "prepare": "husky",
+    "prepublish": "pnpm build && cp dist/index.js ./ && cp src/index.d.ts ./",
+    "postpublish": "rimraf index.js && rimraf index.d.ts"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@nestjs/common": "^11.1.11",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.19.3",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "prettier": "^3.7.4",
+    "reflect-metadata": "^0.2.2",
+    "rimraf": "^6.1.2",
+    "rxjs": "^7.8.2",
+    "sequelize": "^6.37.7",
+    "sequelize-typescript": "^2.1.6",
+    "sqlite3": "^5.1.7",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "11.x",
+    "reflect-metadata": "0.x",
+    "rxjs": "7.x",
+    "sequelize": "6.x",
+    "sequelize-typescript": "2.x"
+  }
+}