storemw-core-api 1.0.0

package/dist/services/injection_field/InjectionFieldService.d.ts

@@ -0,0 +1,137 @@
+import { UserInjectionFieldReplaceProps, UserInjectionFieldModuleRef } from "./UserInjectionFieldService";
+import { ItemInjectionFieldReplaceProps, ItemInjectionFieldModuleRef } from "./ItemInjectionFieldService";
+import { RepositoryInjectionFieldReplaceProps, RepositoryInjectionFieldModuleRef } from "./RepositoryInjectionFieldService";
+import { LogisticInjectionFieldReplaceProps, LogisticInjectionFieldModuleRef } from "./LogisticInjectionFieldService";
+import { DocumentInjectionFieldReplaceProps, DocumentInjectionFieldModuleRef } from "./DocumentInjectionFieldService";
+import { QueryList, QueryGet } from "../../schema/common";
+import { DefaultServiceProps } from "../../utils";
+export declare const injectionFieldTypes: {
+    readonly user: "user";
+    readonly item: "item";
+    readonly document: "document";
+    readonly repository: "repository";
+    readonly logistic: "logistic";
+};
+export type InjectionFieldType = typeof injectionFieldTypes[keyof typeof injectionFieldTypes];
+export declare const injectionFieldDataTypes: {
+    readonly id: "id";
+    readonly value: "value";
+    readonly numeric: "numeric";
+    readonly integer: "integer";
+    readonly timestamp: "timestamp";
+    readonly date: "date";
+    readonly date_time: "date_time";
+    readonly text: "text";
+};
+export type InjectionFieldDataType = typeof injectionFieldDataTypes[keyof typeof injectionFieldDataTypes];
+declare const modulePrefixMap: {
+    transporter: string;
+    product: string;
+    item: string;
+    category: string;
+    brand: string;
+    uom: string;
+    container: string;
+    package: string;
+    sales: string;
+    delivery: string;
+    cash_sales: string;
+    proforma_sales: string;
+    retail_cash_sales: string;
+    replacement_delivery_order: string;
+    trip: string;
+    administrator: string;
+    customer: string;
+    worker: string;
+    supplier: string;
+    driver: string;
+    retailer: string;
+    member: string;
+};
+declare const refPrefixMap: {
+    logistic: string;
+    item: string;
+    repository: string;
+    repository_item: string;
+    document: string;
+    document_item: string;
+    branch: string;
+    user: string;
+};
+export type InjectionFieldServiceProps = DefaultServiceProps & {
+    injectionFieldType: InjectionFieldType;
+};
+export type InjectionFieldGetProps = QueryGet & {
+    id: number;
+};
+export type InjectionFieldListProps = QueryList & {};
+export type InjectionFieldRemoveProps = {
+    injectionFieldIds: BigInt[];
+};
+type RenameModuleRef<T extends {
+    module: any;
+    ref: any;
+}> = T extends any ? {
+    field_module: T["module"];
+    field_ref: T["ref"];
+} : never;
+export type InjectionFieldModuleRef = (RenameModuleRef<UserInjectionFieldModuleRef | ItemInjectionFieldModuleRef | DocumentInjectionFieldModuleRef | RepositoryInjectionFieldModuleRef | LogisticInjectionFieldModuleRef>);
+export type InjectionFieldCreateProps = {
+    data: InjectionFieldModuleRef & {
+        field_key: string;
+        field_type: InjectionFieldDataType;
+        is_multiple: false;
+        multiple_count: false;
+        merge_multiple_inline: false;
+    };
+};
+export type InjectionFieldReplaceProps = {
+    injectionFieldType?: InjectionFieldType;
+    data: UserInjectionFieldReplaceProps["data"] | ItemInjectionFieldReplaceProps["data"] | DocumentInjectionFieldReplaceProps["data"] | RepositoryInjectionFieldReplaceProps["data"] | LogisticInjectionFieldReplaceProps["data"];
+};
+export declare const InjectionFieldService: (props: InjectionFieldServiceProps) => {
+    createInjectionField: ({ data }: InjectionFieldCreateProps) => Promise<{
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        injection_field_id: bigint;
+        field_module: string | null;
+        field_ref: string | null;
+        field_key: string | null;
+        field_name: string | null;
+        field_type: string | null;
+        is_multiple: bigint | null;
+        multiple_count: bigint | null;
+        merge_multiple_inline: bigint;
+    }>;
+    getInjectionField: ({ id, datatypes }: InjectionFieldGetProps) => Promise<any>;
+    replaceInjectionField: ({ data, injectionFieldType: overrideInjectionFieldType }: InjectionFieldReplaceProps) => Promise<any>;
+    listInjectionFields: ({ limit, offset, filters, sortfield, sortorder, datatypes }: InjectionFieldListProps) => Promise<{
+        data: any[];
+        total: number;
+    }>;
+    removeInjectionFields: ({ injectionFieldIds }: InjectionFieldRemoveProps) => Promise<{
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        injection_field_id: bigint;
+        field_module: string | null;
+        field_ref: string | null;
+        field_key: string | null;
+        field_name: string | null;
+        field_type: string | null;
+        is_multiple: bigint | null;
+        multiple_count: bigint | null;
+        merge_multiple_inline: bigint;
+    }[]>;
+    listActiveInjectionFields: (fieldRef: keyof typeof refPrefixMap, fieldModule: keyof typeof modulePrefixMap) => Promise<any[]>;
+};
+export {};

package/dist/services/injection_field/InjectionFieldService.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectionFieldService = exports.injectionFieldDataTypes = exports.injectionFieldTypes = void 0;
+const utils_1 = require("../../utils");
+const models_1 = require("../../models");
+const UserInjectionFieldService_1 = require("./UserInjectionFieldService");
+const ItemInjectionFieldService_1 = require("./ItemInjectionFieldService");
+const RepositoryInjectionFieldService_1 = require("./RepositoryInjectionFieldService");
+const LogisticInjectionFieldService_1 = require("./LogisticInjectionFieldService");
+const DocumentInjectionFieldService_1 = require("./DocumentInjectionFieldService");
+const utils_2 = require("../../utils");
+const utils_3 = require("../../utils");
+exports.injectionFieldTypes = {
+    user: "user",
+    item: "item",
+    document: "document",
+    repository: "repository",
+    logistic: "logistic",
+};
+exports.injectionFieldDataTypes = {
+    id: "id",
+    value: "value",
+    numeric: "numeric",
+    integer: "integer",
+    timestamp: "timestamp",
+    date: "date",
+    date_time: "date_time",
+    text: "text"
+};
+const modulePrefixMap = {
+    ...UserInjectionFieldService_1.userModulePrefixMap,
+    ...DocumentInjectionFieldService_1.documentModulePrefixMap,
+    ...RepositoryInjectionFieldService_1.repositoryModulePrefixMap,
+    ...ItemInjectionFieldService_1.itemModulePrefixMap,
+    ...LogisticInjectionFieldService_1.logisticModulePrefixMap
+};
+const refPrefixMap = {
+    ...UserInjectionFieldService_1.userRefPrefixMap,
+    ...DocumentInjectionFieldService_1.documentRefPrefixMap,
+    ...RepositoryInjectionFieldService_1.repositoryRefPrefixMap,
+    ...ItemInjectionFieldService_1.itemRefPrefixMap,
+    ...LogisticInjectionFieldService_1.logisticRefPrefixMap
+};
+// sample
+let c = {
+    data: {
+        field_ref: "item",
+        field_module: "product",
+        field_type: "date",
+        field_key: "aaa",
+        // field_name: "sdfds",
+        is_multiple: false,
+        merge_multiple_inline: false,
+        multiple_count: false
+    }
+};
+const getCreatePayload = (data, fieldName) => {
+    return {
+        [`${models_1.ModelInjectionFieldFields.field_key}`]: data.field_key,
+        [`${models_1.ModelInjectionFieldFields.field_module}`]: data.field_module,
+        [`${models_1.ModelInjectionFieldFields.field_name}`]: `${fieldName}`,
+        [`${models_1.ModelInjectionFieldFields.field_ref}`]: data.field_ref,
+        [`${models_1.ModelInjectionFieldFields.field_type}`]: data.field_type,
+        [`${models_1.ModelInjectionFieldFields.is_multiple}`]: 0,
+        [`${models_1.ModelInjectionFieldFields.multiple_count}`]: 0,
+        [`${models_1.ModelInjectionFieldFields.merge_multiple_inline}`]: 0,
+    };
+};
+let mainSqlSelect = {
+    [`injf.${models_1.ModelInjectionFieldFields.field_key}`]: "field_key",
+    [`injf.${models_1.ModelInjectionFieldFields.field_module}`]: "field_module",
+    [`injf.${models_1.ModelInjectionFieldFields.field_name}`]: "field_name",
+    [`injf.${models_1.ModelInjectionFieldFields.field_ref}`]: "field_ref",
+    [`injf.${models_1.ModelInjectionFieldFields.field_type}`]: "field_type",
+    [`injf.${models_1.ModelInjectionFieldFields.injection_field_id}`]: "injection_field_id",
+    [`injf.${models_1.ModelInjectionFieldFields.is_multiple}`]: "is_multiple",
+    [`injf.${models_1.ModelInjectionFieldFields.merge_multiple_inline}`]: "merge_multiple_inline",
+    [`injf.${models_1.ModelInjectionFieldFields.multiple_count}`]: "multiple_count"
+};
+let defaultSqlSelect = {
+    [`injf.${models_1.ModelInjectionFieldFields.createdatetime}`]: "createdatetime",
+    [`creator.${models_1.ModelUserFields.login_username}`]: "createusername",
+    [`injf.${models_1.ModelInjectionFieldFields.updatedatetime}`]: "updatedatetime",
+    [`updater.${models_1.ModelUserFields.login_username}`]: "updateusername",
+    [`injf.${models_1.ModelInjectionFieldFields.isdelete}`]: "isdelete",
+    [`injf.${models_1.ModelInjectionFieldFields.istrash}`]: "istrash",
+    [`injf.${models_1.ModelInjectionFieldFields.accountid}`]: "accountid",
+};
+const getTargetTableName = (fieldRef) => {
+    let targetTableName = ``;
+    if (fieldRef in UserInjectionFieldService_1.userRefPrefixMap) {
+        targetTableName = "user_injection_fields";
+    }
+    if (fieldRef in DocumentInjectionFieldService_1.documentRefPrefixMap) {
+        targetTableName = "document_injection_fields";
+    }
+    if (fieldRef in ItemInjectionFieldService_1.itemRefPrefixMap) {
+        targetTableName = "item_injection_fields";
+    }
+    if (fieldRef in LogisticInjectionFieldService_1.logisticRefPrefixMap) {
+        targetTableName = "logistic_injection_fields";
+    }
+    if (fieldRef in RepositoryInjectionFieldService_1.repositoryRefPrefixMap) {
+        targetTableName = "repository_injection_fields";
+    }
+    return targetTableName;
+};
+const InjectionFieldService = (props) => {
+    const { prisma, injectionFieldType = "user", accountId = 0, actionUserId = 0, } = props;
+    const injectionFieldModel = (0, models_1.InjectionFieldModel)({ prisma, accountId, actionUserId });
+    const userInjectionFieldService = (0, UserInjectionFieldService_1.UserInjectionFieldService)({ prisma, accountId, actionUserId });
+    const documentInjectionFieldService = (0, DocumentInjectionFieldService_1.DocumentInjectionFieldService)({ prisma, accountId, actionUserId });
+    const repositoryInjectionFieldService = (0, RepositoryInjectionFieldService_1.RepositoryInjectionFieldService)({ prisma, accountId, actionUserId });
+    const logisticInjectionFieldService = (0, LogisticInjectionFieldService_1.LogisticInjectionFieldService)({ prisma, accountId, actionUserId });
+    const itemInjectionFieldService = (0, ItemInjectionFieldService_1.ItemInjectionFieldService)({ prisma, accountId, actionUserId });
+    const createInjectionField = async ({ data }) => {
+        const fieldName = (0, utils_3.buildFullFieldName)(`${data.field_ref}`, `${data.field_module}`, `${data.field_key}`, refPrefixMap, modulePrefixMap);
+        // have to check the record exists
+        const existing = await listInjectionFields({
+            offset: 0,
+            limit: 1,
+            sortfield: `${models_1.ModelInjectionFieldFields.injection_field_id}`,
+            sortorder: "ASC",
+            filters: [{
+                    field: `${models_1.ModelInjectionFieldFields.field_name}`,
+                    operator: '=',
+                    value: `${fieldName}`
+                }],
+            datatypes: []
+        });
+        if (existing.data.length > 0) {
+            throw new Error(`Duplicated injection field name found : ${fieldName}`);
+        }
+        const _data = getCreatePayload(data, fieldName);
+        if (!_data) {
+            throw new Error(`Invalid create injection field payload: ${JSON.stringify(_data)}`);
+        }
+        let response = await injectionFieldModel.create({ data: _data });
+        let fieldRef = response?.field_ref ?? "";
+        if (fieldRef) {
+            let targetTableName = getTargetTableName(fieldRef);
+            // after create record - create physical table fields
+            injectionFieldModel.createInjectionFieldIntoTable(targetTableName, fieldName, data.field_type);
+        }
+        return response;
+    };
+    const getInjectionField = async ({ id, datatypes = [] }) => {
+        let { data } = await listInjectionFields({
+            limit: 1,
+            offset: 0,
+            filters: [{ field: `${models_1.ModelInjectionFieldFields.injection_field_id}`, operator: "=", value: id }],
+            sortfield: `${models_1.ModelInjectionFieldFields.injection_field_id}`,
+            sortorder: "ASC",
+            datatypes
+        });
+        return data[0] ?? null;
+    };
+    const listInjectionFields = async ({ limit, offset, filters, sortfield, sortorder, datatypes = [] }) => {
+        let data = [];
+        let sqlSelect = [
+            `COUNT(injf.*) OVER() as filtered_count`,
+            (0, utils_2.buildSqlSelect)(``, mainSqlSelect),
+            (0, utils_2.buildSqlSelect)(``, defaultSqlSelect)
+        ];
+        let sqlRelation = [
+            (0, utils_2.buildSqlRelation)("left", "injf", "users", "creator", ["injf.createuserid = creator.user_id", "creator.isdelete = false", "creator.istrash = false"]),
+            (0, utils_2.buildSqlRelation)("left", "injf", "users", "updater", ["injf.updateuserid = updater.user_id", "updater.isdelete = false", "updater.istrash = false"])
+        ];
+        let sqlGroupBy = [...Object.keys(mainSqlSelect), ...Object.keys(defaultSqlSelect)];
+        let filterColumns = { ...mainSqlSelect, ...defaultSqlSelect };
+        let sqlWhere = [
+            `injf.isdelete = false`,
+            `injf.istrash = false`,
+            ...(filters.length ? [(0, utils_2.buildSqlWhere)(filters, filterColumns)] : []),
+        ];
+        let sqlOrderby = (0, utils_2.buildSqlOrderBy)(sortfield, sortorder);
+        let sqlLimitOffset = (0, utils_2.buildSqlLimitOffset)(limit, offset);
+        const sqlRaw = (0, utils_2.buildSqlRawSelect)({
+            tableName: "injection_fields",
+            mainAlias: "injf",
+            accountId,
+            sqlSelect,
+            sqlRelation,
+            sqlWhere,
+            sqlGroupBy,
+            sqlOrderby,
+            sqlLimitOffset
+        });
+        data = await injectionFieldModel.raw(sqlRaw);
+        const response = {
+            data: data.map(({ filtered_count, ...rest }) => rest),
+            total: data.length ? Number(data[0].filtered_count) : 0
+        };
+        return response;
+    };
+    const replaceInjectionField = async ({ data, injectionFieldType: overrideInjectionFieldType }) => {
+        const _injectionFieldType = overrideInjectionFieldType || injectionFieldType;
+        const _data = data;
+        if (!_data) {
+            throw new Error(`Invalid create payload: ${JSON.stringify(_data)}`);
+        }
+        let response = {};
+        if (_injectionFieldType === "user") {
+            response = await userInjectionFieldService.replaceUserInjectionField({ data: _data });
+        }
+        if (_injectionFieldType === "document") {
+            response = await documentInjectionFieldService.replaceDocumentInjectionField({ data: _data });
+        }
+        if (_injectionFieldType === "item") {
+            response = await itemInjectionFieldService.replaceItemInjectionField({ data: _data });
+        }
+        if (_injectionFieldType === "repository") {
+            response = await repositoryInjectionFieldService.replaceRepositoryInjectionField({ data: _data });
+        }
+        if (_injectionFieldType === "logistic") {
+            response = await logisticInjectionFieldService.replaceLogisticInjectionField({ data: _data });
+        }
+        return response;
+    };
+    const removeInjectionFields = async ({ injectionFieldIds }) => {
+        if (!injectionFieldIds.length)
+            (0, utils_1.throwError)('injectionFieldIds is required');
+        await Promise.all(injectionFieldIds.map(async (id) => {
+            // suspend the field in table
+            const current = await getInjectionField({ id: Number(id), datatypes: [] });
+            const currentFieldName = current?.field_name ?? "";
+            let fieldRef = current?.field_ref ?? "";
+            let targetTableName = getTargetTableName(fieldRef);
+            if (currentFieldName) {
+                await injectionFieldModel.suspendInjectionFieldFromTable(targetTableName, currentFieldName);
+            }
+        }));
+        const response = await injectionFieldModel.remove({ where: { [`${models_1.ModelInjectionFieldFields.injection_field_id}`]: { in: injectionFieldIds } } });
+        return response;
+    };
+    const listActiveInjectionFields = async (fieldRef, fieldModule) => {
+        // const _injectionFieldType = overrideInjectionFieldType || injectionFieldType
+        // let current: any = []
+        // if (_injectionFieldType === injectionFieldTypes.item) {
+        //     const injectionFieldModel = ItemInjectionFieldModel({ prisma, accountId, actionUserId })
+        //     current = await injectionFieldModel.getFields('', ["removed_"])
+        // }
+        let { data } = await listInjectionFields({
+            limit: 100,
+            offset: 0,
+            filters: [
+                { field: `${models_1.ModelInjectionFieldFields.field_ref}`, operator: "=", value: fieldRef },
+                { field: `${models_1.ModelInjectionFieldFields.field_module}`, operator: "=", value: fieldModule },
+            ],
+            sortfield: `${models_1.ModelInjectionFieldFields.injection_field_id}`,
+            sortorder: "ASC",
+            datatypes: []
+        });
+        // return data[0] ?? null;
+        return data.map(i => i.field_name);
+    };
+    return {
+        createInjectionField,
+        getInjectionField,
+        replaceInjectionField,
+        listInjectionFields,
+        removeInjectionFields,
+        listActiveInjectionFields,
+    };
+};
+exports.InjectionFieldService = InjectionFieldService;

package/dist/services/injection_field/ItemInjectionFieldService.d.ts

@@ -0,0 +1,92 @@
+import { DefaultServiceProps } from "../../utils";
+type ItemInjectionFieldMap = {
+    product: {
+        item: {
+            itemId: any;
+        };
+    };
+    item: {
+        item: {
+            itemId: any;
+        };
+    };
+    brand: {
+        item: {
+            itemId: any;
+        };
+    };
+    category: {
+        item: {
+            itemId: any;
+        };
+    };
+    uom: {
+        item: {
+            itemId: any;
+        };
+    };
+};
+type ItemInjectionFieldModule = keyof ItemInjectionFieldMap;
+export declare const itemModulePrefixMap: Record<ItemInjectionFieldModule, string>;
+export declare const itemRefPrefixMap: Record<"item", string>;
+export type ItemInjectionFieldModuleRef = {
+    [M in ItemInjectionFieldModule]: {
+        [R in keyof ItemInjectionFieldMap[M]]: {
+            module: M;
+            ref: R;
+        } & ItemInjectionFieldMap[M][R];
+    }[keyof ItemInjectionFieldMap[M]];
+}[ItemInjectionFieldModule];
+export type ItemInjectionFieldServiceProps = DefaultServiceProps & {};
+export type ItemInjectionFieldRemoveProps = {
+    ids: number[];
+};
+export type ItemInjectionFieldReplaceProps = {
+    data: ItemInjectionFieldModuleRef & {
+        fields: any;
+    };
+};
+export declare const ItemInjectionFieldService: (props: ItemInjectionFieldServiceProps) => {
+    replaceItemInjectionField: ({ data }: ItemInjectionFieldReplaceProps) => Promise<{
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        field_module: string | null;
+        field_ref: string | null;
+        item_injection_field_id: bigint;
+        item_id: bigint;
+        item_uid_id: bigint;
+        product_id: bigint;
+        category_id: bigint;
+        brand_id: bigint;
+        uom_id: bigint;
+        itm_itm_inttest: bigint | null;
+        itm_itm_id1: bigint | null;
+        itm_itm_value1: string | null;
+        itm_itm_date1: Date | null;
+        itm_itm_text1_bk_20: string;
+        itm_itm_num1_bk_21: import("../../generated/prisma/runtime/library").Decimal;
+        itm_itm_inttest123: bigint | null;
+        itm_itm_inttest1234: bigint | null;
+        itm_itm_inttest12345: bigint | null;
+        itm_itm_inttest123456: bigint | null;
+        itm_itm_inttest08: bigint | null;
+        itm_itm_inttest1234756: bigint | null;
+        itm_itm_test123: bigint | null;
+        itm_itm_test1234: bigint | null;
+        itm_itm_pack_qty: bigint | null;
+        itm_prt_pack_qty2: bigint | null;
+        itm_itm_test008: bigint | null;
+        itm_prt_pack_qty10: bigint | null;
+        itm_prt_50: import("../../generated/prisma/runtime/library").Decimal | null;
+        itm_prt_500: import("../../generated/prisma/runtime/library").Decimal | null;
+        itm_prt_rtdsfsdf_bk_37: string;
+        yes_bk_38: bigint;
+        itm_itm_customer_marking: string | null;
+    }>;
+};
+export {};

package/dist/services/injection_field/ItemInjectionFieldService.js

@@ -0,0 +1,68 @@
+"use strict";
+// import { logError, throwError } from "../../utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ItemInjectionFieldService = exports.itemRefPrefixMap = exports.itemModulePrefixMap = void 0;
+const models_1 = require("../../models");
+const utils_1 = require("../../utils");
+// type ItemInjectionFieldRef<M extends ItemInjectionFieldModule> = keyof ItemInjectionFieldMap[M];
+exports.itemModulePrefixMap = {
+    product: "prt",
+    item: "itm",
+    brand: "brd",
+    category: "ct",
+    uom: "uom"
+};
+exports.itemRefPrefixMap = {
+    item: "itm",
+};
+const getReplacePayload = (data) => {
+    let { module, ref, itemId } = data;
+    let payload = {};
+    payload = {
+        ...payload,
+        ...{
+            [`${models_1.ModelItemInjectionFieldFields.field_module}`]: module,
+            [`${models_1.ModelItemInjectionFieldFields.field_ref}`]: ref,
+        }
+    };
+    if ("itemId" in data) {
+        payload = { ...payload, ...(data?.itemId ? { [`${models_1.ModelItemInjectionFieldFields.item_id}`]: itemId } : {}) };
+    }
+    const rest = data.fields;
+    // apply dynamic prefix: refPrefix_modulePrefix_fieldKey
+    const refPrefix = exports.itemRefPrefixMap[ref] ?? ref;
+    const modulePrefix = exports.itemModulePrefixMap[module] ?? module;
+    for (const [key, value] of Object.entries(rest)) {
+        payload[`${refPrefix}_${modulePrefix}_${key}`] = value;
+    }
+    return payload;
+};
+const ItemInjectionFieldService = (props) => {
+    const { prisma, accountId = 0, actionUserId = 0 } = props;
+    const itemInjectionFieldModel = (0, models_1.ItemInjectionFieldModel)({ prisma, accountId, actionUserId });
+    const replaceItemInjectionField = async ({ data }) => {
+        const _data = getReplacePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid create payload: ${JSON.stringify(_data)}`);
+        }
+        const where = {
+            [models_1.ModelItemInjectionFieldFields.field_module]: data.module,
+            [models_1.ModelItemInjectionFieldFields.field_ref]: data.ref,
+            ...(data?.itemId ? { [models_1.ModelItemInjectionFieldFields.item_id]: data.itemId } : {}),
+        };
+        // Narrow: only include branchId if data.ref === "branch"
+        // if (data.ref === "branch") {
+        //     where[ModelItemInjectionFieldFields.branch_id] = (data as Extract<ItemInjectionFieldModuleRef, { ref: "branch" }>).branchId;
+        // }
+        let modelFields = await itemInjectionFieldModel.getFields();
+        let finalData = (0, utils_1.convertPayloadByTableSchema)(_data, modelFields);
+        console.log('modelFields', modelFields);
+        console.log('finalData', finalData);
+        const response = await itemInjectionFieldModel.update({ data: finalData, where });
+        return response;
+    };
+    return {
+        replaceItemInjectionField
+    };
+};
+exports.ItemInjectionFieldService = ItemInjectionFieldService;

package/dist/services/injection_field/LogisticInjectionFieldService.d.ts

@@ -0,0 +1,45 @@
+import { DefaultServiceProps } from "../../utils";
+type LogisticInjectionFieldMap = {
+    transporter: {
+        logistic: {
+            logisticId: any;
+        };
+    };
+};
+type LogisticInjectionFieldModule = keyof LogisticInjectionFieldMap;
+export declare const logisticModulePrefixMap: Record<LogisticInjectionFieldModule, string>;
+export declare const logisticRefPrefixMap: Record<"logistic", string>;
+export type LogisticInjectionFieldModuleRef = {
+    [M in LogisticInjectionFieldModule]: {
+        [R in keyof LogisticInjectionFieldMap[M]]: {
+            module: M;
+            ref: R;
+        } & LogisticInjectionFieldMap[M][R];
+    }[keyof LogisticInjectionFieldMap[M]];
+}[LogisticInjectionFieldModule];
+export type LogisticInjectionFieldServiceProps = DefaultServiceProps & {};
+export type LogisticInjectionFieldRemoveProps = {
+    ids: number[];
+};
+export type LogisticInjectionFieldReplaceProps = {
+    data: LogisticInjectionFieldModuleRef & {
+        fields: any;
+    };
+};
+export declare const LogisticInjectionFieldService: (props: LogisticInjectionFieldServiceProps) => {
+    replaceLogisticInjectionField: ({ data }: LogisticInjectionFieldReplaceProps) => Promise<{
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        field_module: string | null;
+        field_ref: string | null;
+        logistic_injection_field_id: bigint;
+        logistic_id: bigint;
+        lgt_tpt_repo_t3e2s2: import("../../generated/prisma/runtime/library").Decimal | null;
+    }>;
+};
+export {};

package/dist/services/injection_field/LogisticInjectionFieldService.js

@@ -0,0 +1,72 @@
+"use strict";
+// import { logError, throwError } from "../../utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogisticInjectionFieldService = exports.logisticRefPrefixMap = exports.logisticModulePrefixMap = void 0;
+const models_1 = require("../../models");
+const utils_1 = require("../../utils");
+// type LogisticInjectionFieldRef<M extends LogisticInjectionFieldModule> = keyof LogisticInjectionFieldMap[M];
+exports.logisticModulePrefixMap = {
+    transporter: "tpt"
+};
+exports.logisticRefPrefixMap = {
+    logistic: "lgt"
+};
+const getReplacePayload = (data) => {
+    let { module, ref, logisticId } = data;
+    let payload = {};
+    payload = {
+        ...payload,
+        ...{
+            [`${models_1.ModelLogisticInjectionFieldFields.field_module}`]: module,
+            [`${models_1.ModelLogisticInjectionFieldFields.field_ref}`]: ref,
+        }
+    };
+    if ("logisticId" in data) {
+        payload = { ...payload, ...(data?.logisticId ? { [`${models_1.ModelLogisticInjectionFieldFields.logistic_id}`]: logisticId } : {}) };
+    }
+    // if ("branchId" in data) {
+    //     const branchId = data.branchId
+    //     payload = { ...payload, ...(data?.branchId ? { [`${ModelLogisticInjectionFieldFields.branch_id}`]: branchId } : {}) }
+    // }
+    // if ("memberId" in data) {
+    //     const memberId = data.memberId
+    //     payload = { ...payload, ...(data?.memberId ? { [`${ModelLogisticInjectionFieldFields.member_id}`]: memberId } : {}) }
+    // }
+    const rest = data.fields;
+    // apply dynamic prefix: refPrefix_modulePrefix_fieldKey
+    const refPrefix = exports.logisticRefPrefixMap[ref] ?? ref;
+    const modulePrefix = exports.logisticModulePrefixMap[module] ?? module;
+    for (const [key, value] of Object.entries(rest)) {
+        payload[`${refPrefix}_${modulePrefix}_${key}`] = value;
+    }
+    return payload;
+};
+const LogisticInjectionFieldService = (props) => {
+    const { prisma, accountId = 0, actionUserId = 0 } = props;
+    const logisticInjectionFieldModel = (0, models_1.LogisticInjectionFieldModel)({ prisma, accountId, actionUserId });
+    const replaceLogisticInjectionField = async ({ data }) => {
+        const _data = getReplacePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid create payload: ${JSON.stringify(_data)}`);
+        }
+        const where = {
+            [models_1.ModelLogisticInjectionFieldFields.field_module]: data.module,
+            [models_1.ModelLogisticInjectionFieldFields.field_ref]: data.ref,
+            ...(data?.logisticId ? { [models_1.ModelLogisticInjectionFieldFields.logistic_id]: data.logisticId } : {}),
+        };
+        // Narrow: only include branchId if data.ref === "branch"
+        // if (data.ref === "branch") {
+        //     where[ModelLogisticInjectionFieldFields.branch_id] = (data as Extract<LogisticInjectionFieldModuleRef, { ref: "branch" }>).branchId;
+        // }
+        let modelFields = await logisticInjectionFieldModel.getFields();
+        let finalData = (0, utils_1.convertPayloadByTableSchema)(_data, modelFields);
+        console.log('modelFields', modelFields);
+        console.log('finalData', finalData);
+        const response = await logisticInjectionFieldModel.update({ data: finalData, where });
+        return response;
+    };
+    return {
+        replaceLogisticInjectionField
+    };
+};
+exports.LogisticInjectionFieldService = LogisticInjectionFieldService;