storemw-core-client 1.0.1

package/dist/services/wallet/WalletService.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletService = exports.walletCurrencyTypes = exports.walletTargetTypes = exports.walletTypes = void 0;
+const lib_1 = require("@/lib");
+const lib_2 = require("@/lib");
+exports.walletTypes = {
+    wallet: "wallet",
+    walletUser: "wallet_user"
+};
+exports.walletTargetTypes = {
+    wallet: "wallet",
+    walletUser: "wallet_user"
+};
+exports.walletCurrencyTypes = {
+    myr: "MYR",
+    sgd: "SGD",
+    usd: "USD",
+    cny: "CNY"
+};
+const getCreatePayload = (walletType, data) => {
+    if (walletType === "wallet" && "wallet" in data) {
+        return {
+            wallet: {
+                name: data.wallet.name,
+                currency: data.wallet.currency,
+                wallet_key: data.wallet.walletKey,
+                primary_wallet: (data.wallet.isPrimary === true) ? 1 : 0,
+                conversion_rate: data.wallet.conversionRate,
+                description: data.wallet.description,
+                status: (data.wallet.status === true) ? 1 : 0
+            }
+        };
+    }
+    if (walletType === "wallet_user" && "walletUser" in data) {
+        return {
+            wallet: {
+                wallet_id: data.walletUser.walletId,
+                user_id: data.walletUser.userId,
+                status: (data.walletUser.status === true) ? 1 : 0
+            }
+        };
+    }
+};
+const getUpdatePayload = (walletType, data) => {
+    if (walletType === "wallet" && "wallet" in data) {
+        return {
+            wallet: {
+                name: data.wallet.name,
+                currency: data.wallet.currency,
+                wallet_key: data.wallet.walletKey,
+                primary_wallet: (data.wallet.isPrimary === true) ? 1 : 0,
+                conversion_rate: data.wallet.conversionRate,
+                description: data.wallet.description,
+                status: (data.wallet.status === true) ? 1 : 0
+            }
+        };
+    }
+    if (walletType === "wallet_user" && "walletUser" in data) {
+        return {
+            wallet: {
+                status: (data.walletUser.status === true) ? 1 : 0
+            }
+        };
+    }
+};
+const WalletService = (props) => {
+    const { walletType = "wallet", walletTargetType, ...rest } = props ?? {};
+    const { makeCall } = (0, lib_1.ApiService)(rest?.customToken ? { customToken: rest.customToken } : {});
+    const endpoint1 = "wallet";
+    const endpoint2 = "wallets";
+    const list = async (props) => {
+        const { walletType: overrideWalletType } = props;
+        const url = (0, lib_2.buildApiListUrl)(`${endpoint2}/${overrideWalletType || walletType}`, props);
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+        return response;
+    };
+    const get = async (props) => {
+        const { id, walletType: overrideWalletType } = props;
+        const url = (0, lib_2.buildApiGetUrl)(`${endpoint1}/${overrideWalletType || walletType}/${id}`, props);
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+        return response;
+    };
+    const create = async ({ data, walletType: overrideWalletType, walletTargetType: overrideWalletTargetType }) => {
+        let _walletType = overrideWalletType || walletType;
+        let payload = getCreatePayload(_walletType, data);
+        let url = `${endpoint1}`;
+        let postData = {
+            scope: {
+                target: overrideWalletTargetType || walletTargetType,
+                action: "",
+            },
+            payload
+        };
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+        return response;
+    };
+    const update = async ({ id, data, walletType: overrideWalletType, walletTargetType: overrideWalletTargetType }) => {
+        let url = `${endpoint1}/${id}`;
+        let _walletType = overrideWalletType || walletType;
+        let payload = getUpdatePayload(_walletType, data);
+        const postData = {
+            scope: {
+                target: overrideWalletTargetType || walletTargetType,
+                action: "",
+            },
+            payload
+        };
+        const response = await makeCall({
+            url,
+            method: "put",
+            payload: postData
+        });
+        return response;
+    };
+    const remove = async ({ ids, walletTargetType: overrideWalletTargetType }) => {
+        let url = `${endpoint2}/delete`;
+        const postData = {
+            scope: {
+                target: overrideWalletTargetType || walletTargetType,
+            },
+            payload: {
+                ids
+            }
+        };
+        const response = await makeCall({
+            url,
+            method: "post",
+            payload: postData
+        });
+        return response;
+    };
+    const getDataTypes = async ({ walletType: overrideWalletType }) => {
+        let url = `${endpoint1}/data_types/${overrideWalletType || walletType}`;
+        const response = await makeCall({
+            url,
+            method: "get",
+        });
+        return response;
+    };
+    return {
+        list,
+        get,
+        create,
+        update,
+        remove,
+        getDataTypes,
+    };
+};
+exports.WalletService = WalletService;

package/dist/utils/dateUtils.d.ts

@@ -0,0 +1,6 @@
+import dayjs from "dayjs";
+export declare const getCurrentDateTimeISO: () => string;
+export declare const dayjsDisplayFormat = "YYYY-MM-DD HH:mm:ss";
+export declare const getCurrentDateTime: () => string;
+export declare const formatDisplayDateTime: (date: any) => string;
+export { dayjs };

package/dist/utils/dateUtils.js

@@ -0,0 +1,28 @@
+"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.formatDisplayDateTime = exports.getCurrentDateTime = exports.dayjsDisplayFormat = 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;
+exports.dayjsDisplayFormat = "YYYY-MM-DD HH:mm:ss";
+const getCurrentDateTime = () => {
+    return (0, dayjs_1.default)().format(exports.dayjsDisplayFormat);
+};
+exports.getCurrentDateTime = getCurrentDateTime;
+const formatDisplayDateTime = (date) => {
+    return (0, dayjs_1.default)(date).format(exports.dayjsDisplayFormat);
+};
+exports.formatDisplayDateTime = formatDisplayDateTime;

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { default as _ } from "lodash";
+export { dayjs, getCurrentDateTime, getCurrentDateTimeISO, formatDisplayDateTime } from "./dateUtils";

package/dist/utils/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDisplayDateTime = exports.getCurrentDateTimeISO = exports.getCurrentDateTime = exports.dayjs = exports._ = void 0;
+var lodash_1 = require("lodash");
+Object.defineProperty(exports, "_", { enumerable: true, get: function () { return __importDefault(lodash_1).default; } });
+var dateUtils_1 = require("./dateUtils");
+Object.defineProperty(exports, "dayjs", { enumerable: true, get: function () { return dateUtils_1.dayjs; } });
+Object.defineProperty(exports, "getCurrentDateTime", { enumerable: true, get: function () { return dateUtils_1.getCurrentDateTime; } });
+Object.defineProperty(exports, "getCurrentDateTimeISO", { enumerable: true, get: function () { return dateUtils_1.getCurrentDateTimeISO; } });
+Object.defineProperty(exports, "formatDisplayDateTime", { enumerable: true, get: function () { return dateUtils_1.formatDisplayDateTime; } });

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "storemw-core-client",
+  "version": "1.0.1",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node -r tsconfig-paths/register src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/lodash": "^4.17.20",
+    "@types/node": "^20.19.24",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.13.1",
+    "dayjs": "^1.11.18",
+    "dotenv": "^17.2.3",
+    "lodash": "^4.17.21"
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,15 @@
+export interface ApiConfig {
+    baseURL: string;
+    token?: string;
+}
+
+// Shared default config (global runtime memory)
+let defaultConfig: ApiConfig = {
+    baseURL: "",
+};
+
+export const setApiConfig = (newConfig: ApiConfig) => {
+    defaultConfig = { ...defaultConfig, ...newConfig };
+};
+
+export const getApiConfig = (): ApiConfig => defaultConfig;

package/src/config/env.ts

@@ -0,0 +1,18 @@
+import "dotenv/config";
+
+export const env = {
+    NODE_ENV: process.env.NODE_ENV ?? "development",
+
+    // 👇 the API endpoint
+    API_BASE_URL:
+        process.env.NEXT_PUBLIC_API_BASE_URL ??
+        process.env.VITE_API_BASE_URL ??
+        process.env.API_BASE_URL ??
+        "",
+
+    // 👇 optional auth token
+    API_TOKEN: process.env.API_TOKEN ?? "",
+
+    // 👇 you can add more if needed later
+    DEBUG: process.env.DEBUG === "true",
+};

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export { env } from "./env"
+export { getApiConfig, setApiConfig } from "./config"

package/src/index.ts

@@ -0,0 +1,41 @@
+import {
+    AuthService,
+    LocationService,
+} from "@/services"
+
+import { setApiConfig, env } from "@/config"
+
+// set the api config from env
+setApiConfig({
+    baseURL: env.API_BASE_URL,
+    token: ""
+})
+
+const testAuthToken = async () => {
+    const authService = AuthService({ authTargetType: "administrator" })
+    const response = await authService.authLogin({
+        username: "masteradmin2",
+        password: "abc12345"
+    })
+    return response
+}
+
+// const testLocation = async () => {
+//         const locationService = LocationService({ customToken: "sdfdsfds" })
+//         await locationService.get({ id: 23432, dataTypes: [], locationType: "location" })
+//     
+// }
+
+(async () => {
+
+    try {
+        // await testLocation();
+        const response = await testAuthToken();
+        console.log('response', response)
+    } catch (error) {
+        console.error(`error`, error)
+    }
+
+})();
+
+

package/src/lib/ApiService.ts

@@ -0,0 +1,170 @@
+import axios, { isAxiosError } from "axios";
+import type { AxiosResponse, AxiosInstance, AxiosRequestConfig } from "axios";
+
+// import { EnvService, /* SessionService */ } from '.'; // Adjust path as needed
+
+import { getApiConfig } from "@/config";
+
+type ApiResponse = {
+    status: boolean;
+    message: string;
+    data?: any;
+}
+
+type ApiError = {
+    message: string;
+}
+
+type AxiosInstanceParams = {
+    axiosClient: AxiosInstance,
+    cancelToken: any
+}
+
+export type ApiServiceType = {
+    customToken?: string, // custom jwt token
+}
+
+// You can inject token later if needed (via a setter or directly)
+let accessToken: string = '';
+
+const createAxiosInstance = (endpointUrl: string): AxiosInstanceParams => {
+    // return axios.create({
+    //     baseURL: endpointUrl,
+    //     timeout: 30000,
+    // });
+
+    let axiosClient = axios.create({
+        baseURL: endpointUrl,
+        timeout: 30000,
+    });
+
+    let cancelToken = axios.CancelToken
+
+    return {
+        axiosClient,
+        cancelToken
+    }
+}
+
+export const ApiService = (props?: ApiServiceType) => {
+
+    const customToken = props?.customToken
+
+    // const { baseURL } = EnvService(); // always read fresh env if needed
+    const { baseURL } = getApiConfig()
+
+    const {
+        axiosClient,
+        // cancelToken,
+    } = createAxiosInstance(baseURL)
+
+    const setToken = (token: string) => {
+        accessToken = token;
+    }
+
+    const getAuthorization = (): string => {
+        return accessToken ? `Bearer ${accessToken}` : '';
+    }
+
+    const makeCall = async ({
+        url,
+        payload,
+        method,
+        sessionAuthentication = true
+    }: {
+        url: string;
+        payload?: any;
+        method: 'get' | 'post' | 'put' | 'delete';
+        sessionAuthentication?: boolean; // skip to check the session for headers
+    }): Promise<ApiResponse> => {
+
+        if (customToken) { // if option to use customToken
+            setToken(customToken)
+        } else {
+            if (sessionAuthentication) {
+                // const { getSession } = SessionService()
+
+                // const session = await getSession()
+
+                // if (session?.token) {
+                //     setToken(session?.token)
+                // }
+            }
+        }
+
+
+        // const client = createAxiosInstance(baseURL);
+        const client = axiosClient
+
+        // console.log('accessToken', accessToken)
+
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json',
+            ...(accessToken ? { Authorization: getAuthorization() } : {}),
+        };
+
+        const config: AxiosRequestConfig = {
+            method,
+            url,
+            headers,
+            ...(method.toLowerCase() !== 'get' ? { data: payload } : {}),
+        };
+
+        // console.log('[Axios Call]', baseURL, url, method, JSON.stringify(payload));
+
+        try {
+            const response = await client.request<ApiResponse>(config);
+            return parseResponse(response);
+        } catch (error: unknown) {
+            if (isAxiosError<ApiError>(error)) {
+                const message =
+                    error.response?.data?.message || error.message || 'Network error';
+
+                // console.log('error', error)
+                throw getError(false, message);
+            }
+            throw getError(false, `${(error as any)?.message || 'Unknown error'}`);
+        }
+    }
+
+    const parseResponse = (response: AxiosResponse<ApiResponse>) => {
+        if (!isRequestSuccess(response)) {
+            throw getError(false, 'Server failed to respond properly');
+        }
+
+        if (!isResultSuccess(response)) {
+            throw getError(false, response?.data?.message || 'API returned an error');
+        }
+
+        const { status, message, data } = response.data;
+        return getSuccess(status, message, data);
+    }
+
+    const isRequestSuccess = (response: AxiosResponse): boolean => response.status === 200
+
+    const isResultSuccess = (response: AxiosResponse<ApiResponse>): boolean =>
+        Boolean(response?.data?.status)
+
+    const getError = (status: boolean, message = '') => ({
+        status,
+        message,
+    })
+
+    const getSuccess = (status: boolean, message = '', data?: any) => ({
+        status,
+        message,
+        data,
+    })
+
+    return {
+        createAxiosInstance,
+        getAuthorization,
+        setToken,
+        makeCall,
+        parseResponse,
+        isRequestSuccess,
+        isResultSuccess,
+        getError,
+        getSuccess
+    }
+};

package/src/lib/index.ts

@@ -0,0 +1,5 @@
+export { ApiService } from './ApiService';
+export type { ApiServiceType } from "./ApiService"
+
+export { filterOperatorTypes, buildApiGetUrl, buildApiListUrl, BuildApiListParamsProps, BuildApiGetParamsProps } from './queryParams';
+export type { FilterItem } from './queryParams';

package/src/lib/queryParams.ts

@@ -0,0 +1,162 @@
+export const _operatorSymbols = {
+    eq: "=",
+    startsWith: "_%",
+    endsWith: "%_",
+    contains: "%",
+    containsOr: "%||",
+    anyOf: "where_in",
+    anyOfOr: "or_where_in",
+    excludeOf: "where_not_in",
+    excludeOfOr: "or_where_not_in",
+    moreThanEq: ">=",
+    moreThanEqOr: ">=||",
+    lessThanEq: "<=",
+    lessThanEqOr: "<=||",
+    notEq: "!=",
+    eqOr: "=||",
+    havingInOr: "or_having_in",
+    isNull: "null",
+    isNotNull: "null!=",
+    isNullOr: "null||",
+} as const;
+
+export const filterOperatorTypes = Object.keys(_operatorSymbols).reduce((acc, key) => {
+    acc[key] = key;
+    return acc;
+}, {} as Record<string, string>);
+
+export type FilterOperator = keyof typeof filterOperatorTypes;
+
+export type FilterItem = {
+    name: string;
+    // operator: keyof typeof _operatorSymbols;
+    operator: FilterOperator,
+    value?: any;
+    group?: string;
+}
+
+// export type SortInfo = {
+//     id: string;
+//     dir: 1 | -1;
+// }
+
+export type BuildApiListParamsProps = {
+    limit?: number;
+    offset?: number;
+    filterValue?: FilterItem[];
+    // sortInfo?: SortInfo;
+    sortField?: string;
+    sortOrder?: "asc" | "desc";
+    dataTypes?: string[];
+    extraFilters?: any[]; // e.g. location filters
+}
+
+export type BuildApiGetParamsProps = {
+    dataTypes?: string[];
+}
+
+export function buildApiListUrl(
+    endpoint: string,
+    props: BuildApiListParamsProps,
+    // operatorSymbols: Record<string, string>
+): string {
+
+    let filters: any[] = [];
+
+    const {
+        limit,
+        offset,
+        filterValue,
+        // sortInfo,
+        sortField,
+        sortOrder,
+        dataTypes = [],
+        extraFilters = [],
+    } = props;
+
+    // Process filters
+    if (filterValue) {
+        for (const filter of filterValue) {
+            if (
+                filter.value !== undefined ||
+                filter.operator === "isNull" ||
+                filter.operator === "isNotNull" ||
+                filter.operator === "isNullOr"
+            ) {
+                const line: any = {
+                    field: filter.name,
+                    operator: _operatorSymbols[filter.operator as keyof typeof _operatorSymbols],
+                    value: filter.value,
+                };
+
+                if (filter.group) line.group = filter.group;
+
+                filters.push(line);
+            }
+        }
+    }
+
+    // Add any extra filters passed in
+    filters = [...filters, ...extraFilters];
+
+    // Sorting
+    let sortfield = sortField ?? "id";
+    let sortorder = sortOrder ?? "desc";
+
+    // if (sortInfo?.id) {
+    //     sortfield = sortInfo.id;
+    //     sortorder = sortInfo.dir === -1 ? "desc" : "asc";
+    // }
+
+    // Build URL
+    let url = `${endpoint}?limit=${limit}&offset=${offset}&sortfield=${sortfield}&sortorder=${sortorder}`;
+    url += `&filters=${JSON.stringify(filters.length > 0 ? filters : [])}`;
+
+    if (dataTypes.length > 0) {
+        url += `&datatypes=${JSON.stringify(dataTypes)}`;
+    }
+
+    return url;
+}
+
+export function buildApiGetUrl(
+    endpoint: string,
+    props: BuildApiGetParamsProps,
+    // operatorSymbols: Record<string, string>
+): string {
+
+    // let filters: any[] = [];
+
+    const {
+        // limit,
+        // offset,
+        // filterValue,
+        // // sortInfo,
+        // sortField,
+        // sortOrder,
+        dataTypes = [],
+        // extraFilters = [],
+    } = props;
+
+    // Add any extra filters passed in
+    // filters = [...filters, ...extraFilters];
+
+    // Sorting
+    // let sortfield = sortField ?? "id";
+    // let sortorder = sortOrder ?? "desc";
+
+    // if (sortInfo?.id) {
+    //     sortfield = sortInfo.id;
+    //     sortorder = sortInfo.dir === -1 ? "desc" : "asc";
+    // }
+
+    // Build URL
+    let url = `${endpoint}?`;
+    // url += `&filters=${JSON.stringify(filters.length > 0 ? filters : [])}`;
+
+    if (dataTypes.length > 0) {
+        url += `datatypes=${JSON.stringify(dataTypes)}`;
+    }
+
+    return url;
+}