Respan Dataset Explorer

Файл с моделью - pooduct-model.js, OS не надо добавлять

Извините за недопонимание. Давайте исправим это, используя указанный вами файл `product-model.js` без добавления префикса `OS`.

### Модель `product-model.js`
```javascript
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const ProductModel = sequelize.define(
    'product',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        title: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
    },
    {
        tableName: 'products',  // Имя таблицы
        schema: 'os',           // Схема базы данных
        timestamps: false,      // Отключаем временные метки
    }
);

module.exports = ProductModel;
```

### Сервис `ProductService`
Теперь создадим сервис для управления данными модели `ProductModel`.

```javascript
const ProductModel = require('../models/product-model');

class ProductService {
    /** получить все записи из таблицы "products" */
    async getAllRecords() {
        const list = await ProductModel.findAll();
        return list;
    }

    /** создать запись в таблице "products" */
    async createRecord(payload) {
        const data = await ProductModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "products" */
    async updateRecord(payload) {
        let record = await ProductModel.findOne({ where: { id: payload.id } });
        if (!record) throw new Error('Record not found');
        record.title = payload?.title || record.title;
        return await record.save();
    }

    /** удалить запись из таблицы "products" */
    async removeRecord(recordId) {
        const record = await ProductModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new ProductService();
```

Теперь у вас есть адекватная модель и сервис для работы с таблицей `products` в схеме `os`. 

Еще раз напиши сервис для:
```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const ProductModel = sequelize.define(
    'product',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        title: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
    },
    {
        tableName: 'products',  // Определяем имя таблицы
        schema: 'os',           // Указываем схему базы данных
        timestamps: false,      // Отключаем временные метки
    }
);

module.exports = ProductModel;
```

Конечно, давайте создадим сервис для вашей модели `ProductModel`, который будет работать с таблицей `products` в схеме `os`.

### Сервис `ProductService`

```javascript
const ProductModel = require('../models/product-model');

class ProductService {
    /** получить все записи из таблицы "products" в схеме "os" */
    async getAllRecords() {
        try {
            const list = await ProductModel.findAll();
            return list;
        } catch (error) {
            console.error("Error fetching records:", error);
            throw error;
        }
    }

    /** создать запись в таблице "products" в схеме "os" */
    async createRecord(payload) {
        try {
            const data = await ProductModel.create(payload);
            return data;
        } catch (error) {
            console.error("Error creating record:", error);
            throw error;
        }
    }

    /** обновить запись в таблице "products" в схеме "os" */
    async updateRecord(payload) {
        try {
            const record = await ProductModel.findOne({ where: { id: payload.id } });
            if (!record) throw new Error('Record not found');

            record.title = payload?.title || record.title;
            return await record.save();
        } catch (error) {
            console.error("Error updating record:", error);
            throw error;
        }
    }

    /** удалить запись из таблицы "products" в схеме "os" */
    async removeRecord(recordId) {
        try {
            const result = await ProductModel.destroy({ where: { id: recordId } });
            if (!result) throw new Error('Record not found');
            return result;
        } catch (error) {
            console.error("Error deleting record:", error);
            throw error;
        }
    }
}

module.exports = new ProductService();
```

### Пояснение

1. **Обработка ошибок:** Я добавил блоки `try-catch` вокруг каждой операции для обработки возможных ошибок. Это полезно для отладки и понимания проблем, которые могут возникнуть при взаимодействии с базой данных.

2. **CRUD операции:** В сервисе реализованы все основные функции для CRUD операций:
   - `getAllRecords()` для получения всех записей,
   - `createRecord(payload)` для создания новой записи,
   - `updateRecord(payload)` для обновления существующей записи,
   - `removeRecord(recordId)` для удаления записи по идентификатору.

Теперь у вас есть полноценный сервис для работы с вашей моделью `ProductModel`, который можно легко интегрировать в ваше приложение.

Точно по примеру:

Хорошо, создадим сервис для модели `ProductModel`, строго следуя предоставленному вами примеру.

### Модель `product-model.js`
(Вы уже предоставили это, но я повторю для полного понимания контекста)

```javascript
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const ProductModel = sequelize.define(
    'product',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        title: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
    },
    {
        tableName: 'products',  // Определяем имя таблицы
        schema: 'os',           // Указываем схему базы данных
        timestamps: false,      // Отключаем временные метки
    }
);

module.exports = ProductModel;
```

### Сервис `ProductService`
Теперь создадим сервис так, как вы описали в примере:

```javascript
const ProductModel = require('../models/product-model');

class ProductService {
    /** получить все записи из таблицы "products" */
    async getAllRecords() {
        const list = await ProductModel.findAll();
        return list;
    }

    /** создать запись в таблице "products" */
    async createRecord(payload) {
        const data = await ProductModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "products" */
    async updateRecord(payload) {
        let record = await ProductModel.findOne({ where: { id: payload.id } });
        if (!record) throw new Error('Record not found');
        record.title = payload?.title || record.title;
        return await record.save();
    }

    /** удалить запись из таблицы "products" */
    async removeRecord(recordId) {
        const record = await ProductModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new ProductService();
```

### Примечания

- **CRUD операции**: Как указано в примере, сервис содержит методы для выполнения операций: `getAllRecords()` (получить все записи), `createRecord()` (создать запись), `updateRecord()` (обновить запись) и `removeRecord()` (удалить запись).
  
- **Обновление и удаление**: В методах обновления и удаления добавлена проверка на существование записи, и в случае отсутствия записи выбрасывается ошибка. Это не было частью вашего примера, но это стандартная практика для предотвращения ошибок.

Теперь сервис выполнен в соответствии с вашим примером и готов к работе с моделью `ProductModel`.

Вот пример:
```
const ProductModel = require('../models/product-model');

class ProductService {
    /** получить все записи из таблицы "products" */
    async getAllRecords() {
        const list = await ProductModel.findAll();
        return list;
    }

    /** создать запись в таблице "products" */
    async createRecord(payload) {
        const data = await ProductModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "products" */
    async updateRecord(payload) {
        let record = await ProductModel.findOne({ where: { id: payload.id } });
        record.title = payload?.title || record.title;
        return await record.save();
    }

    /** удалить запись из таблицы "products" */
    async removeRecord(recordId) {
        const record = await ProductModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new ProductService();
```

Понял, теперь точно следуем вашему примеру. Вот как будет выглядеть сервис для вашей модели `ProductModel`:

### Сервис `ProductService`

```javascript
const ProductModel = require('../models/product-model');

class ProductService {
    /** получить все записи из таблицы "products" */
    async getAllRecords() {
        const list = await ProductModel.findAll();
        return list;
    }

    /** создать запись в таблице "products" */
    async createRecord(payload) {
        const data = await ProductModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "products" */
    async updateRecord(payload) {
        let record = await ProductModel.findOne({ where: { id: payload.id } });
        if (record) {
            record.title = payload?.title || record.title;
            return await record.save();
        }
        throw new Error('Record not found');
    }

    /** удалить запись из таблицы "products" */
    async removeRecord(recordId) {
        const record = await ProductModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new ProductService();
```

### Объяснения

- **Методы сервиса**: В каждом из методов (`getAllRecords`, `createRecord`, `updateRecord`, `removeRecord`), используются стандартные методы Sequelize для работы с данными:
  - `findAll()` для получения всех записей.
  - `create(payload)` для создания новой записи.
  - `findOne()` и последующее изменение модели для обновления существующей записи.
  - `destroy({ where: { id: recordId } })` для удаления записи.

- **Проверка на существование записи**: При обновлении записи добавлено условие проверки на существование записи перед ее обновлением.

Сервис в точности соответствует представленному вами примеру. Он выполняет основные CRUD операции для модели `ProductModel`.

Теперь для:
```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const DepartmentModel = sequelize.define(
    'department',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        name: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
    },
    {
        tableName: 'department', // Имя таблицы
        schema: 'os',           // Указываем схему базы данных
        timestamps: false,      // Отключаем временные метки
    }
);

module.exports = DepartmentModel;
```

Хорошо, теперь давайте создадим сервис для модели `DepartmentModel`, аналогично вашему примеру для модели `ProductModel`.

### Сервис `DepartmentService`

```javascript
const DepartmentModel = require('../models/department-model');

class DepartmentService {
    /** получить все записи из таблицы "department" */
    async getAllRecords() {
        const list = await DepartmentModel.findAll();
        return list;
    }

    /** создать запись в таблице "department" */
    async createRecord(payload) {
        const data = await DepartmentModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "department" */
    async updateRecord(payload) {
        let record = await DepartmentModel.findOne({ where: { id: payload.id } });
        if (record) {
            record.name = payload?.name || record.name;
            return await record.save();
        }
        throw new Error('Record not found');
    }

    /** удалить запись из таблицы "department" */
    async removeRecord(recordId) {
        const record = await DepartmentModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new DepartmentService();
```

### Объяснения

- **Методы сервиса**: Мы используем те же методы взаимодействия с базой данных, что и в вашем примере:
  - `findAll()` для получения всех записей отдела.
  - `create(payload)` для создания нового отдела.
  - `findOne()` для поиска отдела, который нужно обновить, и его последующего сохранения.
  - `destroy({ where: { id: recordId } })` для удаления отдела по идентификатору.

- **Проверка существования**: Метод `updateRecord` включает проверку на существование записи перед обновлением, чтобы избежать ошибок.

Теперь у вас есть готовый сервис для работы с моделью `DepartmentModel`, который поддерживает основные CRUD операции.

Теперь для:
```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const InstitutionModel = sequelize.define(
    'institution',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        title: {
            type: Sequelize.STRING(100),
            allowNull: false,
        },
        address: {
            type: Sequelize.STRING(100),
            allowNull: false,
        },
        INN: {
            type: Sequelize.STRING(100),
            allowNull: false,
        },
        KPP: {
            type: Sequelize.STRING(100),
            allowNull: false,
        },
    },
    {
        tableName: 'institution', // Имя таблицы
        schema: 'os',             // Указываем схему базы данных
        timestamps: false,        // Отключаем временные метки
    }
);

module.exports = InstitutionModel;
```

Создадим сервис для вашей модели `InstitutionModel`, аналогично предыдущим примерам. Этот сервис будет включать стандартные CRUD операции: получение всех записей, создание, обновление и удаление записи.

### Сервис `InstitutionService`

```javascript
const InstitutionModel = require('../models/institution-model');

class InstitutionService {
    /** получить все записи из таблицы "institution" */
    async getAllRecords() {
        const list = await InstitutionModel.findAll();
        return list;
    }

    /** создать запись в таблице "institution" */
    async createRecord(payload) {
        const data = await InstitutionModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "institution" */
    async updateRecord(payload) {
        let record = await InstitutionModel.findOne({ where: { id: payload.id } });
        if (record) {
            record.title = payload?.title || record.title;
            record.address = payload?.address || record.address;
            record.INN = payload?.INN || record.INN;
            record.KPP = payload?.KPP || record.KPP;
            return await record.save();
        }
        throw new Error('Record not found');
    }

    /** удалить запись из таблицы "institution" */
    async removeRecord(recordId) {
        const record = await InstitutionModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new InstitutionService();
```

### Объяснения

- **Методы сервиса**:
  - `getAllRecords()`: Получает все записи из таблицы `institution`.
  - `createRecord(payload)`: Создает новую запись на основе переданного объекта `payload`.
  - `updateRecord(payload)`: Ищет запись по `id` и обновляет поля `title`, `address`, `INN` и `KPP`, если они предоставлены в объекте `payload`.
  - `removeRecord(recordId)`: Удаляет запись по идентификатору `id`.

- **Обработка обновлений**: Метод `updateRecord` проверяет существование записи перед обновлением и обновляет только те поля, которые присутствуют в `payload`.

Теперь у вас есть сервис для работы с моделью `InstitutionModel`, поддерживающий основные операции с данными.

```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const PersonModel = sequelize.define(
    'person',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        lastname: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
        firstname: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
        patronymic: {
            type: Sequelize.STRING(50),
            allowNull: true, // Значение по умолчанию NULL допускает null
        },
        position: { // Использование обратных кавычек в SQL для защиты зарезервированных слов
            type: Sequelize.STRING(50),
            allowNull: false,
        },
        phonenumber: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
        series: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
        number: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
    },
    {
        tableName: 'person', // Имя таблицы
        schema: 'os',        // Указываем схему базы данных
        timestamps: false,   // Отключаем временные метки
    }
);

module.exports = PersonModel;
```

Давайте создадим сервис для работы с `PersonModel`, который будет содержать методы для выполнения основных CRUD операций.

### Сервис `PersonService`

```javascript
const PersonModel = require('../models/person-model');

class PersonService {
    /** получить все записи из таблицы "person" */
    async getAllRecords() {
        const list = await PersonModel.findAll();
        return list;
    }

    /** создать запись в таблице "person" */
    async createRecord(payload) {
        const data = await PersonModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "person" */
    async updateRecord(payload) {
        let record = await PersonModel.findOne({ where: { id: payload.id } });
        if (record) {
            record.lastname = payload?.lastname || record.lastname;
            record.firstname = payload?.firstname || record.firstname;
            record.patronymic = payload?.patronymic || record.patronymic;
            record.position = payload?.position || record.position;
            record.phonenumber = payload?.phonenumber || record.phonenumber;
            record.series = payload?.series || record.series;
            record.number = payload?.number || record.number;
            return await record.save();
        }
        throw new Error('Record not found');
    }

    /** удалить запись из таблицы "person" */
    async removeRecord(recordId) {
        const record = await PersonModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new PersonService();
```

### Объяснения

- **Методы сервиса**:
  - `getAllRecords()`: Возвращает все записи из таблицы `person`.
  - `createRecord(payload)`: Создает новую запись используя объект `payload`.
  - `updateRecord(payload)`: Находит запись по `id` и обновляет поля, если они присутствуют в `payload`. Если запись не найдена, выбрасывает ошибку.
  - `removeRecord(recordId)`: Удаляет запись из таблицы `person` по идентификатору `id`.

- **Поля модели**: Все поля модели учитываются при создании и обновлении записи. Поле `patronymic` допускает значение `null`, и это учтено в обработки обновлений.

Теперь у вас есть сервис `PersonService`, который позволяет управлять данными в таблице `person`, используя основные CRUD операции.

```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const StorageModel = sequelize.define(
    'storage',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        type: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
        address: {
            type: Sequelize.STRING(50),
            allowNull: false,
        },
    },
    {
        tableName: 'storage', // Имя таблицы
        schema: 'os',         // Указываем схему базы данных
        timestamps: false,    // Отключаем временные метки
    }
);

module.exports = StorageModel;
```

Давайте создадим сервис для работы с `StorageModel`, который будет включать методы для выполнения основных операций CRUD.

### Сервис `StorageService`

```javascript
const StorageModel = require('../models/storage-model');

class StorageService {
    /** получить все записи из таблицы "storage" */
    async getAllRecords() {
        const list = await StorageModel.findAll();
        return list;
    }

    /** создать запись в таблице "storage" */
    async createRecord(payload) {
        const data = await StorageModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "storage" */
    async updateRecord(payload) {
        let record = await StorageModel.findOne({ where: { id: payload.id } });
        if (record) {
            record.type = payload?.type || record.type;
            record.address = payload?.address || record.address;
            return await record.save();
        }
        throw new Error('Record not found');
    }

    /** удалить запись из таблице "storage" */
    async removeRecord(recordId) {
        const record = await StorageModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new StorageService();
```

### Объяснения

- **Методы сервиса**:
  - `getAllRecords()`: Возвращает все записи из таблицы `storage`.
  - `createRecord(payload)`: Создает новую запись на основе объекта `payload`.
  - `updateRecord(payload)`: Обновляет поля `type` и `address` в записи, найденной по `id`, если такие существуют в объекте `payload`. Если запись не найдена, выбрасывает ошибку.
  - `removeRecord(recordId)`: Удаляет запись из таблицы `storage` по указанному идентификатору `id`.

- **Обновление полей**: Все поля модели (`type`, `address`) учитываются при создании и обновлении записи. Если обновляемое поле отсутствует в `payload`, сохраняется текущее значение.

Теперь у вас есть `StorageService`, который позволяет управлять записями в таблице `storage`, используя основные CRUD операции.

Теперь по примеру:
```
const ProxyHeaderModel = require('../models/proxy-header-model');

class ProxyHeaderService {
    /** получить все записи из таблицы "proxyheaders" */
    async getAllRecords() {
        const list = await ProxyHeaderModel.findAll();
        return list;
    }

    /** получить одну запись по id из таблицы "proxyheaders" */
    async getOneRecord(recordId) {
        const record = await ProxyHeaderModel.findOne({ where: {id: recordId } });
        return record;
    }

    /** создать запись в таблице "proxyheaders" */
    async createRecord(payload) {
        const data = await ProxyHeaderModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "proxyheaders" */
    async updateRecord(payload) {
        let record = await ProxyHeaderModel.findOne({ where: { id: payload.id } });
        record.number = payload?.number || record?.number;
        record.dischargeDate = payload?.dischargeDate || record?.dischargeDate;
        record.endDate = payload?.endDate || record?.endDate;
        record.individualId = payload?.individualId || record?.individualId;
        record.organizationId = payload?.organizationId || record?.organizationId;
        return await record.save();
    }

    /** удалить запись из таблицы "proxyheaders" */
    async removeRecord(recordId) {
        const record = await ProxyHeaderModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new ProxyHeaderService();
```
```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const ProxyHeaderModel = sequelize.define(
    'proxyheader',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        number: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        dischargeDate: {
            type: Sequelize.DATE,
            allowNull: false
        },
        endDate: {
            type: Sequelize.DATE,
            allowNull: false,
        },
        individualId: {
            type: Sequelize.INTEGER,
            foreignKey: true,
            allowNull: false,
        },
        organizationId: {
            type: Sequelize.INTEGER,
            foreignKey: true,
            allowNull: false,
        },
    },
    {
        timestamps: false,
    }
);

module.exports = ProxyHeaderModel;
```
Сделай для:
```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const OsHeaderModel = sequelize.define(
    'osheader',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        number: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        date: {
            type: Sequelize.DATE,
            allowNull: false,
        },
        institutionId: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        departmentId: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        personId: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        storageId: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
    },
    {
        tableName: 'osheaders', // Имя таблицы
        schema: 'os',           // Указываем схему базы данных
        timestamps: false,      // Отключаем временные метки
    }
);

module.exports = OsHeaderModel;
```

Создадим сервис для модели `OsHeaderModel`, следуя вашему примеру с `ProxyHeaderService`. Этот сервис будет включать методы для выполнения операций CRUD, включая получение всех записей, получение одной записи, создание, обновление и удаление записей.

### Сервис `OsHeaderService`

```javascript
const OsHeaderModel = require('../models/os-header-model');

class OsHeaderService {
    /** получить все записи из таблицы "osheaders" */
    async getAllRecords() {
        const list = await OsHeaderModel.findAll();
        return list;
    }

    /** получить одну запись по id из таблицы "osheaders" */
    async getOneRecord(recordId) {
        const record = await OsHeaderModel.findOne({ where: { id: recordId } });
        return record;
    }

    /** создать запись в таблице "osheaders" */
    async createRecord(payload) {
        const data = await OsHeaderModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "osheaders" */
    async updateRecord(payload) {
        let record = await OsHeaderModel.findOne({ where: { id: payload.id } });
        if (record) {
            record.number = payload?.number || record.number;
            record.date = payload?.date || record.date;
            record.institutionId = payload?.institutionId || record.institutionId;
            record.departmentId = payload?.departmentId || record.departmentId;
            record.personId = payload?.personId || record.personId;
            record.storageId = payload?.storageId || record.storageId;
            return await record.save();
        }
        throw new Error('Record not found');
    }

    /** удалить запись из таблицы "osheaders" */
    async removeRecord(recordId) {
        const record = await OsHeaderModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new OsHeaderService();
```

### Объяснения

- **Методы сервиса** следуют вашему примеру и предоставляют следующие операции:
  - `getAllRecords()`: Возвращает все записи из таблицы `osheaders`.
  - `getOneRecord(recordId)`: Возвращает одну запись по ID из таблицы `osheaders`.
  - `createRecord(payload)`: Создает новую запись на основе объекта `payload`.
  - `updateRecord(payload)`: Обновляет существующую запись, определяемую по `id` в `payload`, и обновляет поля с данными из `payload`, если они предоставлены.
  - `removeRecord(recordId)`: Удаляет запись по `id` из таблицы `osheaders`.

- **Логика обновления**: В методе `updateRecord` перед изменением проверяется наличие записи, чтобы избежать ошибок при попытке обновления несуществующей записи. В случае отсутствия записи, выбрасывается ошибка.

Теперь у вас есть `OsHeaderService` для работы с моделью `OsHeaderModel`, поддерживающий основные операции CRUD.

```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const ProxyBodyModel = sequelize.define(
    'proxybody',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        count: {
            type: Sequelize.INTEGER,
            allowNull: true,
            defaultValue: 1,
        },
        unit: {
            type: Sequelize.STRING(8),
            allowNull: false,
        },
        proxyHeaderId: {
            type: Sequelize.INTEGER,
            foreignKey: true,
            allowNull: false,
        },
        productId: {
            type: Sequelize.INTEGER,
            foreignKey: true,
            allowNull: false,
        },
    },
    {
        timestamps: false,
    }
);

module.exports = ProxyBodyModel;
```
```
const ProxyBodyModel = require('../models/proxy-body-model');

class ProxyBodyService {
    /** получить все записи из таблицы "proxybodies" по  proxyHeaderId */
    async getAllHeadersRecords(headerId) {
        const list = await ProxyBodyModel.findAll({ where: { proxyHeaderId: headerId } });
        return list;
    }

    /** создать запись в таблице "proxybodies" */
    async createRecord(payload) {
        const data = await ProxyBodyModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "proxybodies" */
    async updateRecord(payload) {
        let record = await ProxyBodyModel.findOne({ where: { id: payload.id } });
        record.count = payload?.count || record.count;
        record.unit = payload?.unit || record.unit;
        record.proxyHeaderId = payload?.proxyHeaderId || record.proxyHeaderId;
        record.productId = payload?.productId || record.productId;
        return await record.save();
    }

    /** удалить запись из таблицы "proxybodies" */
    async removeRecord(recordId) {
        const record = await ProxyBodyModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new ProxyBodyService();
```
По примеру выше сделай для:
```
const Sequelize = require('sequelize');
const sequelize = require('../connection');

const OsbodiesModel = sequelize.define(
    'osbody',
    {
        id: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            allowNull: false,
        },
        osHeaderId: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        productId: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        inventoryNum: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        cost: {
            type: Sequelize.INTEGER,
            allowNull: false,
        },
        debet: {
            type: Sequelize.STRING(100),
            allowNull: false,
        },
        credit: {
            type: Sequelize.STRING(100),
            allowNull: false,
        },
        journalNum: {
            type: Sequelize.STRING(100),
            allowNull: false,
        },
    },
    {
        tableName: 'osbodies', // Имя таблицы
        schema: 'os',          // Указываем схему базы данных
        timestamps: false,     // Отключаем временные метки
    }
);

module.exports = OsbodiesModel;
```

Создадим сервис для модели `OsbodiesModel`, аналогичный вашему примеру с `ProxyBodyService`. Этот сервис будет включать основные методы для CRUD операций, с учетом специфики работы с полем `osHeaderId`.

### Сервис `OsbodiesService`

```javascript
const OsbodiesModel = require('../models/osbodies-model');

class OsbodiesService {
    /** получить все записи из таблицы "osbodies" по osHeaderId */
    async getAllHeadersRecords(headerId) {
        const list = await OsbodiesModel.findAll({ where: { osHeaderId: headerId } });
        return list;
    }

    /** создать запись в таблице "osbodies" */
    async createRecord(payload) {
        const data = await OsbodiesModel.create(payload);
        return data;
    }

    /** обновить запись в таблице "osbodies" */
    async updateRecord(payload) {
        let record = await OsbodiesModel.findOne({ where: { id: payload.id } });
        if (record) {
            record.osHeaderId = payload?.osHeaderId || record.osHeaderId;
            record.productId = payload?.productId || record.productId;
            record.inventoryNum = payload?.inventoryNum || record.inventoryNum;
            record.cost = payload?.cost || record.cost;
            record.debet = payload?.debet || record.debet;
            record.credit = payload?.credit || record.credit;
            record.journalNum = payload?.journalNum || record.journalNum;
            return await record.save();
        }
        throw new Error('Record not found');
    }

    /** удалить запись из таблицы "osbodies" */
    async removeRecord(recordId) {
        const record = await OsbodiesModel.destroy({ where: { id: recordId } });
        return record;
    }
}

module.exports = new OsbodiesService();
```

### Объяснения

- **Методы сервиса**:
  - `getAllHeadersRecords(headerId)`: Возвращает все записи из таблицы `osbodies`, относящиеся к заданному `osHeaderId`.
  - `createRecord(payload)`: Создает новую запись на основе данных, переданных в `payload`.
  - `updateRecord(payload)`: Ищет запись по `id` и обновляет поля, если они указаны в `payload`.
  - `removeRecord(recordId)`: Удаляет запись по `id` из таблицы `osbodies`.

- **Обновление полей**: В методе `updateRecord`, как и в предыдущих примерах, проверяется существование записи перед изменением. Если запись не найдена, выбрасывается ошибка.

Теперь у вас есть `OsbodiesService`, который реализует основные CRUD методы для работы с моделью `OsbodiesModel`.