storemw-core-client 1.0.1

package/.env

@@ -0,0 +1 @@
+API_BASE_URL=http://103.47.154.104:1759

package/.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Run Storemw-Core Client",
+            "runtimeArgs": [
+                "-r",
+                "ts-node/register",
+                "-r",
+                "tsconfig-paths/register"
+            ],
+            "args": [
+                "${workspaceFolder}/src/index.ts"
+            ],
+            "cwd": "${workspaceFolder}",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "outputCapture": "std"
+        }
+    ]
+}

package/dist/config/config.d.ts

@@ -0,0 +1,6 @@
+export interface ApiConfig {
+    baseURL: string;
+    token?: string;
+}
+export declare const setApiConfig: (newConfig: ApiConfig) => void;
+export declare const getApiConfig: () => ApiConfig;

package/dist/config/config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiConfig = exports.setApiConfig = void 0;
+// Shared default config (global runtime memory)
+let defaultConfig = {
+    baseURL: "",
+};
+const setApiConfig = (newConfig) => {
+    defaultConfig = { ...defaultConfig, ...newConfig };
+};
+exports.setApiConfig = setApiConfig;
+const getApiConfig = () => defaultConfig;
+exports.getApiConfig = getApiConfig;

package/dist/config/env.d.ts

@@ -0,0 +1,7 @@
+import "dotenv/config";
+export declare const env: {
+    NODE_ENV: string;
+    API_BASE_URL: string;
+    API_TOKEN: string;
+    DEBUG: boolean;
+};

package/dist/config/env.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+require("dotenv/config");
+exports.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/dist/config/index.d.ts

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

package/dist/config/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setApiConfig = exports.getApiConfig = exports.env = void 0;
+var env_1 = require("./env");
+Object.defineProperty(exports, "env", { enumerable: true, get: function () { return env_1.env; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "getApiConfig", { enumerable: true, get: function () { return config_1.getApiConfig; } });
+Object.defineProperty(exports, "setApiConfig", { enumerable: true, get: function () { return config_1.setApiConfig; } });

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const services_1 = require("@/services");
+const config_1 = require("@/config");
+// set the api config from env
+(0, config_1.setApiConfig)({
+    baseURL: config_1.env.API_BASE_URL,
+    token: ""
+});
+const testAuthToken = async () => {
+    const authService = (0, services_1.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/dist/lib/ApiService.d.ts

@@ -0,0 +1,41 @@
+import type { AxiosResponse, AxiosInstance } from "axios";
+type ApiResponse = {
+    status: boolean;
+    message: string;
+    data?: any;
+};
+type AxiosInstanceParams = {
+    axiosClient: AxiosInstance;
+    cancelToken: any;
+};
+export type ApiServiceType = {
+    customToken?: string;
+};
+export declare const ApiService: (props?: ApiServiceType) => {
+    createAxiosInstance: (endpointUrl: string) => AxiosInstanceParams;
+    getAuthorization: () => string;
+    setToken: (token: string) => void;
+    makeCall: ({ url, payload, method, sessionAuthentication }: {
+        url: string;
+        payload?: any;
+        method: "get" | "post" | "put" | "delete";
+        sessionAuthentication?: boolean;
+    }) => Promise<ApiResponse>;
+    parseResponse: (response: AxiosResponse<ApiResponse>) => {
+        status: boolean;
+        message: string;
+        data: any;
+    };
+    isRequestSuccess: (response: AxiosResponse) => boolean;
+    isResultSuccess: (response: AxiosResponse<ApiResponse>) => boolean;
+    getError: (status: boolean, message?: string) => {
+        status: boolean;
+        message: string;
+    };
+    getSuccess: (status: boolean, message?: string, data?: any) => {
+        status: boolean;
+        message: string;
+        data: any;
+    };
+};
+export {};

package/dist/lib/ApiService.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiService = void 0;
+const axios_1 = __importStar(require("axios"));
+// import { EnvService, /* SessionService */ } from '.'; // Adjust path as needed
+const config_1 = require("@/config");
+// You can inject token later if needed (via a setter or directly)
+let accessToken = '';
+const createAxiosInstance = (endpointUrl) => {
+    // return axios.create({
+    //     baseURL: endpointUrl,
+    //     timeout: 30000,
+    // });
+    let axiosClient = axios_1.default.create({
+        baseURL: endpointUrl,
+        timeout: 30000,
+    });
+    let cancelToken = axios_1.default.CancelToken;
+    return {
+        axiosClient,
+        cancelToken
+    };
+};
+const ApiService = (props) => {
+    const customToken = props?.customToken;
+    // const { baseURL } = EnvService(); // always read fresh env if needed
+    const { baseURL } = (0, config_1.getApiConfig)();
+    const { axiosClient,
+    // cancelToken,
+     } = createAxiosInstance(baseURL);
+    const setToken = (token) => {
+        accessToken = token;
+    };
+    const getAuthorization = () => {
+        return accessToken ? `Bearer ${accessToken}` : '';
+    };
+    const makeCall = async ({ url, payload, method, sessionAuthentication = true }) => {
+        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 = {
+            'Content-Type': 'application/json',
+            ...(accessToken ? { Authorization: getAuthorization() } : {}),
+        };
+        const config = {
+            method,
+            url,
+            headers,
+            ...(method.toLowerCase() !== 'get' ? { data: payload } : {}),
+        };
+        // console.log('[Axios Call]', baseURL, url, method, JSON.stringify(payload));
+        try {
+            const response = await client.request(config);
+            return parseResponse(response);
+        }
+        catch (error) {
+            if ((0, axios_1.isAxiosError)(error)) {
+                const message = error.response?.data?.message || error.message || 'Network error';
+                // console.log('error', error)
+                throw getError(false, message);
+            }
+            throw getError(false, `${error?.message || 'Unknown error'}`);
+        }
+    };
+    const parseResponse = (response) => {
+        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) => response.status === 200;
+    const isResultSuccess = (response) => Boolean(response?.data?.status);
+    const getError = (status, message = '') => ({
+        status,
+        message,
+    });
+    const getSuccess = (status, message = '', data) => ({
+        status,
+        message,
+        data,
+    });
+    return {
+        createAxiosInstance,
+        getAuthorization,
+        setToken,
+        makeCall,
+        parseResponse,
+        isRequestSuccess,
+        isResultSuccess,
+        getError,
+        getSuccess
+    };
+};
+exports.ApiService = ApiService;

package/dist/lib/index.d.ts

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

package/dist/lib/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildApiListUrl = exports.buildApiGetUrl = exports.filterOperatorTypes = exports.ApiService = void 0;
+var ApiService_1 = require("./ApiService");
+Object.defineProperty(exports, "ApiService", { enumerable: true, get: function () { return ApiService_1.ApiService; } });
+var queryParams_1 = require("./queryParams");
+Object.defineProperty(exports, "filterOperatorTypes", { enumerable: true, get: function () { return queryParams_1.filterOperatorTypes; } });
+Object.defineProperty(exports, "buildApiGetUrl", { enumerable: true, get: function () { return queryParams_1.buildApiGetUrl; } });
+Object.defineProperty(exports, "buildApiListUrl", { enumerable: true, get: function () { return queryParams_1.buildApiListUrl; } });

package/dist/lib/queryParams.d.ts

@@ -0,0 +1,43 @@
+export declare const _operatorSymbols: {
+    readonly eq: "=";
+    readonly startsWith: "_%";
+    readonly endsWith: "%_";
+    readonly contains: "%";
+    readonly containsOr: "%||";
+    readonly anyOf: "where_in";
+    readonly anyOfOr: "or_where_in";
+    readonly excludeOf: "where_not_in";
+    readonly excludeOfOr: "or_where_not_in";
+    readonly moreThanEq: ">=";
+    readonly moreThanEqOr: ">=||";
+    readonly lessThanEq: "<=";
+    readonly lessThanEqOr: "<=||";
+    readonly notEq: "!=";
+    readonly eqOr: "=||";
+    readonly havingInOr: "or_having_in";
+    readonly isNull: "null";
+    readonly isNotNull: "null!=";
+    readonly isNullOr: "null||";
+};
+export declare const filterOperatorTypes: Record<string, string>;
+export type FilterOperator = keyof typeof filterOperatorTypes;
+export type FilterItem = {
+    name: string;
+    operator: FilterOperator;
+    value?: any;
+    group?: string;
+};
+export type BuildApiListParamsProps = {
+    limit?: number;
+    offset?: number;
+    filterValue?: FilterItem[];
+    sortField?: string;
+    sortOrder?: "asc" | "desc";
+    dataTypes?: string[];
+    extraFilters?: any[];
+};
+export type BuildApiGetParamsProps = {
+    dataTypes?: string[];
+};
+export declare function buildApiListUrl(endpoint: string, props: BuildApiListParamsProps): string;
+export declare function buildApiGetUrl(endpoint: string, props: BuildApiGetParamsProps): string;

package/dist/lib/queryParams.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterOperatorTypes = exports._operatorSymbols = void 0;
+exports.buildApiListUrl = buildApiListUrl;
+exports.buildApiGetUrl = buildApiGetUrl;
+exports._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||",
+};
+exports.filterOperatorTypes = Object.keys(exports._operatorSymbols).reduce((acc, key) => {
+    acc[key] = key;
+    return acc;
+}, {});
+function buildApiListUrl(endpoint, props) {
+    let filters = [];
+    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 = {
+                    field: filter.name,
+                    operator: exports._operatorSymbols[filter.operator],
+                    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;
+}
+function buildApiGetUrl(endpoint, props) {
+    // 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;
+}

package/dist/services/account/AccountService.d.ts

@@ -0,0 +1,52 @@
+import { ApiServiceType } from '@/lib';
+import { BuildApiListParamsProps, BuildApiGetParamsProps } from '@/lib';
+export declare const accountTypes: {
+    readonly account: "account";
+};
+export declare const accountTargetTypes: {
+    readonly account: "account";
+};
+export type AccountType = typeof accountTypes[keyof typeof accountTypes];
+export type AccountTargetType = typeof accountTargetTypes[keyof typeof accountTargetTypes];
+export type AccountTargetKey = keyof typeof accountTargetTypes;
+export type AccountServiceProps = ApiServiceType & {
+    accountTargetType?: AccountTargetType;
+    accountType?: AccountType;
+};
+export type ListAccountProps = BuildApiListParamsProps & {
+    accountType?: AccountType;
+};
+export type GetAccountProps = BuildApiGetParamsProps & {
+    id: number | string;
+    accountType?: AccountType;
+};
+export type UpdateAccountProps = {
+    id: number;
+    accountTargetType?: AccountTargetType;
+    accountType?: AccountType;
+    data: {
+        account: {
+            name: string;
+            businessId: number;
+        };
+    };
+};
+export type RemoveAccountProps = {
+    accountTargetType?: AccountTargetType;
+    ids: number[];
+};
+export type GetDataTypeAccountProps = {
+    accountType?: AccountType;
+};
+export declare const AccountService: (props?: AccountServiceProps) => {
+    get: (props: GetAccountProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+    update: ({ id, data, accountType: overrideAccountType, accountTargetType: overrideAccountTargetType }: UpdateAccountProps) => Promise<{
+        status: boolean;
+        message: string;
+        data?: any;
+    }>;
+};

package/dist/services/account/AccountService.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountService = exports.accountTargetTypes = exports.accountTypes = void 0;
+const lib_1 = require("@/lib");
+const lib_2 = require("@/lib");
+exports.accountTypes = {
+    account: "account",
+};
+exports.accountTargetTypes = {
+    account: "account",
+};
+// const getCreatePayload = (accountType: AccountType, data: CreateAccountProps["data"]) => {
+//     if (accountType === "account") {
+//         return {
+//         }
+//     }
+// }
+const getUpdatePayload = (accountType, data) => {
+    if (accountType === "account" && "account" in data) {
+        return {
+            account: {
+                name: data.account.name,
+                business_id: data.account.businessId
+            }
+        };
+    }
+};
+const AccountService = (props) => {
+    const { accountType = "account", accountTargetType, ...rest } = props ?? {};
+    const { makeCall } = (0, lib_1.ApiService)(rest?.customToken ? { customToken: rest.customToken } : {});
+    const endpoint1 = "account";
+    const get = async (props) => {
+        const { id, accountType: overrideAccountType } = props;
+        const url = (0, lib_2.buildApiGetUrl)(`${endpoint1}/${overrideAccountType || accountType}/${id}`, props);
+        const response = await makeCall({
+            url,
+            method: "get",
+            payload: {},
+            // configuration
+        });
+        return response;
+    };
+    // const create = async ({ data, accountType: overrideAccountType, accountTargetType: overrideAccountTargetType }: CreateAccountProps) => {
+    //         let payload: any = {}
+    //         if (overrideAccountType) {
+    //             payload = getCreatePayload(overrideAccountType, data)
+    //         }
+    //         let url = `${endpoint1}`;
+    //         let postData = {
+    //             scope: {
+    //                 target: overrideAccountTargetType || accountTargetType,
+    //                 action: "",
+    //             },
+    //             payload
+    //         }
+    //         const response = await makeCall({
+    //             url,
+    //             method: "post",
+    //             payload: postData
+    //         });
+    //         return response;
+    // }
+    const update = async ({ id, data, accountType: overrideAccountType, accountTargetType: overrideAccountTargetType }) => {
+        let url = `${endpoint1}/${id}`;
+        // let payload: any = {}
+        // if (overrideAccountType) {
+        //     payload = getUpdatePayload(overrideAccountType, data)
+        // }
+        let _accountType = overrideAccountType || accountType;
+        let payload = getUpdatePayload(_accountType, data);
+        const postData = {
+            scope: {
+                target: overrideAccountTargetType || accountTargetType,
+                action: "",
+            },
+            payload
+        };
+        const response = await makeCall({
+            url,
+            method: "put",
+            payload: postData
+        });
+        return response;
+    };
+    // const remove = async ({ ids, accountTargetType: overrideAccountTargetType }: RemoveAccountProps) => {
+    //         let url = `${endpoint2}/delete`
+    //         const postData = {
+    //             scope: {
+    //                 target: overrideAccountTargetType || accountTargetType,
+    //             },
+    //             payload: {
+    //                 ids
+    //             }
+    //         }
+    //         const response = await makeCall({
+    //             url,
+    //             method: "post",
+    //             payload: postData
+    //         });
+    //         return response;
+    // }
+    // const getDataTypes = async ({ accountType: overrideAccountType }: GetDataTypeAccountProps) => {
+    //         let url = `${endpoint1}/data_types/${overrideAccountType || accountType}`
+    //         const response = await makeCall({
+    //             url,
+    //             method: "get",
+    //         });
+    //         return response;
+    // }
+    return {
+        // list,
+        get,
+        // create,
+        update,
+        // remove,
+        // getDataTypes
+    };
+};
+exports.AccountService = AccountService;