@sasscore/database 0.0.1

package/dist/repositories/main.repository.js

@@ -0,0 +1,1120 @@
+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);
+};
+// @ts-nocheck — legacy MainRepository port; tighten types in a follow-up.
+import { Injectable } from '@nestjs/common';
+import { Op } from 'sequelize';
+import { TenantScopeMode } from './tenant-scope-mode.enum.js';
+import { RepositoryExecutionMode } from './repository-execution-mode.enum.js';
+let MainRepository = class MainRepository {
+    modelProvider;
+    _cachedModel = null;
+    _modelLoading = null;
+    /** Execution mode: TENANT (default) requires CLS; SYSTEM bypasses CLS and tenant scope. */
+    executionMode = RepositoryExecutionMode.TENANT;
+    ctx;
+    _logger;
+    /**
+     * Repository-level tenant policy (default-safe).
+     * Override in subclasses: e.g. {@link TenantScopeMode.DISABLED} for junction / auth lookups.
+     */
+    scopeMode = TenantScopeMode.REQUIRED;
+    constructor(modelProvider) {
+        this.modelProvider = modelProvider;
+    }
+    /**
+     * Builds a new repository instance sharing the same model provider, with {@link IRequestContext}
+     * set for this request (see {@link IRepository.createInstance}).
+     */
+    async createInstance(ctx) {
+        const Ctor = this.constructor;
+        const instance = new Ctor(this.modelProvider);
+        instance.setCtx(ctx);
+        (this._logger) && instance.setLogger(this._logger);
+        if (!this._cachedModel && !this._modelLoading)
+            await this.getModel();
+        if (this._cachedModel) {
+            instance._cachedModel = this._cachedModel;
+            instance._modelLoading = null;
+        }
+        return instance;
+    }
+    /**
+     * Builds a new repository instance in SYSTEM mode.
+     * No CLS required, no tenant scope applied — safe for admin/system operations only.
+     * Use instead of `createInstance({ userId: 0, companyId: 0 })`.
+     */
+    async createSystemInstance() {
+        const Ctor = this.constructor;
+        const instance = new Ctor(this.modelProvider);
+        instance.executionMode = RepositoryExecutionMode.SYSTEM;
+        instance._logger = this._logger;
+        instance._cachedModel = this._cachedModel;
+        return instance;
+    }
+    // @deprecated
+    setCtx(ctx) {
+        this.ctx = ctx;
+        return this;
+    }
+    /** Normalized request context; undefined if not set yet. */
+    getCtx() {
+        return this.ctx;
+    }
+    setLogger(logger) {
+        this._logger = logger;
+    }
+    get logger() {
+        return this._logger || console;
+    }
+    /**
+     * Tenant scope from {@link IRequestContext} (set via {@link setRequestContext} before DB calls).
+     */
+    getScope() {
+        const ctx = this.getCtx();
+        const companyId = ctx?.companyId;
+        if (companyId == null || !Number.isFinite(Number(companyId))) {
+            throw new Error('[SECURITY] Tenant scope missing: companyId not set on IRequestContext (call setRequestContext before repository use)');
+        }
+        // const rawStockOwnerId = ctx?.stockOwnerId;
+        // const stockOwnerId =
+        //   rawStockOwnerId != null && Number.isFinite(Number(rawStockOwnerId))
+        //     ? Number(rawStockOwnerId)
+        //     : undefined;
+        return {
+            companyId: Number(companyId),
+            // ...(stockOwnerId !== undefined ? { stockOwnerId } : {}),
+        };
+    }
+    /**
+     * Effective tenant keys for this repository: {@link scopeMode} → CLS → {@link getScope} →
+     * strip keys absent on the Sequelize model → {@link assertRowLevelCompanyScope}.
+     *
+     * Requires `_cachedModel` to be set (call `getModel()` first). If the model is not loaded yet,
+     * returns the context-derived scope without model intersection (conservative).
+     */
+    resolveScopedTenantFields() {
+        if (this.executionMode === RepositoryExecutionMode.SYSTEM) {
+            this.logger.warn(`[SYSTEM QUERY] ${this.constructor.name}`);
+            return {};
+        }
+        if (this.scopeMode === TenantScopeMode.DISABLED) {
+            return {};
+        }
+        const companyIdRaw = this.ctx?.companyId;
+        const hasCompany = companyIdRaw != null && Number.isFinite(Number(companyIdRaw));
+        if (this.scopeMode === TenantScopeMode.OPTIONAL && !hasCompany) {
+            return {};
+        }
+        if (this.scopeMode === TenantScopeMode.REQUIRED && !hasCompany) {
+            throw new Error('[SECURITY] Tenant scope missing: companyId not set on IRequestContext (setRequestContext)');
+        }
+        let scope = { ...this.getScope() };
+        const model = this._cachedModel;
+        if (!model?.rawAttributes) {
+            return scope;
+        }
+        const attrs = model.rawAttributes;
+        if (!Object.prototype.hasOwnProperty.call(attrs, 'accountId')) {
+            const { accountId: _omitAccount, ...rest } = scope;
+            scope = rest;
+        }
+        if (!Object.prototype.hasOwnProperty.call(attrs, 'companyId')) {
+            const { companyId: _omitCompany, ...rest } = scope;
+            scope = rest;
+        }
+        this.assertRowLevelCompanyScope(scope);
+        return scope;
+    }
+    /**
+     * Rows partitioned by `company_id` must never run with an empty tenant scope (would match all
+     * companies like `SELECT count(*) FROM categories`). Junction / company-root models omit
+     * `companyId` in Sequelize attributes — they skip this check.
+     */
+    assertRowLevelCompanyScope(scope) {
+        const model = this._cachedModel;
+        if (!model?.rawAttributes) {
+            return;
+        }
+        if (!Object.prototype.hasOwnProperty.call(model.rawAttributes, 'companyId')) {
+            return;
+        }
+        const cid = scope.companyId;
+        if (cid == null || !Number.isFinite(Number(cid))) {
+            throw new Error(`[SECURITY] Model ${String(model.name)} is company-scoped but resolved tenant scope has no companyId (CLS / getScope).`);
+        }
+    }
+    /**
+     * Sequelize rejects keys with `undefined` (e.g. account_id = undefined). Strip them.
+     * Also cleans plain-object branches inside Op.or / Op.and arrays.
+     */
+    stripUndefinedWhere(where) {
+        if (where == null || typeof where !== 'object') {
+            return where;
+        }
+        const omitUndefinedShallow = (obj) => {
+            if (obj == null || typeof obj !== 'object' || Array.isArray(obj)) {
+                return obj;
+            }
+            const out = { ...obj };
+            for (const key of Object.keys(out)) {
+                if (out[key] === undefined) {
+                    delete out[key];
+                }
+            }
+            return out;
+        };
+        const result = omitUndefinedShallow(where);
+        for (const sym of [Op.or, Op.and]) {
+            const group = result[sym];
+            if (!Array.isArray(group))
+                continue;
+            result[sym] = group.map((entry) => {
+                if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+                    return omitUndefinedShallow(entry);
+                }
+                return entry;
+            });
+        }
+        return result;
+    }
+    /**
+     * Merge CLS tenant scope into a write payload (`create` / `defaults` / `bulkCreate`).
+     * `companyId` from scope still applies last (isolation). If the row sets explicit `accountId`
+     * (e.g. a channel row for a specific account), do not let CLS "current account" overwrite it.
+     */
+    mergeRowWithTenantScope(row, _scope) {
+        // TEMP: CLS tenant scope merge disabled — uncomment block below to restore isolation
+        // const s: Record<string, unknown> = { ...(_scope as Record<string, unknown>) };
+        // if (row.accountId != null && row.accountId !== undefined) {
+        //   delete s.accountId;
+        // }
+        // return this.stripUndefinedWhere({ ...row, ...s });
+        return this.stripUndefinedWhere({ ...row });
+    }
+    /**
+     * Merge caller `where` with tenant scope. Policy: {@link scopeMode}; keys: CLS via
+     * {@link resolveScopedTenantFields} (never ad-hoc per method).
+     *
+     * TEMP: scope merge disabled — uncomment to restore CLS isolation on reads/writes.
+     */
+    applyScopeToWhere(where = {}) {
+        const scope = { ...this.resolveScopedTenantFields() };
+        return this.stripUndefinedWhere({
+            ...where,
+            ...scope,
+        });
+    }
+    // Реалізація абстрактного геттера для моделі
+    // Оскільки ARepository очікує синхронний геттер, але ми маємо асинхронний modelProvider,
+    // ми повертаємо кешовану модель або заглушку
+    get model() {
+        return this._cachedModel || null;
+    }
+    // Асинхронний метод для отримання моделі з кешуванням
+    async getModel() {
+        try {
+            // Якщо модель вже кешована, повертаємо її
+            if (this._cachedModel) {
+                return this._cachedModel;
+            }
+            // Якщо модель вже завантажується, чекаємо завершення
+            if (this._modelLoading) {
+                return await this._modelLoading;
+            }
+            this._modelLoading = this.modelProvider();
+            const model = await this._modelLoading;
+            if (!model) {
+                console.error(`❌ [MainRepository] Model provider returned null!`);
+                this._modelLoading = null;
+                throw new Error('Model is null - tenant connection failed');
+            }
+            if (!model.sequelize) {
+                throw new Error(`[MainRepository] Model "${model.name}" is not bound to Sequelize. Ensure it is registered in models.registry.ts.`);
+            }
+            // Кешуємо модель
+            this._cachedModel = model;
+            this._modelLoading = null; // Завантаження завершено
+            // Get and log Sequelize instance associated with this model
+            const sequelize = this._cachedModel.sequelize;
+            if (process.env.TENANCY_STRATEGY === 'shared' &&
+                sequelize &&
+                sequelize.config &&
+                sequelize.config.database !== process.env.SHARED_DB_NAME) {
+                throw new Error('!!CRITICAL: USE SHARED DATABASE IS NOT CORRECT!!');
+            }
+            return model;
+        }
+        catch (error) {
+            console.error(`❌ [MainRepository] Error getting model:`, error.message);
+            this._modelLoading = null; // Скидаємо стан завантаження при помилці
+            throw error;
+        }
+    }
+    /*
+     * Only for checking model is loaded
+    */
+    async checkModel() {
+        const model = await this.getModel();
+        return model;
+    }
+    // Метод для скидання кешу (корисно для тестування або зміни тенанта)
+    clearModelCache() {
+        this._cachedModel = null;
+        this._modelLoading = null;
+    }
+    async create(item, options) {
+        const model = await this.getModel();
+        if (!model) {
+            const error = new Error('Model is undefined in MainRepository.create');
+            throw error;
+        }
+        // const scope = this.resolveScopedTenantFields();
+        const itemWithScope = this.mergeRowWithTenantScope(item, {});
+        const result = await model.create(itemWithScope, options);
+        return result;
+    }
+    async update(id, item, options) {
+        const model = await this.getModel();
+        if (!model) {
+            console.error("Model is undefined in MainRepository.update");
+            return { affectedCount: 0, rows: [] };
+        }
+        const scopedWhere = this.applyScopeToWhere({ id: id });
+        const [affectedCount, rows] = await model.update(item, {
+            where: scopedWhere,
+            ...options,
+            returning: true,
+        });
+        return { affectedCount, rows };
+    }
+    // async update(
+    //   id: string | number,
+    //   item: Partial<T>,
+    //   options?: IOptions,
+    // ): Promise<T[]> {
+    //   try {
+    //     const model = await this.getModel();
+    //     if (!model) {
+    //       console.error('Model is undefined in MainRepository.update');
+    //       return [];
+    //     }
+    //     const [affectedCount, rows] = await model.update(item, {
+    //       where: { id: id as any },
+    //       ...options,
+    //       returning: true,
+    //     });
+    //     return rows;
+    //   } catch (error) {
+    //     console.error(`Error updating item:`, error);
+    //     return [];
+    //   }
+    // }
+    /**
+     * Оновлений метод delete з автоматичним фільтруванням по tenantId
+     */
+    async delete(id) {
+        const model = await this.getModel();
+        if (!model) {
+            console.error("Model is undefined in MainRepository.delete");
+            return false;
+        }
+        const scopedWhere = this.applyScopeToWhere({ id: id });
+        const affectedCount = await model.destroy({ where: scopedWhere });
+        return affectedCount > 0;
+    }
+    async hardDelete(id) {
+        return await this.delete(id);
+    }
+    async deleteWithTransaction(id, transaction) {
+        const model = await this.getModel();
+        const scopedWhere = this.applyScopeToWhere({ id: id });
+        const affectedCount = await model.destroy({
+            where: scopedWhere,
+            transaction,
+        });
+        return affectedCount > 0;
+    }
+    /**
+     * Оновлений метод findById з автоматичним фільтруванням по tenantId
+     */
+    async findById(id, companyId, options) {
+        const model = await this.getModel();
+        if (!model) {
+            console.error("Model is undefined in MainRepository.findById");
+            return null;
+        }
+        if (companyId) {
+            return await model.findOne({
+                where: this.applyScopeToWhere({
+                    id: id,
+                    companyId,
+                }),
+                ...options,
+            });
+        }
+        return await model.findOne({
+            where: this.applyScopeToWhere({ id: id }),
+            ...options,
+        });
+    }
+    async findByIdWithTransaction(id, transaction) {
+        try {
+            const model = await this.getModel();
+            return await model.findByPk(id, { transaction });
+        }
+        catch (error) {
+            console.error(`Error finding item by id with transaction:`, error);
+            return null;
+        }
+    }
+    async findAllWithTransaction(transaction) {
+        try {
+            const model = await this.getModel();
+            return await model.findAll({ transaction });
+        }
+        catch (error) {
+            console.error(`Error finding all items with transaction:`, error);
+            return [];
+        }
+    }
+    async findOne(where, options) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.findOne');
+                return null;
+            }
+            const scopedWhere = this.applyScopeToWhere(where);
+            return await model.findOne({ where: scopedWhere, ...options });
+        }
+        catch (error) {
+            console.error(`Error finding one item:`, error);
+            return null;
+        }
+    }
+    async findOneWithTransaction(where, transaction) {
+        try {
+            const model = await this.getModel();
+            return await model.findOne({ where, transaction });
+        }
+        catch (error) {
+            console.error(`Error finding one item with transaction:`, error);
+            return null;
+        }
+    }
+    /**
+     * @deprecated Use findAll instead
+     */
+    async findMany(where, include, order) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                return [];
+            }
+            const options = { where };
+            if (include)
+                options.include = include;
+            if (order)
+                options.order = order;
+            return await model.findAll(options);
+        }
+        catch (error) {
+            console.error(`Error finding many items:`, error);
+            return [];
+        }
+    }
+    /**
+     * Find all items with automatic isolation by companyId and accountId
+     */
+    async findAll(where = {}, options) {
+        try {
+            const model = await this.getModel();
+            if (!model)
+                return [];
+            const scopedWhere = this.applyScopeToWhere(where);
+            return await model.findAll({
+                where: scopedWhere,
+                ...(options || {}),
+            });
+        }
+        catch (error) {
+            console.error(`Error finding many items:`, error);
+            return [];
+        }
+    }
+    /**
+     * Find all items with pagination and automatic isolation
+     */
+    async findAllWithPagination(where = {}, pagination, options) {
+        const model = await this.getModel();
+        if (!model)
+            throw new Error('Model is null in findAllWithPagination');
+        const scopedWhere = this.applyScopeToWhere(where);
+        const countOptions = {
+            where: scopedWhere,
+            distinct: true,
+        };
+        if (options?.include) {
+            countOptions.include = options.include;
+        }
+        const limit = pagination.limit || 10;
+        const page = pagination.page || 1;
+        const offset = (page - 1) * limit;
+        let orderFields = [];
+        if (pagination.order) {
+            if (Array.isArray(pagination.order)) {
+                orderFields = pagination.order;
+            }
+            else if (typeof pagination.order === 'string') {
+                orderFields = [pagination.order];
+            }
+        }
+        const [list, total] = await Promise.all([
+            model.findAll({
+                where: scopedWhere,
+                ...(options || {}),
+                limit,
+                offset,
+                order: orderFields.length > 0
+                    ? orderFields.map((field) => [
+                        field,
+                        pagination.orderDirection || 'DESC',
+                    ])
+                    : [],
+            }),
+            model.count(countOptions),
+        ]);
+        return {
+            list,
+            total: Number(total),
+            page,
+            limit,
+            totalPages: Math.ceil(Number(total) / limit),
+        };
+    }
+    async findManyWithTransaction(where, transaction, include, order) {
+        try {
+            const model = await this.getModel();
+            const options = { where, transaction };
+            if (include)
+                options.include = include;
+            if (order)
+                options.order = order;
+            return await model.findAll(options);
+        }
+        catch (error) {
+            console.error(`Error finding many items with transaction:`, error);
+            return [];
+        }
+    }
+    /**
+     * Count with automatic isolation by companyId and accountId
+     */
+    async count(where, tenantId) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.count');
+                return 0;
+            }
+            const scopedWhere = this.applyScopeToWhere(where);
+            const options = { where: scopedWhere };
+            const result = await model.count(options);
+            return result;
+        }
+        catch (error) {
+            console.error(`Error counting item:`, error);
+            return 0;
+        }
+    }
+    async countWithTransaction(where, transaction) {
+        try {
+            const model = await this.getModel();
+            const result = await model.count({ where, transaction });
+            return result;
+        }
+        catch (error) {
+            console.error(`Error counting item with transaction:`, error);
+            return 0;
+        }
+    }
+    /**
+     * Оновлений метод exists з автоматичним фільтруванням по tenantId
+     */
+    async exists(where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.exists');
+                return false;
+            }
+            const scopedWhere = this.applyScopeToWhere(where);
+            const count = await model.count({ where: scopedWhere });
+            return count > 0;
+        }
+        catch (error) {
+            console.error(`Error checking existence of item:`, error);
+            return false;
+        }
+    }
+    async existsWithTransaction(where, transaction) {
+        try {
+            const model = await this.getModel();
+            const count = await model.count({ where, transaction });
+            return count > 0;
+        }
+        catch (error) {
+            console.error(`Error checking existence of item with transaction:`, error);
+            return false;
+        }
+    }
+    async bulkCreate(items) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.bulkCreate');
+                return [];
+            }
+            // const scope = this.resolveScopedTenantFields();
+            const rows = (items || []).map((row) => this.mergeRowWithTenantScope(row, {}));
+            return await model.bulkCreate(rows);
+        }
+        catch (error) {
+            console.error(`Error bulk creating item:`, error);
+            return [];
+        }
+    }
+    async bulkCreateWithTransaction(items, transaction) {
+        try {
+            const model = await this.getModel();
+            return await model.bulkCreate(items, { transaction });
+        }
+        catch (error) {
+            console.error(`Error bulk creating item with transaction:`, error);
+            return [];
+        }
+    }
+    async bulkUpdate(where, updates) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.bulkUpdate');
+                return 0;
+            }
+            const scopedWhere = this.applyScopeToWhere(where);
+            const [affectedCount] = await model.update(updates, { where: scopedWhere });
+            return affectedCount;
+        }
+        catch (error) {
+            console.error(`Error bulk updating item:`, error);
+            return 0;
+        }
+    }
+    async bulkUpdateWithTransaction(where, updates, transaction) {
+        try {
+            const model = await this.getModel();
+            const scopedWhere = this.applyScopeToWhere(where);
+            const [affectedCount] = await model.update(updates, {
+                where: scopedWhere,
+                transaction,
+            });
+            return affectedCount;
+        }
+        catch (error) {
+            console.error(`Error bulk updating item with transaction:`, error);
+            return 0;
+        }
+    }
+    async bulkDelete(where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.bulkDelete');
+                return 0;
+            }
+            const scopedWhere = this.applyScopeToWhere(where);
+            return await model.destroy({ where: scopedWhere });
+        }
+        catch (error) {
+            console.error(`Error bulk deleting item:`, error);
+            return 0;
+        }
+    }
+    async bulkDeleteWithTransaction(where, transaction) {
+        try {
+            const model = await this.getModel();
+            const scopedWhere = this.applyScopeToWhere(where);
+            return await model.destroy({ where: scopedWhere, transaction });
+        }
+        catch (error) {
+            console.error(`Error bulk deleting item with transaction:`, error);
+            return 0;
+        }
+    }
+    async findAndCountAll(options) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.findAndCountAll');
+                return { rows: [], count: 0 };
+            }
+            return await model.findAndCountAll(options);
+        }
+        catch (error) {
+            console.error(`Error finding and counting item:`, error);
+            return { rows: [], count: 0 };
+        }
+    }
+    async findAndCountAllWithTransaction(options, transaction) {
+        try {
+            const model = await this.getModel();
+            return await model.findAndCountAll({ ...options, transaction });
+        }
+        catch (error) {
+            console.error(`Error finding and counting item with transaction:`, error);
+            return { rows: [], count: 0 };
+        }
+    }
+    async findOrCreate(where, defaults) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.findOrCreate');
+                return [null, false];
+            }
+            // const scope = this.resolveScopedTenantFields();
+            return await model.findOrCreate({
+                where: this.applyScopeToWhere(where),
+                defaults: this.mergeRowWithTenantScope(defaults, {}),
+            });
+        }
+        catch (error) {
+            console.error(`Error finding or creating item:`, error);
+            return [null, false];
+        }
+    }
+    async findOrCreateWithTransaction(where, defaults, transaction) {
+        try {
+            const model = await this.getModel();
+            // const scope = this.resolveScopedTenantFields();
+            return await model.findOrCreate({
+                where: this.applyScopeToWhere(where),
+                defaults: this.mergeRowWithTenantScope(defaults, {}),
+                transaction,
+            });
+        }
+        catch (error) {
+            console.error(`Error finding or creating item with transaction:`, error);
+            return [null, false];
+        }
+    }
+    async upsert(values, where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.upsert');
+                return null;
+            }
+            // Sequelize upsert не приймає where в options, а використовує values для пошуку
+            const [instance] = await model.upsert(values);
+            return instance;
+        }
+        catch (error) {
+            console.error(`Error upserting item:`, error);
+            return null;
+        }
+    }
+    async upsertWithTransaction(values, where, transaction) {
+        try {
+            const model = await this.getModel();
+            // Sequelize upsert не приймає where в options, а використовує values для пошуку
+            const [instance] = await model.upsert(values, {
+                transaction,
+            });
+            return instance;
+        }
+        catch (error) {
+            console.error(`Error upserting item with transaction:`, error);
+            return null;
+        }
+    }
+    async increment(where, fields, by = 1) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.increment');
+                return 0;
+            }
+            const result = await model.increment(fields, { where, by });
+            return result[fields[0]] || 0;
+        }
+        catch (error) {
+            console.error(`Error incrementing item:`, error);
+            return 0;
+        }
+    }
+    async incrementWithTransaction(where, fields, by, transaction) {
+        try {
+            const model = await this.getModel();
+            const result = await model.increment(fields, {
+                where,
+                by,
+                transaction,
+            });
+            return result[fields[0]] || 0;
+        }
+        catch (error) {
+            console.error(`Error incrementing item with transaction:`, error);
+            return 0;
+        }
+    }
+    async decrement(where, fields, by = 1) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.decrement');
+                return 0;
+            }
+            const result = await model.decrement(fields, { where, by });
+            return result[fields[0]] || 0;
+        }
+        catch (error) {
+            console.error(`Error decrementing item:`, error);
+            return 0;
+        }
+    }
+    async decrementWithTransaction(where, fields, by, transaction) {
+        try {
+            const model = await this.getModel();
+            const result = await model.decrement(fields, {
+                where,
+                by,
+                transaction,
+            });
+            return result[fields[0]] || 0;
+        }
+        catch (error) {
+            console.error(`Error decrementing item with transaction:`, error);
+            return 0;
+        }
+    }
+    async max(field, where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.max');
+                return 0;
+            }
+            const options = { attributes: [[field, 'max']] };
+            if (where)
+                options.where = where;
+            const result = await model.findOne(options);
+            return result?.getDataValue('max') || 0;
+        }
+        catch (error) {
+            console.error(`Error getting max ${field} from item:`, error);
+            return 0;
+        }
+    }
+    async min(field, where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.min');
+                return 0;
+            }
+            const options = { attributes: [[field, 'min']] };
+            if (where)
+                options.where = where;
+            const result = await model.findOne(options);
+            return result?.getDataValue('min') || 0;
+        }
+        catch (error) {
+            console.error(`Error getting min ${field} from item:`, error);
+            return 0;
+        }
+    }
+    async sum(field, where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.sum');
+                return 0;
+            }
+            const options = { attributes: [[field, 'sum']] };
+            if (where)
+                options.where = where;
+            const result = await model.findOne(options);
+            return result?.getDataValue('sum') || 0;
+        }
+        catch (error) {
+            console.error(`Error getting sum ${field} from item:`, error);
+            return 0;
+        }
+    }
+    async average(field, where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.average');
+                return 0;
+            }
+            const options = { attributes: [[field, 'avg']] };
+            if (where)
+                options.where = where;
+            const result = await model.findOne(options);
+            return result?.getDataValue('avg') || 0;
+        }
+        catch (error) {
+            console.error(`Error getting average ${field} from item:`, error);
+            return 0;
+        }
+    }
+    async rawQuery(sql, replacements) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.rawQuery');
+                return [];
+            }
+            return await model.sequelize.query(sql, { replacements });
+        }
+        catch (error) {
+            console.error(`Error executing raw query on item:`, error);
+            return [];
+        }
+    }
+    async rawQueryWithTransaction(sql, transaction, replacements) {
+        try {
+            const model = await this.getModel();
+            return await model.sequelize.query(sql, {
+                replacements,
+                transaction,
+            });
+        }
+        catch (error) {
+            console.error(`Error executing raw query on item with transaction:`, error);
+            return [];
+        }
+    }
+    async findFirst(where, options) {
+        try {
+            const model = await this.getModel();
+            if (!model)
+                return null;
+            const scopedWhere = this.applyScopeToWhere(where || {});
+            return await model.findOne({
+                where: scopedWhere,
+                ...options,
+            });
+        }
+        catch (error) {
+            console.error(`Error finding first item:`, error);
+            return null;
+        }
+    }
+    async findAndCount(where, include, order) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.findAndCount');
+                return { count: 0, rows: [] };
+            }
+            const scopedWhere = this.applyScopeToWhere(where || {});
+            const options = { where: scopedWhere };
+            if (include)
+                options.include = include;
+            if (order)
+                options.order = order;
+            return await model.findAndCountAll(options);
+        }
+        catch (error) {
+            console.error(`Error finding and counting items:`, error);
+            return { count: 0, rows: [] };
+        }
+    }
+    async updateMany(where, data, options) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.updateMany');
+                return options.returning ? [] : 0;
+            }
+            const scopedWhere = this.applyScopeToWhere(where);
+            if (options && options?.returning) {
+                const [affectedCount, rows] = await model.update(data, {
+                    where: scopedWhere,
+                    ...options,
+                    returning: true,
+                });
+                return rows;
+            }
+            const [affectedCount] = await model.update(data, {
+                where: scopedWhere,
+                ...options,
+                returning: false,
+            });
+            return affectedCount;
+        }
+        catch (error) {
+            console.error(`Error updating many items:`, error);
+            return options.returning ? [] : 0;
+        }
+    }
+    async updateManyWithTransaction(where, data, transaction) {
+        try {
+            const model = await this.getModel();
+            const scopedWhere = this.applyScopeToWhere(where);
+            const [affectedCount] = await model.update(data, {
+                where: scopedWhere,
+                transaction,
+            });
+            return affectedCount;
+        }
+        catch (error) {
+            console.error(`Error updating many items with transaction:`, error);
+            return 0;
+        }
+    }
+    async softDelete(id, companyId) {
+        try {
+            const model = await this.getModel();
+            if (!model)
+                return false;
+            // Check if model has is_delete property
+            const hasIsDeleteField = model.getAttributes && 'is_delete' in model.getAttributes();
+            if (hasIsDeleteField) {
+                const scopedWhere = this.applyScopeToWhere({ id: id });
+                const [affectedCount] = await model.update({ deletedAt: new Date() }, { where: scopedWhere });
+                return affectedCount > 0;
+            }
+            else {
+                const scopedWhere = this.applyScopeToWhere({ id: id });
+                const affectedCount = await model.destroy({ where: scopedWhere });
+                return affectedCount > 0;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async deleteMany(where) {
+        try {
+            const model = await this.getModel();
+            if (!model) {
+                console.error('Model is undefined in MainRepository.deleteMany');
+                return 0;
+            }
+            const scopedWhere = this.applyScopeToWhere(where);
+            return await model.destroy({ where: scopedWhere });
+        }
+        catch (error) {
+            console.error(`Error deleting many items:`, error);
+            return 0;
+        }
+    }
+    async deleteManyWithTransaction(where, transaction) {
+        try {
+            const model = await this.getModel();
+            const scopedWhere = this.applyScopeToWhere(where);
+            return await model.destroy({ where: scopedWhere, transaction });
+        }
+        catch (error) {
+            console.error(`Error deleting many items with transaction:`, error);
+            return 0;
+        }
+    }
+    /**
+     * 🔍 Debug: Log query info before each operation
+     */
+    logQueryInfo(method, params) {
+        try {
+            const model = this._cachedModel;
+            if (model && model.sequelize) {
+                const config = model.sequelize.config;
+                const strategy = process.env.TENANCY_STRATEGY || 'separate';
+                const sharedDbName = process.env.SHARED_DB_NAME || 'not_set';
+                console.log(`🔍 [${this.constructor.name}.${method}] Database Info:`);
+                console.log(`  📊 Database: ${config.database || 'unknown'}`);
+                console.log(`  🌐 Host: ${config.host || 'unknown'}`);
+                console.log(`  🔌 Port: ${config.port || 'unknown'}`);
+                console.log(`  👤 Username: ${config.username || 'unknown'}`);
+                console.log(`  🎯 Strategy: ${strategy}`);
+                console.log(`  🔗 SHARED_DB_NAME: ${sharedDbName}`);
+                console.log(`  📝 Model: ${model.name}`);
+                if (params) {
+                    console.log(`  📋 Params:`, params);
+                }
+                // Додаткова інформація про стратегію
+                if (strategy === 'shared') {
+                    console.log(`  ✅ Using SHARED strategy - connecting to: ${sharedDbName}`);
+                }
+                else {
+                    console.log(`  🏗️ Using SEPARATE strategy - tenant-specific connection`);
+                }
+                console.log(`  ─`.repeat(50));
+            }
+            else {
+                console.log(`🔍 [${this.constructor.name}.${method}] Model not loaded yet`);
+                console.log(`  📊 Strategy: ${process.env.TENANCY_STRATEGY || 'separate'}`);
+                console.log(`  🔗 SHARED_DB_NAME: ${process.env.SHARED_DB_NAME || 'not_set'}`);
+                console.log(`  ─`.repeat(50));
+            }
+        }
+        catch (error) {
+            console.log(`🔍 [${this.constructor.name}.${method}] Error logging query info:`, error.message);
+        }
+    }
+    /**
+     * Створити новий запис з транзакцією
+     */
+    async createWithTransaction(item, transaction) {
+        try {
+            const model = await this.getModel();
+            return await model.create(item, { transaction });
+        }
+        catch (error) {
+            console.error(`Error creating item with transaction:`, error);
+            throw error;
+        }
+    }
+    async updateWithTransaction(id, item, transaction) {
+        try {
+            const model = await this.getModel();
+            const [affectedCount] = await model.update(item, {
+                where: { id: id },
+                transaction,
+            });
+            return affectedCount > 0;
+        }
+        catch (error) {
+            console.error(`Error updating item with transaction:`, error);
+            return false;
+        }
+    }
+    checkModelInfo(model) {
+        console.log('Check model info');
+        console.log('Model:', model);
+        console.log('Model name:', model.name);
+        console.log('Model tableName:', model.tableName);
+        console.log('Model sequelize:', model.sequelize);
+        if (model?.sequelize?.config) {
+            console.log('Model sequelize config:', model.sequelize.config);
+            console.log('Model sequelize config database:', model.sequelize.config.database);
+            console.log('Model sequelize config host:', model.sequelize.config.host);
+        }
+    }
+};
+MainRepository = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [Function])
+], MainRepository);
+export { MainRepository };
+//# sourceMappingURL=main.repository.js.map