@chift/chift-nodejs 0.0.1

package/src/modules/datastores.ts

@@ -0,0 +1,19 @@
+import { components } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+
+const DataStores = (internalApi: InternalAPI) => {
+    const _internalApi: InternalAPI = internalApi;
+
+    const getDataStores = async () => {
+        const { data }: { data: components['schemas']['DataStoreItem'][] } = await _internalApi.get(
+            '/datastores'
+        );
+        return data;
+    };
+
+    return {
+        getDataStores,
+    };
+};
+
+export { DataStores };

package/src/modules/ecommerce.ts

@@ -0,0 +1,82 @@
+import { operations, components } from '../types/public-api/schema';
+import { RequestData } from '../types/api';
+
+type getOrdersParams = Omit<
+    operations['ecommerce_get_orders']['parameters']['query'],
+    'page' | 'size'
+>;
+
+const ecommerceFactory = {
+    getCustomers(): RequestData<components['schemas']['CommerceCustomerItem'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/customers',
+        };
+    },
+    getProducts(): RequestData<components['schemas']['app__routers__commerce__ProductItem'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/products',
+        };
+    },
+    getCustomer(customerId: string): RequestData<components['schemas']['CommerceCustomerItem']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/customers/${customerId}`,
+        };
+    },
+    getProduct(
+        productId: string
+    ): RequestData<components['schemas']['app__routers__commerce__ProductItem']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/products/${productId}`,
+        };
+    },
+    getProductVariantById(variantId: string): RequestData<components['schemas']['VariantItem']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/variants/${variantId}`,
+        };
+    },
+    updateAvailableQuantity(
+        variantId: string,
+        inventoryDetails: components['schemas']['InventoryDetailsUpdate']
+    ): RequestData<components['schemas']['InventoryDetailsItem']> {
+        return {
+            method: 'post',
+            url: `/consumers/{consumer_id}/commerce/variants/set_quantity/${variantId}`,
+            body: inventoryDetails,
+        };
+    },
+    getLocations(): RequestData<components['schemas']['CommerceLocationItem'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/locations',
+        };
+    },
+    getOrders(params: getOrdersParams): RequestData<components['schemas']['OrderItemOut'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/orders',
+            params: params,
+        };
+    },
+    createOrder(
+        order: components['schemas']['OrderItemIn']
+    ): RequestData<components['schemas']['OrderItemOut']> {
+        return {
+            method: 'post',
+            url: `/consumers/{consumer_id}/commerce/orders`,
+            body: order,
+        };
+    },
+    getOrder(orderId: string): RequestData<components['schemas']['OrderItemOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/orders/${orderId}`,
+        };
+    },
+};
+
+export { ecommerceFactory };

package/src/modules/flow.ts

@@ -0,0 +1,168 @@
+import { components } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+import { Consumers } from './consumers';
+import { Consumer } from './consumer';
+import { SimpleResponseModel } from '../types/sync';
+
+const Flow = (
+    internalApi: any,
+    body: components['schemas']['ReadFlowItem'],
+    syncid: string,
+    consumers: string[],
+    process?: (consumer: any, context: any) => any
+) => {
+    const _internalApi: InternalAPI = internalApi;
+    const data: components['schemas']['ReadFlowItem'] = body;
+    const _syncid = syncid;
+    const _consumers = consumers;
+    const _process = process;
+
+    const sendEvent = async (payload: components['schemas']['PostSyncFlowEvent']) => {
+        const { data: response }: { data: components['schemas']['TriggerResponse'] } =
+            await _internalApi.post(`/syncs/${_syncid}/flows/${data.id}/event`, payload);
+        return response;
+    };
+
+    const getExecution = async (executionId: string) => {
+        const { data: response }: { data: components['schemas']['ChainExecutionItem'] } =
+            await _internalApi.get(`/syncs/${_syncid}/flows/${data.id}/executions/${executionId}`);
+        return response;
+    };
+
+    /**
+     * Internal use: Function used to execute a flow while testing locally or by calling the sendEvent function
+     */
+    const execute = async ({ testData = {}, context = {} }: any) => {
+        // first create the process in Chift (it will check if it's already created or not and execute it)
+        await _internalApi.post(`/syncs/${_syncid}/flows`, {
+            name: data.name,
+            description: data.description,
+            execution: data.execution,
+            trigger: data.trigger,
+            config: data.config,
+        });
+        // execute locally or remotely by sending an event to execute the flow
+        if (context.local) {
+            // when you execute locally you need to have a process defined
+            const logs = context.logs || false;
+            if (_process) executeLocal(_process, logs);
+            else throw Error('Process is not defined it cannot be executed');
+        } else {
+            await sendEvent(testData);
+        }
+    };
+
+    /**
+     * Internal use: Function used to execute a flow locally based on the configured consumers.
+     */
+    const localExecution = async (process: (consumer: any, context: any) => any) => {
+        _internalApi.debug = true;
+        for (let i = 0; i < _consumers.length; i++) {
+            // we do not care about the customer
+            let consumer;
+            try {
+                consumer = await Consumers(_internalApi).getConsumerById(_consumers[i]);
+            } catch (err) {
+                console.log(
+                    `Cannot run for consumer ${_consumers[i]} as it cannot be found; probably part of an external account ? Use the platform to debug.`
+                );
+            }
+            if (consumer) {
+                const syncData = await consumer.getSyncData(_syncid);
+                const flow = syncData.enabled_flows?.find((flow) => flow.id === data.id);
+                if (flow && syncData.status === 'active') {
+                    const context = {
+                        ...syncData,
+                        flow_id: flow.id,
+                        flow_name: flow.name,
+                        flow_values: flow.values,
+                        flow_config: flow.config,
+                    };
+                    delete context['enabled_flows'];
+                    await process(consumer, context);
+                } else {
+                    console.log(
+                        `Cannot run for consumer ${_consumers[i]} as the flow is not activated or not correctly configured`
+                    );
+                }
+            }
+        }
+        _internalApi.debug = false;
+    };
+
+    /**
+     * Internal use: Function used to execute a flow locally for debugging purposes. It will create the executions server-side on Chift to be able to follow-up the execution through Chift's UI.
+     * It will call localExecution to execute the flow for the configured consumers
+     */
+    const executeLocal = async (
+        process: (consumer: typeof Consumer, context: any) => any,
+        log = false
+    ) => {
+        if (log) {
+            // create executions on the platform to add the logs to the server
+            const { data: response }: { data: SimpleResponseModel } = await _internalApi.post(
+                `/syncs/${_syncid}/flows/${data.id}/local`,
+                { type: 'START' }
+            );
+            if (response.data) {
+                const { executionid, chainexecutionid } = response.data;
+                _internalApi.setRelatedChainExecutionId(chainexecutionid);
+                try {
+                    await localExecution(process);
+                    await _internalApi.post(`/syncs/${_syncid}/flows/${data.id}/local`, {
+                        type: 'END',
+                        executionid: executionid,
+                        chainexecutionid: chainexecutionid,
+                    });
+                } catch (err: any) {
+                    if (err.error) {
+                        // it's an error from the one api
+                        const error_message = `Error when executing request with url ${err.url} for consumer ${err.consumerName} (${err.consumerId})`;
+                        console.log(`[ERROR]: ${error_message}: ${JSON.stringify(err.error)}`);
+                        await _internalApi.post(`/syncs/${_syncid}/flows/${data.id}/local`, {
+                            type: 'END',
+                            executionid: executionid,
+                            chainexecutionid: chainexecutionid,
+                            error: true,
+                            error_message: error_message,
+                            technical_error_message: JSON.stringify(err.error),
+                        });
+                    } else {
+                        console.log('[ERROR]: ' + err.toString());
+                        await _internalApi.post(`/syncs/${_syncid}/flows/${data.id}/local`, {
+                            type: 'END',
+                            executionid: executionid,
+                            chainexecutionid: chainexecutionid,
+                            error: true,
+                            technical_error_message: err.toString(),
+                        });
+                    }
+                }
+                _internalApi.setRelatedChainExecutionId('');
+            } else {
+                throw Error('Execution could not be executed');
+            }
+        } else {
+            try {
+                await localExecution(process);
+            } catch (err: any) {
+                if (err.error) {
+                    const error_message = `Error when executing request with url ${err.url} for consumer ${err.consumerName} (${err.consumerId})`;
+                    console.log(`[ERROR] ${error_message}: ${JSON.stringify(err.error)}`);
+                } else {
+                    console.log('[ERROR]: ' + err.toString());
+                }
+            }
+        }
+    };
+
+    return {
+        execute,
+        getExecution,
+        executeLocal,
+        flowId: data.id,
+        name: data.name,
+    };
+};
+
+export { Flow };

package/src/modules/integrations.ts

@@ -0,0 +1,22 @@
+import { operations } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+import { chiftOperations } from '../types/public-api/mappings';
+
+const Integrations = (internalApi: InternalAPI) => {
+    const _internalApi: InternalAPI = internalApi;
+
+    const getIntegrations = async () => {
+        const {
+            data,
+        }: {
+            data: operations[chiftOperations['getIntegrations']]['responses'][200]['content']['application/json'];
+        } = await _internalApi.get('/integrations');
+        return data;
+    };
+
+    return {
+        getIntegrations,
+    };
+};
+
+export { Integrations };

package/src/modules/internalApi.ts

@@ -0,0 +1,162 @@
+import axios, { AxiosInstance } from 'axios';
+import { AuthType, TokenType, RequestData } from '../types/api';
+import Settings from '../helpers/settings';
+
+class InternalAPI {
+    instance: AxiosInstance;
+    auth: AuthType;
+    token?: TokenType;
+    debug = false;
+    relatedChainExecutionId?: string;
+    get;
+    post;
+    patch;
+    delete;
+
+    constructor(auth: AuthType) {
+        // add interceptor
+        this.auth = auth;
+        this.instance = axios.create({
+            baseURL: this.auth.baseUrl || Settings.BASE_URL,
+        });
+        this.get = this.instance.get;
+        this.post = this.instance.post;
+        this.patch = this.instance.patch;
+        this.delete = this.instance.delete;
+
+        this.instance.interceptors.request.use(
+            (config) => {
+                return new Promise((resolve) => {
+                    if (this.relatedChainExecutionId) {
+                        config.headers['X-Chift-RelatedChainExecutionId'] =
+                            this.relatedChainExecutionId;
+                    }
+                    if (this.token) {
+                        if (this.token?.expires_on < new Date().getTime()) {
+                            return this.getToken().then(() => {
+                                config.headers['Authorization'] =
+                                    'Bearer ' + this.token?.access_token;
+                                return resolve(config);
+                            });
+                        } else {
+                            config.headers['Authorization'] = 'Bearer ' + this.token?.access_token;
+                            return resolve(config);
+                        }
+                    } else {
+                        return this.getToken().then(() => {
+                            config.headers['Authorization'] = 'Bearer ' + this.token?.access_token;
+                            return resolve(config);
+                        });
+                    }
+                });
+            },
+            function (error) {
+                // Do something with request error
+                return Promise.reject(error);
+            }
+        );
+    }
+
+    getToken = async () => {
+        try {
+            const tokenData: AuthType = {
+                clientId: this.auth.clientId,
+                clientSecret: this.auth.clientSecret,
+                accountId: this.auth.accountId,
+            };
+            if (this.auth.envId) {
+                tokenData['envId'] = this.auth.envId;
+            }
+            const res = await axios.post(
+                `${this.auth.baseUrl || Settings.BASE_URL}/token`,
+                tokenData
+            );
+            this.token = res.data;
+        } catch (err: any) {
+            if (axios.isAxiosError(err)) {
+                if (err.response) {
+                    if (err.response.status === 401) {
+                        throw new Error('The provided credentials are not correct');
+                    }
+                }
+            }
+        }
+    };
+
+    getPaginationParams = (currPage: number) => {
+        return {
+            page: currPage,
+            size: 100,
+        };
+    };
+
+    public setRelatedChainExecutionId(chainExecutionId: string) {
+        this.relatedChainExecutionId = chainExecutionId;
+    }
+
+    public async makeRequest<TResponse>(requestData: RequestData<TResponse>) {
+        try {
+            if (this.debug) {
+                console.log(
+                    `[DEBUG]: Executing operation ${requestData?.property} with url ${requestData.url} for consumer: ${requestData.consumerName}`
+                );
+            }
+            let continuePagination = true;
+            let items: any[] = [];
+            let currentPage = 0;
+            while (continuePagination) {
+                currentPage++;
+                let params = requestData.params || {};
+                if (requestData.method === 'get') {
+                    params = {
+                        ...params,
+                        ...this.getPaginationParams(currentPage),
+                    };
+                }
+                const res = await this.instance({
+                    url: requestData.url,
+                    method: requestData.method,
+                    params: params,
+                    data: requestData.body !== undefined ? requestData.body : undefined,
+                });
+                const { data } = res;
+                if (data) {
+                    if (requestData.method === 'get' && 'total' in data && 'items' in data) {
+                        if (currentPage * 100 > data.total) {
+                            continuePagination = false;
+                        }
+                    } else {
+                        if (this.debug) {
+                            console.log(`[DEBUG]: Data received: ${JSON.stringify(data)}`);
+                        }
+                        return data;
+                    }
+                    items = items.concat(data.items);
+                } else {
+                    return null;
+                }
+            }
+            if (this.debug) {
+                console.log(`[DEBUG]: Data received: ${JSON.stringify(items)}`);
+            }
+            return items;
+        } catch (e: any) {
+            if (e.response) {
+                if (e.response.data) {
+                    const error = { ...e.response.data, status_code: e.response.status };
+                    const fullerror = {
+                        error,
+                        consumerId: requestData.consumerId,
+                        consumerName: requestData.consumerName,
+                        url: requestData.url,
+                    };
+                    //return error as TResponse;
+                    throw fullerror;
+                }
+            }
+            throw e;
+        }
+    }
+}
+
+export { InternalAPI };

package/src/modules/invoicing.ts

@@ -0,0 +1,106 @@
+import { components, operations } from '../types/public-api/schema';
+import { RequestData } from '../types/api';
+
+const invoicingFactory = {
+    getInvoices(
+        params: operations['invoicing_get_invoices']['parameters']['query']
+    ): RequestData<components['schemas']['InvoiceItemOut'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/invoices`,
+            params: params,
+        };
+    },
+    getInvoiceById(
+        invoiceId: string,
+        params: operations['invoicing_get_invoice']['parameters']['query']
+    ): RequestData<components['schemas']['InvoiceItemOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/invoices/${invoiceId}`,
+            params: params,
+        };
+    },
+    createInvoice(
+        invoice: components['schemas']['InvoiceItem']
+    ): RequestData<components['schemas']['InvoiceItemOut']> {
+        return {
+            method: 'create',
+            url: `/consumers/{consumer_id}/invoicing/invoices`,
+            body: invoice,
+        };
+    },
+    getProducts(): RequestData<components['schemas']['ProductItemOut'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/products`,
+        };
+    },
+    getProductById(productId: string): RequestData<components['schemas']['ProductItemOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/products/${productId}`,
+        };
+    },
+    createProduct(
+        product: components['schemas']['models__invoicing__ProductItem']
+    ): RequestData<components['schemas']['ProductItemOut']> {
+        return {
+            method: 'create',
+            url: `/consumers/{consumer_id}/invoicing/products`,
+            body: product,
+        };
+    },
+    getTaxes(): RequestData<components['schemas']['models__invoicing__VatCode'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/taxes`,
+        };
+    },
+    getTaxById(taxId: string): RequestData<components['schemas']['models__invoicing__VatCode']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/taxes/${taxId}`,
+        };
+    },
+    getOpportunities(): RequestData<components['schemas']['OpportunityItem'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/opportunities`,
+        };
+    },
+    getOpportunitiesById(
+        opportunityId: string
+    ): RequestData<components['schemas']['OpportunityItem']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/opportunities/${opportunityId}`,
+        };
+    },
+    getContacts(
+        params?: operations['invoicing_get_contacts']['parameters']['query']
+    ): RequestData<components['schemas']['ContactItemOut'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/contacts`,
+            params: params,
+        };
+    },
+    getContactById(contactId: string): RequestData<components['schemas']['ContactItemOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/invoicing/contacts/${contactId}`,
+        };
+    },
+    createContact(
+        contact: components['schemas']['ContactItemIn']
+    ): RequestData<components['schemas']['ContactItemOut']> {
+        return {
+            method: 'create',
+            url: `/consumers/{consumer_id}/invoicing/contacts`,
+            body: contact,
+        };
+    },
+};
+
+export { invoicingFactory };

package/src/modules/pos.ts

@@ -0,0 +1,112 @@
+import { operations, components } from '../types/public-api/schema';
+import { RequestData } from '../types/api';
+
+type getPaymentsParams = Omit<
+    operations['pos_get_payments']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getPaymentMethodsParams = Omit<
+    operations['pos_get_payments_methods']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getCustomersParams = Omit<
+    operations['pos_get_customers']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getOrdersParams = Omit<operations['pos_get_orders']['parameters']['query'], 'page' | 'size'>;
+
+const posFactory = {
+    getLocations(): RequestData<components['schemas']['POSLocationItem'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/pos/locations',
+        };
+    },
+    getOrders(params: getOrdersParams): RequestData<components['schemas']['OrderItem'][]> {
+        return {
+            params,
+            method: 'get',
+            url: '/consumers/{consumer_id}/pos/orders',
+        };
+    },
+    getCustomers(
+        params: getCustomersParams
+    ): RequestData<components['schemas']['POSCustomerItem'][]> {
+        return {
+            params,
+            method: 'get',
+            url: '/consumers/{consumer_id}/pos/customers',
+        };
+    },
+    getOrder(orderId: string): RequestData<components['schemas']['OrderItem']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/pos/orders/${orderId}`,
+        };
+    },
+    getCustomer(customerId: string): RequestData<components['schemas']['POSCustomerItem']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/pos/customers/${customerId}`,
+        };
+    },
+    createCustomer(
+        customer: components['schemas']['POSCreateCustomerItem']
+    ): RequestData<components['schemas']['POSCustomerItem']> {
+        return {
+            method: 'create',
+            url: `/consumers/{consumer_id}/pos/customers`,
+            body: customer,
+        };
+    },
+    getPaymentMethods(
+        params: getPaymentMethodsParams
+    ): RequestData<components['schemas']['PaymentMethods'][]> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/pos/payment-methods`,
+        };
+    },
+    getSales(
+        params: operations['pos_get_sales']['parameters']['query']
+    ): RequestData<components['schemas']['SalesItem']> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/pos/sales`,
+        };
+    },
+    getClosure(
+        date: string,
+        params: operations['pos_get_closure']['parameters']['query']
+    ): RequestData<components['schemas']['ClosureItem']> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/pos/closures/${date}`,
+        };
+    },
+    getPayments(params: getPaymentsParams): RequestData<components['schemas']['PaymentItem'][]> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/pos/payments`,
+        };
+    },
+    updateOrder(
+        orderId: string,
+        order: components['schemas']['UpdateOrderItem']
+    ): RequestData<components['schemas']['OrderItem']> {
+        return {
+            method: 'patch',
+            url: `/consumers/{consumer_id}/pos/orders/${orderId}`,
+            body: order,
+        };
+    },
+};
+
+export { posFactory };