@rytass/wms-module-core 0.1.0

package/lib/services/hold-inventory-order.service.js

@@ -0,0 +1,285 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import '../models/metadata/batch.entity.js';
+import '../models/metadata/batch-group.entity.js';
+import '../models/metadata/loader.entity.js';
+import '../models/metadata/loader-type.entity.js';
+import '../models/metadata/loader-unit.entity.js';
+import '../models/metadata/location.entity.js';
+import '../models/metadata/material.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import '../models/metadata/sale-order.entity.js';
+import { StockEntity } from '../models/metadata/stock.entity.js';
+import '../models/metadata/unit.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-item.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-change.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-change.entity.js';
+import '../models/extensions/transfer-order/transfer-order.entity.js';
+import '../models/extensions/transfer-order/transfer-order-item.entity.js';
+import '../models/extensions/transfer-order/transfer-order-change.entity.js';
+import { HoldInventoryOrderEntity } from '../models/extensions/hold-inventory-order/hold-inventory-order.entity.js';
+import { HoldInventoryOrderItemEntity } from '../models/extensions/hold-inventory-order/hold-inventory-order-item.entity.js';
+import { HoldInventoryOrderChangeEntityClass } from '../models/extensions/hold-inventory-order/hold-inventory-order-change.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-item.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-change.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-item.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-change.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-item.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-change.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-item.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-change.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-item.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-change.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-item.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-change.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-change.entity.js';
+import '../models/extensions/scrape-order/scrape-order.entity.js';
+import '../models/extensions/scrape-order/scrape-order-item.entity.js';
+import '../models/extensions/scrape-order/scrape-order-change.entity.js';
+import { DataSource } from 'typeorm';
+import { HelperService } from './helper.service.js';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import { MaterialService } from './material.service.js';
+import { BatchService } from './batch.service.js';
+import { StockService } from './stock.service.js';
+
+let HoldInventoryOrderService = class HoldInventoryOrderService {
+    dataSource;
+    helperService;
+    materialService;
+    batchService;
+    stockService;
+    holdInventoryOrderEntity;
+    holdInventoryOrderItemEntity;
+    stockEntity;
+    seqPrefix = 'HIO';
+    constructor(dataSource, helperService, materialService, batchService, stockService, holdInventoryOrderEntity, holdInventoryOrderItemEntity, stockEntity) {
+        this.dataSource = dataSource;
+        this.helperService = helperService;
+        this.materialService = materialService;
+        this.batchService = batchService;
+        this.stockService = stockService;
+        this.holdInventoryOrderEntity = holdInventoryOrderEntity;
+        this.holdInventoryOrderItemEntity = holdInventoryOrderItemEntity;
+        this.stockEntity = stockEntity;
+    }
+    getRepositories(manager) {
+        return {
+            holdInventoryOrder: manager.getRepository(this.holdInventoryOrderEntity),
+            holdInventoryOrderItem: manager.getRepository(this.holdInventoryOrderItemEntity),
+            holdInventoryOrderChange: manager.getRepository(HoldInventoryOrderChangeEntityClass),
+            stock: manager.getRepository(this.stockEntity),
+            order: manager.getRepository(OrderEntity),
+        };
+    }
+    async processHoldInventoryOrderItems(items, repos, manager) {
+        await Promise.all(items.map(async (data) => {
+            // Ensure required fields are present
+            if (!data.batchId || !data.materialId)
+                return;
+            // Split batch first with held flag to track held state
+            const splittedBatch = await this.batchService.splitBatch({
+                id: data.batchId,
+                held: true,
+                manager,
+            });
+            // Save item with ORIGINAL batch id to maintain source state
+            const item = await repos.holdInventoryOrderItem.save(repos.holdInventoryOrderItem.create(data));
+            const base = await repos.order.save({});
+            const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+            await repos.holdInventoryOrderChange.save(repos.holdInventoryOrderChange.create({
+                itemId: item.id,
+                id: base.id,
+                quantityChanged: item.targetHeldQuantity * conversionFactor,
+            }));
+            // Stock movements track the hold through splitted batch
+            await this.stockService.validateStockAvailability({
+                materialId: item.materialId,
+                batchId: item.batchId,
+                locationId: this.stockService.resolveLocationId(item.locationId),
+                loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                quantity: item.targetHeldQuantity * conversionFactor,
+            }, manager);
+            await repos.stock.save(repos.stock.create([
+                // deduct from original batch available stock
+                {
+                    orderId: base.id,
+                    materialId: item.materialId,
+                    batchId: item.batchId, // original batch
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: -1 * item.targetHeldQuantity * conversionFactor,
+                },
+                // add to splitted batch in held state
+                {
+                    orderId: base.id,
+                    materialId: item.materialId,
+                    batchId: splittedBatch.id, // splitted batch marked held
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: item.targetHeldQuantity * conversionFactor,
+                },
+            ]));
+        }));
+    }
+    async createHoldInventoryOrder(options, manager = this.dataSource.manager) {
+        const repos = this.getRepositories(manager);
+        const { items, ...orderOptions } = options;
+        const key = await this.helperService.getSeq(this.seqPrefix, manager);
+        const order = await repos.holdInventoryOrder.save(repos.holdInventoryOrder.create({ key, ...orderOptions }));
+        if (items?.length > 0) {
+            const processedItems = items.map((item) => ({
+                ...item,
+                orderId: order.id,
+            }));
+            await this.processHoldInventoryOrderItems(processedItems, repos, manager);
+        }
+        return order;
+    }
+    async updateHoldInventoryOrder({ id, manager = this.dataSource.manager, ...options }) {
+        const repos = this.getRepositories(manager);
+        const { items, ...orderOptions } = options;
+        const order = await repos.holdInventoryOrder.findOneBy({ id });
+        const updated = await repos.holdInventoryOrder.save({
+            ...order,
+            ...orderOptions,
+        });
+        if (items?.length) {
+            const existingItemIds = new Set((await repos.holdInventoryOrderItem.find({ where: { orderId: id } })).map((i) => i.id));
+            const newItems = [];
+            const existingItems = [];
+            items.forEach((item) => {
+                if (item.removedAt)
+                    return;
+                if (!item.id)
+                    newItems.push({ ...item, orderId: id });
+                else if (existingItemIds.has(item.id))
+                    existingItems.push({ ...item, orderId: id });
+            });
+            if (newItems.length)
+                await this.processHoldInventoryOrderItems(newItems, repos, manager);
+            if (existingItems.length)
+                await repos.holdInventoryOrderItem.save(await Promise.all(existingItems.map((item) => repos.holdInventoryOrderItem.create(item))));
+        }
+        return updated;
+    }
+    findMany(options) {
+        const queryBuilder = this.dataSource
+            .getRepository(this.holdInventoryOrderEntity)
+            .createQueryBuilder('to');
+        if (options.key)
+            queryBuilder.andWhere('to.key ILIKE :key', { key: `%${options.key}%` });
+        if (options.dateRange)
+            queryBuilder.andWhere('to.createdAt BETWEEN :start AND :end', {
+                start: options.dateRange.from,
+                end: options.dateRange.to,
+            });
+        if (options.materialId)
+            queryBuilder.innerJoin('to.items', 'm_items', 'm_items.materialId = :materialId', {
+                materialId: options.materialId,
+            });
+        if (options.batchId)
+            queryBuilder.innerJoin('to.items', 'b_items', 'b_items.batchId = :batchId', {
+                batchId: options.batchId,
+            });
+        if (options.locationId)
+            queryBuilder.innerJoin('to.items', 'l_items', 'l_items.locationId = :locationId', {
+                locationId: options.locationId,
+            });
+        if (options.loaderId)
+            queryBuilder.innerJoin('to.items', 'ld_items', 'ld_items.loaderId = :loaderId', {
+                loaderId: options.loaderId,
+            });
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        return queryBuilder.getManyAndCount();
+    }
+    async release(options, manager = this.dataSource.manager) {
+        if (!Array.isArray(options))
+            options = [options];
+        const repos = this.getRepositories(manager);
+        const key = await this.helperService.getSeq(this.seqPrefix, manager);
+        const order = await repos.holdInventoryOrder.save(repos.holdInventoryOrder.create({ key }));
+        if (options.length > 0) {
+            await Promise.all(options.map(async (data) => {
+                // Ensure required fields are present
+                if (!data.batchId || !data.materialId)
+                    return;
+                const splittedBatch = await this.batchService.splitBatch({
+                    id: data.batchId,
+                    held: false, // split to release the hold
+                    manager,
+                });
+                // Save item with ORIGINAL batch id to maintain source state
+                const item = await repos.holdInventoryOrderItem.save(repos.holdInventoryOrderItem.create({
+                    ...data,
+                    targetHeldQuantity: -1 * data.quantity,
+                    orderId: order.id,
+                }));
+                const base = await repos.order.save({});
+                const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+                const change = await repos.holdInventoryOrderChange.save(repos.holdInventoryOrderChange.create({
+                    itemId: item.id,
+                    id: base.id,
+                    quantityChanged: -1 * item.targetHeldQuantity * conversionFactor,
+                }));
+                // Stock movements track the hold through splitted batch
+                await this.stockService.validateStockAvailability({
+                    materialId: item.materialId,
+                    batchId: item.batchId,
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: change.quantityChanged,
+                }, manager);
+                await repos.stock.save(repos.stock.create([
+                    // deduct from original batch available stock
+                    {
+                        orderId: base.id,
+                        materialId: item.materialId,
+                        batchId: item.batchId, // original batch
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: -1 * change.quantityChanged,
+                    },
+                    // add to splitted batch in released state
+                    {
+                        orderId: base.id,
+                        materialId: item.materialId,
+                        batchId: splittedBatch.id, // splitted batch marked released
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: change.quantityChanged,
+                    },
+                ]));
+            }));
+        }
+        return order;
+    }
+};
+HoldInventoryOrderService = __decorate([
+    Injectable(),
+    __param(5, Inject(HoldInventoryOrderEntity)),
+    __param(6, Inject(HoldInventoryOrderItemEntity)),
+    __param(7, Inject(StockEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        HelperService,
+        MaterialService,
+        BatchService,
+        StockService, Object, Object, Object])
+], HoldInventoryOrderService);
+
+export { HoldInventoryOrderService };

package/lib/services/index.d.ts

@@ -0,0 +1,22 @@
+export * from './stock.service';
+export * from './loader.service';
+export * from './material.service';
+export * from './batch.service';
+export * from './receive-inventory-order.service';
+export * from './ship-inventory-order.service';
+export * from './location.service';
+export * from './unit.service';
+export * from './transfer-order.service';
+export * from './hold-inventory-order.service';
+export * from './allocate-inventory-order.service';
+export * from './split-batch-order.service';
+export * from './merge-batch-order.service';
+export * from './reclassify-inventory-order.service';
+export * from './transfer-vendor-order.service';
+export * from './quality-inspection-order.service';
+export * from './transfer-customer-order.service';
+export * from './hold-inventory-order.service';
+export * from './sale-order.service';
+export * from './scrape.service';
+export * from './warehouse-map.service';
+export * from './helper.service';

package/lib/services/loader.service.d.ts

@@ -0,0 +1,43 @@
+import { EntityManager, type EntityTarget, Repository, DataSource } from 'typeorm';
+import { LoadersEntityClass } from '../models/metadata/loader.entity';
+import { LoaderTypeEntityClass } from '../models/metadata/loader-type.entity';
+import { CreateLoaderInput, UpdateLoaderInput } from '../typings/create-loader.input';
+import { CreateLoaderTypeInput, UpdateLoaderTypeInput } from '../typings/create-loader-type.input';
+import { FindLoaderInput, FindLoaderTypeInput } from '../typings/find-loader.input';
+import { LoaderUnitEntityClass } from '../models';
+/**
+ * Service for managing loaders and their types
+ * Supports dynamic entity injection for customization
+ * T - Loader entity type
+ * K - Loader Type entity type
+ */
+export declare class LoaderService<T extends LoadersEntityClass = LoadersEntityClass, K extends LoaderTypeEntityClass = LoaderTypeEntityClass> {
+    private readonly dataSource;
+    readonly loaderEntity: EntityTarget<T>;
+    readonly loaderTypeEntity: EntityTarget<K>;
+    readonly loaderUnitEntity: EntityTarget<LoaderUnitEntityClass>;
+    readonly loaderRepository: Repository<T>;
+    readonly loaderTypeRepository: Repository<K>;
+    readonly loaderUnitRepository: Repository<LoaderUnitEntityClass>;
+    readonly loaderSerialMaxDigits = 4;
+    constructor(dataSource: DataSource, loaderEntity: EntityTarget<T>, loaderTypeEntity: EntityTarget<K>, loaderUnitEntity: EntityTarget<LoaderUnitEntityClass>);
+    createLoader({ manager, ...options }: CreateLoaderInput & {
+        manager?: EntityManager;
+    }): Promise<T[]>;
+    createBatchLoaders({ options, manager, }: {
+        options: CreateLoaderInput[];
+        manager?: EntityManager;
+    }): Promise<T[]>;
+    updateLoader({ id, manager, ...options }: UpdateLoaderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    createLoaderType({ manager, ...options }: CreateLoaderTypeInput & {
+        manager?: EntityManager;
+    }): Promise<K>;
+    updateLoaderType({ id, manager, ...options }: UpdateLoaderTypeInput & {
+        manager?: EntityManager;
+    }): Promise<K>;
+    getSeq(prefix: string, count: number, manager?: EntityManager, maxDigits?: number): Promise<number>;
+    findManyLoaders(options: FindLoaderInput<T>): Promise<[T[], number]>;
+    findManyLoaderTypes(options: FindLoaderTypeInput<K>): Promise<[K[], number]>;
+}

package/lib/services/loader.service.js

@@ -0,0 +1,282 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { DataSource, In } from 'typeorm';
+import { LoadersEntity } from '../models/metadata/loader.entity.js';
+import { LoaderTypeEntity } from '../models/metadata/loader-type.entity.js';
+import '../models/metadata/batch.entity.js';
+import '../models/metadata/batch-group.entity.js';
+import { LoaderUnitEntity } from '../models/metadata/loader-unit.entity.js';
+import '../models/metadata/location.entity.js';
+import '../models/metadata/material.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import '../models/metadata/sale-order.entity.js';
+import '../models/metadata/stock.entity.js';
+import '../models/metadata/unit.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-item.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-change.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-change.entity.js';
+import '../models/extensions/transfer-order/transfer-order.entity.js';
+import '../models/extensions/transfer-order/transfer-order-item.entity.js';
+import '../models/extensions/transfer-order/transfer-order-change.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order-item.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order-change.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-item.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-change.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-item.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-change.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-item.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-change.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-item.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-change.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-item.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-change.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-item.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-change.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-change.entity.js';
+import '../models/extensions/scrape-order/scrape-order.entity.js';
+import '../models/extensions/scrape-order/scrape-order-item.entity.js';
+import '../models/extensions/scrape-order/scrape-order-change.entity.js';
+
+/**
+ * Service for managing loaders and their types
+ * Supports dynamic entity injection for customization
+ * T - Loader entity type
+ * K - Loader Type entity type
+ */
+let LoaderService = class LoaderService {
+    dataSource;
+    loaderEntity;
+    loaderTypeEntity;
+    loaderUnitEntity;
+    loaderRepository;
+    loaderTypeRepository;
+    loaderUnitRepository;
+    loaderSerialMaxDigits = 4;
+    constructor(dataSource, loaderEntity, loaderTypeEntity, loaderUnitEntity) {
+        this.dataSource = dataSource;
+        this.loaderEntity = loaderEntity;
+        this.loaderTypeEntity = loaderTypeEntity;
+        this.loaderUnitEntity = loaderUnitEntity;
+        this.loaderRepository = this.dataSource.getRepository(this.loaderEntity);
+        this.loaderTypeRepository = this.dataSource.getRepository(this.loaderTypeEntity);
+        this.loaderUnitRepository =
+            this.dataSource.getRepository(this.loaderUnitEntity);
+    }
+    async createLoader({ manager = this.dataSource.manager, ...options }) {
+        const loaderRepository = manager.getRepository(this.loaderEntity);
+        const loaderTypeRepository = manager.getRepository(this.loaderTypeEntity);
+        const { key } = await loaderTypeRepository.findOneByOrFail({
+            id: options.typeId,
+        });
+        const startSeq = await this.getSeq(key, options.quantity, manager);
+        const loaders = [];
+        for (let i = 0; i < options.quantity; i++) {
+            const seqNum = startSeq + i;
+            const paddedSeq = seqNum
+                .toString()
+                .padStart(this.loaderSerialMaxDigits, '0');
+            const loader = loaderRepository.create({
+                ...options,
+                serialId: `${key}${paddedSeq}`,
+            });
+            loaders.push(loader);
+        }
+        return loaderRepository.save(loaders, { chunk: 1000 });
+    }
+    async createBatchLoaders({ options, manager = this.dataSource.manager, }) {
+        if (options.length === 0)
+            return [];
+        const loaderRepository = manager.getRepository(this.loaderEntity);
+        const loaderTypeRepository = manager.getRepository(this.loaderTypeEntity);
+        const typeMap = await loaderTypeRepository
+            .findBy({ id: In(options.map(({ typeId }) => typeId)) })
+            .then((types) => new Map(types.map((t) => [t.id, t])));
+        const loaders = [];
+        await Promise.all(options.map(async (option) => {
+            const loaderType = typeMap.get(option.typeId);
+            if (loaderType) {
+                const { key } = loaderType;
+                const startSeq = await this.getSeq(key, option.quantity, manager);
+                for (let i = 0; i < option.quantity; i++) {
+                    console.log({ startSeq });
+                    const seqNum = startSeq + i;
+                    const paddedSeq = seqNum
+                        .toString()
+                        .padStart(this.loaderSerialMaxDigits, '0');
+                    const loader = loaderRepository.create({
+                        ...option,
+                        serialId: `${key}${paddedSeq}`,
+                    });
+                    loaders.push(loader);
+                }
+            }
+            else
+                return;
+        }));
+        return loaderRepository.save(loaders, { chunk: 1000 });
+    }
+    async updateLoader({ id, manager = this.dataSource.manager, ...options }) {
+        const loadersRepository = manager.getRepository(this.loaderEntity);
+        const loader = await loadersRepository.findOneByOrFail({ id });
+        return loadersRepository.save(loadersRepository.create({
+            ...loader,
+            ...options,
+        }));
+    }
+    createLoaderType({ manager = this.dataSource.manager, ...options }) {
+        const loaderTypeRepository = manager.getRepository(this.loaderTypeEntity);
+        const loaderType = loaderTypeRepository.create(options);
+        return loaderTypeRepository.save(loaderType);
+    }
+    async updateLoaderType({ id, manager = this.dataSource.manager, ...options }) {
+        const loaderTypeRepository = manager.getRepository(this.loaderTypeEntity);
+        const loaderType = await loaderTypeRepository.findOneByOrFail({ id });
+        return loaderTypeRepository.save(loaderTypeRepository.create({
+            ...loaderType,
+            ...options,
+        }));
+    }
+    async getSeq(prefix, count, manager = this.dataSource.manager, maxDigits = this.loaderSerialMaxDigits) {
+        const seqName = `${prefix}_SEQ`;
+        const maxValue = 10 ** maxDigits - 1;
+        let startVal;
+        try {
+            const [{ val }] = await manager.query(`SELECT CURRVAL('"${seqName}"') + 1 AS val`);
+            startVal = parseInt(val, 10);
+        }
+        catch (ex) {
+            const msg = ex.message;
+            if (/does\snot\sexist/.test(msg)) {
+                await manager.query(`CREATE SEQUENCE "${seqName}"`);
+            }
+            else if (!/not\syet\sdefined/.test(msg)) {
+                throw ex;
+            }
+            // Initialize with NEXTVAL
+            const [{ nextval }] = await manager.query(`SELECT NEXTVAL('"${seqName}"') AS nextval`);
+            startVal = parseInt(nextval, 10);
+        }
+        const endVal = startVal + count - 1;
+        if (endVal > maxValue) {
+            throw new Error(`SEQUENCE_OUT_OF_RANGE: ${prefix} exceeds ${maxDigits} digits (max: ${maxValue}, end: ${endVal})`);
+        }
+        await manager.query(`SELECT SETVAL('"${seqName}"', $1)`, [endVal]);
+        return startVal;
+    }
+    findManyLoaders(options) {
+        const queryBuilder = this.dataSource
+            .getRepository(this.loaderEntity)
+            .createQueryBuilder('loader');
+        if (options.typeId)
+            queryBuilder.andWhere('loader."typeId" = :typeId', {
+                typeId: options.typeId,
+            });
+        if (options.typeIds?.length)
+            queryBuilder.andWhere('loader."typeId" IN (:...typeIds)', {
+                typeIds: options.typeIds,
+            });
+        if (options.locationId)
+            queryBuilder.andWhere('loader."locationId" = :locationId', {
+                locationId: options.locationId,
+            });
+        if (options.locationIds?.length)
+            queryBuilder.andWhere('loader."locationId" IN (:...locationIds)', {
+                locationIds: options.locationIds,
+            });
+        if (options.serialId)
+            queryBuilder.andWhere('loader."serialId" = :serialId', {
+                serialId: options.serialId,
+            });
+        if (options.serialIds?.length)
+            queryBuilder.andWhere('loader."serialId" IN (:...serialIds)', {
+                serialIds: options.serialIds,
+            });
+        if (options.isActive !== undefined)
+            queryBuilder.andWhere('loader."isActive" = :isActive', {
+                isActive: options.isActive,
+            });
+        if (options.dateRange)
+            queryBuilder.andWhere('loader."createdAt" BETWEEN :from AND :to', {
+                from: options.dateRange.from,
+                to: options.dateRange.to,
+            });
+        if (options.note)
+            queryBuilder.andWhere('loader.note LIKE :note', {
+                note: `%${options.note}%`,
+            });
+        if (options.locationKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM locations ldr_loc
+          WHERE ldr_loc.id = loader."locationId"
+          AND ldr_loc.key ILIKE :locationKey
+        )`, { locationKey: `%${options.locationKey}%` });
+        if (options.loaderTypeKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM loader_types ldr_type
+          WHERE ldr_type.id = loader."typeId"
+          AND ldr_type.key ILIKE :loaderTypeKey
+        )`, { loaderTypeKey: `%${options.loaderTypeKey}%` });
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`loader."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        return queryBuilder.getManyAndCount();
+    }
+    findManyLoaderTypes(options) {
+        const queryBuilder = this.dataSource
+            .getRepository(this.loaderTypeEntity)
+            .createQueryBuilder('loader_type');
+        if (options.description)
+            queryBuilder.andWhere('loader_type.description ILIKE :description', {
+                description: `%${options.description}%`,
+            });
+        if (options.isActive !== undefined)
+            queryBuilder.andWhere('loader_type."isActive" = :isActive', {
+                isActive: options.isActive,
+            });
+        if (options.dateRange)
+            queryBuilder.andWhere('loader_type."createdAt" BETWEEN :from AND :to', {
+                from: options.dateRange.from,
+                to: options.dateRange.to,
+            });
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`loader_type."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        return queryBuilder.getManyAndCount();
+    }
+};
+LoaderService = __decorate([
+    Injectable(),
+    __param(1, Inject(LoadersEntity)),
+    __param(2, Inject(LoaderTypeEntity)),
+    __param(3, Inject(LoaderUnitEntity)),
+    __metadata("design:paramtypes", [DataSource, Object, Object, Object])
+], LoaderService);
+
+export { LoaderService };

package/lib/services/location.service.d.ts

@@ -0,0 +1,13 @@
+import { DataSource, EntityTarget, Repository } from 'typeorm';
+import { LocationEntityClass } from '../models';
+import { CreateLocationInput, UpdateLocationInput } from '../typings/create-location.input';
+import { FindLocationInput } from '../typings/find-location.input';
+export declare class LocationService<T extends LocationEntityClass = LocationEntityClass> {
+    private readonly dataSource;
+    readonly locationEntity: EntityTarget<T>;
+    readonly locationReposistory: Repository<T>;
+    constructor(dataSource: DataSource, locationEntity: EntityTarget<T>);
+    createLocation({ parentId, ...options }: CreateLocationInput): Promise<T>;
+    updateLocation({ id, parentId, ...options }: UpdateLocationInput): Promise<T>;
+    findMany(options: FindLocationInput<T>): Promise<[T[], number]>;
+}