storemw-core-api 1.0.0

package/dist/services/user/UserService.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = exports.userTypes = void 0;
+const models_1 = require("../../models");
+const UserPropService_1 = require("./UserPropService");
+const CustomerService_1 = require("./CustomerService");
+const AdministratorService_1 = require("./AdministratorService");
+const WorkerService_1 = require("./WorkerService");
+const utils_1 = require("../../utils");
+exports.userTypes = {
+    administrator: "administrator",
+    worker: "worker",
+    supplier: "supplier",
+    customer: "customer",
+    driver: "driver",
+    retailer: "retailer",
+    member: "member",
+};
+const getCreatePayload = (userType, data) => {
+    if ("user" in data) {
+        return {
+            [`${models_1.ModelUserFields.login_username}`]: data.user.loginUsername,
+            [`${models_1.ModelUserFields.login_password}`]: data.user.loginPassword,
+            [`${models_1.ModelUserFields.address}`]: data.user.address,
+            [`${models_1.ModelUserFields.contact}`]: data.user.contact,
+            [`${models_1.ModelUserFields.email}`]: data.user.email,
+            [`${models_1.ModelUserFields.firstname}`]: data.user.firstname,
+            [`${models_1.ModelUserFields.lastname}`]: data.user.lastname,
+            [`${models_1.ModelUserFields.status}`]: data.user.status ? 1 : 0,
+            [`${models_1.ModelUserFields.user_type}`]: `${userType}`
+        };
+    }
+    return false;
+};
+const getUpdatePayload = (userType, data) => {
+    if ("user" in data) {
+        return {
+            [`${models_1.ModelUserFields.login_username}`]: data.user.loginUsername,
+            ...(data?.user?.loginPassword ? { [`${models_1.ModelUserFields.login_password}`]: data.user.loginPassword } : {}),
+            [`${models_1.ModelUserFields.address}`]: data.user.address,
+            [`${models_1.ModelUserFields.contact}`]: data.user.contact,
+            [`${models_1.ModelUserFields.email}`]: data.user.email,
+            [`${models_1.ModelUserFields.firstname}`]: data.user.firstname,
+            [`${models_1.ModelUserFields.lastname}`]: data.user.lastname,
+            [`${models_1.ModelUserFields.status}`]: data.user.status ? 1 : 0,
+            [`${models_1.ModelUserFields.user_type}`]: `${userType}`
+        };
+    }
+    return false;
+};
+const UserService = (props) => {
+    const { prisma, userType = "administrator", accountId = 0, actionUserId = 0, } = props;
+    const userModel = (0, models_1.UserModel)({ prisma, accountId, actionUserId });
+    const userPropService = (0, UserPropService_1.UserPropService)({ prisma, accountId, actionUserId, userPropType: "LOCATION_ID" });
+    const customerService = (0, CustomerService_1.CustomerService)({ prisma, accountId, actionUserId });
+    const administratorService = (0, AdministratorService_1.AdministratorService)({ prisma, accountId, actionUserId });
+    const workerService = (0, WorkerService_1.WorkerService)({ prisma, accountId, actionUserId });
+    const createUser = async ({ data, userType: overrideUserType }) => {
+        const _userType = overrideUserType || userType;
+        const _data = getCreatePayload(_userType, data);
+        if (!_data) {
+            throw new Error(`Invalid create payload: ${JSON.stringify(_data)}`);
+        }
+        // create user
+        let responseUser = await userModel.create({ data: _data });
+        let newUserId = responseUser.user_id;
+        let response = {};
+        if (_userType === "customer" && "customer" in data) {
+            let dataCustomer = {
+                customer: {
+                    ...data.customer,
+                    userId: Number(newUserId) ?? ""
+                }
+            };
+            // create customer
+            await customerService.createCustomer({ data: dataCustomer });
+            response = await customerService.getCustomer({ id: Number(newUserId), datatypes: [] });
+        }
+        if (_userType === "administrator" && "administrator" in data) {
+            let dataAdministrator = {
+                administrator: {
+                    ...data.administrator,
+                    userId: Number(newUserId) ?? ""
+                }
+            };
+            // create customer
+            await administratorService.createAdministrator({ data: dataAdministrator });
+            // replace user prop
+            await userPropService.replaceUserProp({
+                userPropType: "LOCATION_ID",
+                data: {
+                    userProp: {
+                        userId: Number(newUserId),
+                        locationIds: data.props.locationIds
+                    }
+                }
+            });
+            response = await administratorService.getAdministrator({ id: Number(newUserId), datatypes: [] });
+        }
+        if (_userType === "worker" && "worker" in data) {
+            let dataWorker = {
+                worker: {
+                    ...data.worker,
+                    userId: Number(newUserId) ?? ""
+                }
+            };
+            // create customer
+            await workerService.createWorker({ data: dataWorker });
+            // replace user prop
+            await userPropService.replaceUserProp({
+                userPropType: "LOCATION_ID",
+                data: {
+                    userProp: {
+                        userId: Number(newUserId),
+                        locationIds: data.props.locationIds
+                    }
+                }
+            });
+            response = await workerService.getWorker({ id: Number(newUserId), datatypes: [] });
+        }
+        return response;
+    };
+    const updateUser = async ({ id, data, userType: overrideUserType }) => {
+        const _userType = overrideUserType || userType;
+        const _data = getUpdatePayload(_userType, data);
+        if (!_data) {
+            throw new Error(`Invalid update payload: ${JSON.stringify(_data)}`);
+        }
+        // update user
+        let responseUser = await userModel.update({ id, data: _data });
+        let updateUserId = responseUser.user_id;
+        let response = {};
+        if (_userType === "customer" && "customer" in data) {
+            let dataCustomer = {
+                customer: {
+                    ...data.customer
+                }
+            };
+            await customerService.updateCustomer({ userId: Number(updateUserId), data: dataCustomer });
+            response = await customerService.getCustomer({ id: Number(updateUserId), datatypes: [] });
+        }
+        if (_userType === "administrator" && "administrator" in data) {
+            let dataCustomer = {
+                administrator: {
+                    ...data.administrator
+                }
+            };
+            await administratorService.updateAdministrator({ userId: Number(updateUserId), data: dataCustomer });
+            // replace user prop
+            await userPropService.replaceUserProp({
+                userPropType: "LOCATION_ID",
+                data: {
+                    userProp: {
+                        userId: Number(updateUserId),
+                        locationIds: data.props.locationIds
+                    }
+                }
+            });
+            response = await administratorService.getAdministrator({ id: Number(updateUserId), datatypes: [] });
+        }
+        if (_userType === "worker" && "worker" in data) {
+            let dataWorker = {
+                worker: {
+                    ...data.worker
+                }
+            };
+            await workerService.updateWorker({ userId: Number(updateUserId), data: dataWorker });
+            // replace user prop
+            await userPropService.replaceUserProp({
+                userPropType: "LOCATION_ID",
+                data: {
+                    userProp: {
+                        userId: Number(updateUserId),
+                        locationIds: data.props.locationIds
+                    }
+                }
+            });
+            response = await workerService.getWorker({ id: Number(updateUserId), datatypes: [] });
+        }
+        return response;
+    };
+    const getUser = async ({ id, datatypes = [] }) => {
+        let data = {};
+        if (userType === "customer") {
+            data = await customerService.getCustomer({ id, datatypes: datatypes });
+        }
+        if (userType === "administrator") {
+            data = await administratorService.getAdministrator({ id, datatypes: datatypes });
+        }
+        if (userType === "worker") {
+            data = await workerService.getWorker({ id, datatypes: datatypes });
+        }
+        if (!data) {
+            throw new Error(`Invalid id: ${id}`);
+        }
+        return data;
+    };
+    const listUsers = async ({ limit, offset, filters, sortfield, sortorder, datatypes }) => {
+        let data = [];
+        let total = 0;
+        if (userType === "customer") {
+            ({ data, total } = await customerService.listCustomers({ limit, offset, filters, sortfield, sortorder, datatypes: datatypes }));
+        }
+        if (userType === "administrator") {
+            ({ data, total } = await administratorService.listAdministrators({ limit, offset, filters, sortfield, sortorder, datatypes: datatypes }));
+        }
+        if (userType === "worker") {
+            ({ data, total } = await workerService.listWorkers({ limit, offset, filters, sortfield, sortorder, datatypes: datatypes }));
+        }
+        return {
+            data,
+            total
+        };
+    };
+    const removeUsers = async ({ ids }) => {
+        if (!ids.length)
+            (0, utils_1.throwError)('id is required');
+        let response = [];
+        if (userType === "customer") {
+            response = await customerService.removeCustomers({ userIds: ids });
+        }
+        if (userType === "administrator") {
+            response = await administratorService.removeAdministrators({ userIds: ids });
+            await userPropService.removeUserProps({ userIds: ids });
+        }
+        if (userType === "worker") {
+            response = await workerService.removeWorkers({ userIds: ids });
+            await userPropService.removeUserProps({ userIds: ids });
+        }
+        // remove user
+        let responseUser = await userModel.remove({ ids: ids.map(i => Number(i)) });
+        response.forEach((i, index) => {
+            i.user = responseUser[index];
+        });
+        return response;
+    };
+    const getUserDataTypes = () => {
+        let data = [];
+        let total = 0;
+        if (userType === "customer") {
+            data = customerService.getDataTypes();
+        }
+        if (userType === "administrator") {
+            data = administratorService.getDataTypes();
+        }
+        if (userType === "worker") {
+            data = workerService.getDataTypes();
+        }
+        return data;
+    };
+    return {
+        createUser,
+        updateUser,
+        getUser,
+        listUsers,
+        removeUsers,
+        getUserDataTypes
+    };
+};
+exports.UserService = UserService;

package/dist/services/user/WorkerService.d.ts

@@ -0,0 +1,83 @@
+import { QueryList } from "../../schema/common";
+import { DefaultServiceProps } from "../../utils";
+export type UserType = "worker";
+export declare const workerDataTypes: {
+    location: string;
+    locationCount: string;
+    zone: string;
+    zoneCount: string;
+    workerInjectionFields: string;
+    file: string;
+};
+export type WorkerDataType = keyof typeof workerDataTypes;
+export type WorkerServiceProps = DefaultServiceProps & {};
+export type WorkerGetProps = {
+    id: number;
+    datatypes: WorkerDataType[];
+};
+export type WorkerListProps = QueryList & {
+    datatypes: WorkerDataType[];
+};
+export type WorkerRemoveProps = {
+    userIds: BigInt[];
+};
+export type WorkerCreateProps = {
+    data: {
+        worker: {
+            userId: number;
+            remark: string;
+        };
+    };
+};
+export type WorkerUpdateProps = {
+    userId: number;
+    data: {
+        worker: {
+            remark: string;
+        };
+    };
+};
+export declare const WorkerService: (props: WorkerServiceProps) => {
+    createWorker: ({ data }: WorkerCreateProps) => Promise<{
+        user_id: bigint;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        remark: string | null;
+        worker_id: bigint;
+    }>;
+    updateWorker: ({ userId, data }: WorkerUpdateProps) => Promise<{
+        user_id: bigint;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        remark: string | null;
+        worker_id: bigint;
+    }>;
+    getWorker: ({ id, datatypes }: WorkerGetProps) => Promise<any>;
+    listWorkers: ({ limit, offset, filters, sortfield, sortorder, datatypes }: WorkerListProps) => Promise<{
+        data: any[];
+        total: number;
+    }>;
+    removeWorkers: ({ userIds }: WorkerRemoveProps) => Promise<{
+        user_id: bigint;
+        createdatetime: Date | null;
+        createuserid: bigint;
+        updatedatetime: Date | null;
+        updateuserid: bigint;
+        isdelete: boolean | null;
+        istrash: boolean | null;
+        accountid: bigint;
+        remark: string | null;
+        worker_id: bigint;
+    }[]>;
+    getDataTypes: () => string[];
+};

package/dist/services/user/WorkerService.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerService = exports.workerDataTypes = void 0;
+const utils_1 = require("../../utils");
+const models_1 = require("../../models");
+const utils_2 = require("../../utils");
+exports.workerDataTypes = {
+    location: "location",
+    locationCount: "location_count",
+    zone: "zone",
+    zoneCount: "zone_count",
+    workerInjectionFields: "worker_injection_fields",
+    file: "file",
+};
+const getCreatePayload = (data) => {
+    if ("worker" in data) {
+        return {
+            [`${models_1.ModelWorkerFields.user_id}`]: data.worker.userId,
+            [`${models_1.ModelWorkerFields.remark}`]: data.worker.remark
+        };
+    }
+    return false;
+};
+const getUpdatePayload = (data) => {
+    if ("worker" in data) {
+        return {
+            // [`${ModelWorkerFields.user_id}`]: data.worker.userId,
+            [`${models_1.ModelWorkerFields.remark}`]: data.worker.remark
+        };
+    }
+    return false;
+};
+let mainSqlSelect = {
+    [`wrk.${models_1.ModelWorkerFields.worker_id}`]: "worker_id",
+    [`wrk.${models_1.ModelWorkerFields.user_id}`]: "user_id",
+    [`wrk.${models_1.ModelWorkerFields.remark}`]: "remark",
+};
+let userSqlSelect = {
+    [`usr.${models_1.ModelUserFields.login_username}`]: "username",
+    [`usr.${models_1.ModelUserFields.user_type}`]: "user_type",
+    [`usr.${models_1.ModelUserFields.firstname}`]: "firstname",
+    [`usr.${models_1.ModelUserFields.lastname}`]: "lastname",
+    [`usr.${models_1.ModelUserFields.contact}`]: "contact",
+    [`usr.${models_1.ModelUserFields.email}`]: "email",
+    [`usr.${models_1.ModelUserFields.address}`]: "address",
+    [`usr.${models_1.ModelUserFields.status}`]: "status",
+};
+let defaultSqlSelect = {
+    [`wrk.${models_1.ModelWorkerFields.createdatetime}`]: "createdatetime",
+    [`creator.${models_1.ModelUserFields.login_username}`]: "createusername",
+    [`wrk.${models_1.ModelWorkerFields.updatedatetime}`]: "updatedatetime",
+    [`updater.${models_1.ModelUserFields.login_username}`]: "updateusername",
+    [`wrk.${models_1.ModelWorkerFields.isdelete}`]: "isdelete",
+    [`wrk.${models_1.ModelWorkerFields.istrash}`]: "istrash",
+    [`wrk.${models_1.ModelWorkerFields.accountid}`]: "accountid",
+};
+let userPropLocationSqlSelect = {
+    [`COALESCE(
+        STRING_AGG(usrprop_location.${models_1.ModelUserPropFields.props_id}::text, ', '),
+        ''
+    )`]: "location_id",
+    [`COALESCE(
+        STRING_AGG(location.${models_1.ModelLocationFields.location_name}::text, ', '),
+        ''
+    )`]: "location_name",
+};
+const WorkerService = (props) => {
+    const { prisma, accountId = 0, actionUserId = 0 } = props;
+    const workerModel = (0, models_1.WorkerModel)({ prisma, accountId, actionUserId });
+    const userInjectionFieldModel = (0, models_1.UserInjectionFieldModel)({ prisma, accountId, actionUserId });
+    const createWorker = async ({ data }) => {
+        const _data = getCreatePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid create worker payload: ${JSON.stringify(_data)}`);
+        }
+        let response = await workerModel.create({ data: _data });
+        return response;
+    };
+    const updateWorker = async ({ userId, data }) => {
+        const _data = getUpdatePayload(data);
+        if (!_data) {
+            throw new Error(`Invalid update worker payload: ${JSON.stringify(_data)}`);
+        }
+        let response = await workerModel.update({ where: { [`${models_1.ModelWorkerFields.user_id}`]: userId }, data: _data });
+        return response;
+    };
+    const getWorker = async ({ id, datatypes = [] }) => {
+        let { data } = await listWorkers({
+            limit: 1,
+            offset: 0,
+            filters: [{ field: "user_id", operator: "=", value: id }],
+            sortfield: "user_id",
+            sortorder: "ASC",
+            datatypes
+        });
+        return data[0] ?? null;
+    };
+    const listWorkers = async ({ limit, offset, filters, sortfield, sortorder, datatypes = [] }) => {
+        let data = [];
+        let sqlSelect = [
+            `COUNT(wrk.*) OVER() as filtered_count`,
+            (0, utils_2.buildSqlSelect)(``, mainSqlSelect),
+            (0, utils_2.buildSqlSelect)(``, userSqlSelect),
+            (0, utils_2.buildSqlSelect)(``, defaultSqlSelect),
+            (0, utils_2.buildSqlSelect)(``, userPropLocationSqlSelect),
+        ];
+        let sqlRelation = [
+            (0, utils_2.buildSqlRelation)("left", "wrk", "users", "usr", ["wrk.user_id = usr.user_id", "usr.isdelete = false", "usr.istrash = false"]),
+            (0, utils_2.buildSqlRelation)("left", "wrk", "users", "creator", ["wrk.createuserid = creator.user_id", "creator.isdelete = false", "creator.istrash = false"]),
+            (0, utils_2.buildSqlRelation)("left", "wrk", "users", "updater", ["wrk.updateuserid = updater.user_id", "updater.isdelete = false", "updater.istrash = false"]),
+            (0, utils_2.buildSqlRelation)("left", "wrk", "user_props", "usrprop_location", ["wrk.user_id = usrprop_location.user_id", "usrprop_location.type = 'LOCATION_ID'", "usrprop_location.isdelete = false", "usrprop_location.istrash = false"]),
+            (0, utils_2.buildSqlRelation)("left", "wrk", "locations", "location", ["usrprop_location.props_id = location.location_id", "location.isdelete = false", "location.istrash = false"]),
+        ];
+        let sqlGroupBy = [
+            ...Object.keys(mainSqlSelect),
+            ...Object.keys(userSqlSelect),
+            // ...Object.keys(userPropLocationSqlSelect),
+            ...Object.keys(defaultSqlSelect)
+        ];
+        let filterColumns = {
+            ...mainSqlSelect,
+            ...userSqlSelect,
+            ...userPropLocationSqlSelect,
+            ...defaultSqlSelect
+        };
+        if (datatypes.includes(exports.workerDataTypes.workerInjectionFields)) {
+            const keyPrefix = `usr_wrk_`;
+            const allFields = await userInjectionFieldModel.getFields(`${keyPrefix}`);
+            let injectionFieldSqlSelect = (0, utils_2.toFieldMap)(allFields, "uip");
+            if (Object.keys(injectionFieldSqlSelect).length > 0) {
+                filterColumns = { ...filterColumns, ...injectionFieldSqlSelect };
+                sqlSelect = [...sqlSelect, (0, utils_2.buildSqlSelect)(``, injectionFieldSqlSelect)];
+                sqlRelation = [...sqlRelation, (0, utils_2.buildSqlRelation)("left", "wrk", "user_injection_fields", "uip", ["wrk.user_id = uip.user_id", "uip.field_ref = 'user'", "uip.isdelete = false", "uip.istrash = false"])];
+                sqlGroupBy = [...sqlGroupBy, ...Object.keys(injectionFieldSqlSelect)];
+            }
+        }
+        if (datatypes.includes(exports.workerDataTypes.location)) {
+            let locationSqlSelect = {
+                [`COALESCE(
+                        JSON_AGG(
+                            DISTINCT JSONB_BUILD_OBJECT(
+                                '${models_1.ModelLocationFields.location_id}', location.location_id,
+                                '${models_1.ModelLocationFields.location_code}', location.location_code,
+                                '${models_1.ModelLocationFields.location_name}', location.location_name,
+                                '${models_1.ModelLocationFields.location_type}', location.location_type,
+                                '${models_1.ModelLocationFields.address_1}', location.address_1,
+                                '${models_1.ModelLocationFields.address_2}', location.address_2,
+                                '${models_1.ModelLocationFields.area}', location.area,
+                                '${models_1.ModelLocationFields.area_id}', location.area_id,
+                                '${models_1.ModelLocationFields.country_id}', location.country_id,
+                                '${models_1.ModelLocationFields.state_id}', location.state_id,
+                                '${models_1.ModelLocationFields.postcode}', location.postcode,
+                                '${models_1.ModelLocationFields.is_default}', location.is_default,
+                                '${models_1.ModelLocationFields.person_contact}', location.person_contact,
+                                '${models_1.ModelLocationFields.person_name}', location.person_contact,
+                                '${models_1.ModelLocationFields.person_email}', location.person_email,
+                                '${models_1.ModelLocationFields.isdelete}', location.isdelete,
+                                '${models_1.ModelLocationFields.istrash}', location.istrash
+                            )
+                        ) FILTER (WHERE location.location_id IS NOT NULL AND location.isdelete = false AND location.istrash = false), 
+                        '[]'
+                    )`]: "locations"
+            };
+            filterColumns = { ...filterColumns, ...locationSqlSelect };
+            sqlSelect = [...sqlSelect, (0, utils_2.buildSqlSelect)(``, locationSqlSelect)];
+            // sqlRelation = [...sqlRelation, buildSqlRelation("left", "usrprop_location", "location", "brn", ["wrk.user_id = brn.user_id", "brn.isdelete = false", "brn.istrash = false"])]
+        }
+        if (datatypes.includes(exports.workerDataTypes.locationCount)) {
+            let locationCountSqlSelect = {
+                [`COUNT(DISTINCT location.${models_1.ModelLocationFields.location_id})::INT`]: "location_count"
+            };
+            filterColumns = { ...filterColumns, ...locationCountSqlSelect };
+            sqlSelect = [...sqlSelect, (0, utils_2.buildSqlSelect)(``, locationCountSqlSelect)];
+            // sqlRelation = [...sqlRelation, buildSqlRelation("left", "cus", "branches", "brncount", ["wrk.user_id = brncount.user_id", "brncount.isdelete = false", "brncount.istrash = false"])]
+        }
+        // if (datatypes.includes(customerDataTypes.branchUserCount)) {
+        //     let branchUserCountSqlSelect = {
+        //         [`COUNT(DISTINCT brnusrcount.${ModelBranchUserFields.branch_user_id})::INT`]: "branch_user_count"
+        //     }
+        //     filterColumns = { ...filterColumns, ...branchUserCountSqlSelect }
+        //     sqlSelect = [...sqlSelect, buildSqlSelect(``, branchUserCountSqlSelect)]
+        //     sqlRelation = [...sqlRelation, buildSqlRelation("left", "cus", "branch_users", "brnusrcount", ["wrk.user_id = brnusrcount.user_id", "brnusrcount.isdelete = false", "brnusrcount.istrash = false"])]
+        // }
+        let sqlWhere = [
+            `wrk.isdelete = false`,
+            `wrk.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: "workers",
+            mainAlias: "wrk",
+            accountId,
+            sqlSelect,
+            sqlRelation,
+            sqlWhere,
+            sqlGroupBy,
+            sqlOrderby,
+            sqlLimitOffset
+        });
+        data = await workerModel.raw(sqlRaw);
+        const response = {
+            data: data.map(({ filtered_count, ...rest }) => rest),
+            total: data.length ? Number(data[0].filtered_count) : 0
+        };
+        return response;
+    };
+    const removeWorkers = async ({ userIds }) => {
+        if (!userIds.length)
+            (0, utils_1.throwError)('userIds is required');
+        const response = await workerModel.remove({ where: { [`${models_1.ModelWorkerFields.user_id}`]: { in: userIds } } });
+        return response;
+    };
+    const getDataTypes = () => {
+        return Object.values(exports.workerDataTypes);
+    };
+    return {
+        createWorker,
+        updateWorker,
+        getWorker,
+        listWorkers,
+        removeWorkers,
+        getDataTypes
+    };
+};
+exports.WorkerService = WorkerService;

package/dist/utils/dateUtils.d.ts

@@ -0,0 +1,4 @@
+import dayjs from "dayjs";
+export declare const getCurrentDateTimeISO: () => string;
+export declare const getCurrentDateTime: () => string;
+export { dayjs };

package/dist/utils/dateUtils.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dayjs = exports.getCurrentDateTime = exports.getCurrentDateTimeISO = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+exports.dayjs = dayjs_1.default;
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const timezone_1 = __importDefault(require("dayjs/plugin/timezone"));
+// extend plugins
+dayjs_1.default.extend(utc_1.default);
+dayjs_1.default.extend(timezone_1.default);
+// set default timezone to Malaysia
+dayjs_1.default.tz.setDefault("Asia/Kuala_Lumpur");
+const getCurrentDateTimeISO = () => {
+    return (0, dayjs_1.default)().toISOString();
+};
+exports.getCurrentDateTimeISO = getCurrentDateTimeISO;
+const getCurrentDateTime = () => {
+    return (0, dayjs_1.default)().format('YYYY-MM-DD HH:mm:ss');
+};
+exports.getCurrentDateTime = getCurrentDateTime;

package/dist/utils/exceptionUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Throws a new Error with the given message.
+ */
+export declare function throwError(message: string): never;
+/**
+ * Logs an error using the centralized logger.
+ */
+export declare function logError(error: unknown, context?: string): void;

package/dist/utils/exceptionUtils.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwError = throwError;
+exports.logError = logError;
+const logUtils_1 = __importDefault(require("./logUtils"));
+/**
+ * Throws a new Error with the given message.
+ */
+function throwError(message) {
+    throw new Error(message);
+}
+/**
+ * Logs an error using the centralized logger.
+ */
+function logError(error, context = '') {
+    if (error instanceof Error) {
+        logUtils_1.default.error({ err: error }, context || error.message);
+    }
+    else {
+        logUtils_1.default.error({ err: error }, context || 'Unknown error');
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,15 @@
+export { default as _ } from "lodash";
+export { HTTP_STATUS, sendError, sendSuccess } from "./responseUtils";
+export { dayjs, getCurrentDateTime, getCurrentDateTimeISO } from "./dateUtils";
+export { buildPrismaWhere } from "../helpers/prismaHelper";
+export { validateWithSchema, validateMultipleSchemas, convertPayloadByTableSchema } from "./schemaUtils";
+export { default as logger } from "./logUtils";
+export { throwError, logError } from "./exceptionUtils";
+export { getSwmAuth } from "./smwUtils";
+export { getRequestHeaderLocCode, checkRequestContentIsEmpty } from "./requestUtils";
+export { storeJwtInMemory, getJwtFromMemory } from "./jwtUtils";
+export { getFormattedZodErrors, getFormattedZodErrorsIntoString } from "./zodUtils";
+export { toFieldMap, buildSqlRawSelect, buildSqlRelation, buildSqlSelect, buildSqlWhere, buildSqlLimitOffset, buildSqlOrderBy, getFieldsByType } from "./queryBuilder";
+export type { DefaultServiceProps } from "./serviceUtils";
+export { getDefaultServiceProps } from "./serviceUtils";
+export { buildFullFieldName } from "./injectionFieldUtils";