@chift/chift-nodejs 1.0.16 → 1.0.18

package/src/modules/consumer.ts

@@ -1,213 +0,0 @@
-import { operations, components } from '../types/public-api/schema';
-import { InternalAPI } from './internalApi';
-import { chiftOperations } from '../types/public-api/mappings';
-import { posFactory } from './pos';
-import { pmsFactory } from './pms';
-import { createApiFor } from '../helpers/openapi';
-import { accountingFactory } from './accounting';
-import { invoicingFactory } from './invoicing';
-import { ecommerceFactory } from './ecommerce';
-import { customFactory } from './custom';
-import { SimpleResponseModel } from '../types/sync';
-import { ConsumerLog } from '../types/consumers';
-
-const Consumer = (
-    internalApi: InternalAPI,
-    body: operations[chiftOperations['getConsumerById']]['responses'][200]['content']['application/json']
-) => {
-    const _internalApi = internalApi;
-    const data = body;
-    const consumerId = data.consumerid;
-    const name = data.name;
-    const redirect_url = data.redirect_url;
-    const email = data.email;
-    const pos = createApiFor(posFactory, _internalApi, data.name, consumerId);
-    const pms = createApiFor(pmsFactory, _internalApi, data.name, consumerId);
-    const accounting = createApiFor(accountingFactory, _internalApi, data.name, consumerId);
-    const invoicing = createApiFor(invoicingFactory, _internalApi, data.name, consumerId);
-    const ecommerce = createApiFor(ecommerceFactory, _internalApi, data.name, consumerId);
-    const custom = createApiFor(customFactory, _internalApi, data.name, consumerId);
-
-    const setConnectionId = async (connectionId: string) => {
-        _internalApi.connectionId = connectionId;
-    };
-
-    const setIntegrationId = async (integrationId: string) => {
-        _internalApi.integrationId = integrationId;
-    };
-
-    const getConnections = async () => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['getConnectionsByConsumerId']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.get(`/consumers/${consumerId}/connections`);
-        return data;
-    };
-
-    const createConnection = async (
-        body?: components['schemas']['app__routers__connections__PostConnectionItem']
-    ) => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['createConnection']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.post(`/consumers/${consumerId}/connections`, { ...body });
-        return data;
-    };
-
-    const updateConnection = async (
-        connectionId: string,
-        body?: components['schemas']['PatchConnectionItem']
-    ) => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['updateConnection']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.patch(`/consumers/${consumerId}/connections/${connectionId}`, {
-            ...body,
-        });
-        return data;
-    };
-
-    const deleteConnection = async (connectionId: string) => {
-        const {
-            data,
-        }: { data: operations[chiftOperations['deleteConnectionById']]['responses'][204] } =
-            await _internalApi.delete(`/consumers/${consumerId}/connections/${connectionId}`);
-        return data;
-    };
-
-    const getSyncUrl = async (body: components['schemas']['CreateConsumerSyncItem']) => {
-        const { data }: { data: components['schemas']['LinkSyncItem'] } = await _internalApi.post(
-            `/consumers/${consumerId}/syncs`,
-            body
-        );
-        return data;
-    };
-
-    const getSyncData = async (syncId: string) => {
-        const { data }: { data: components['schemas']['SyncConsumerItem'] } =
-            await _internalApi.get(`/consumers/${consumerId}/syncs/${syncId}`);
-        return data;
-    };
-
-    const enableFlow = async (
-        syncId: string,
-        flowId: string,
-        body: components['schemas']['EnableFlowConsumer']
-    ) => {
-        const { data }: { data: SimpleResponseModel } = await _internalApi.post(
-            `/consumers/${consumerId}/syncs/${syncId}/flows/${flowId}/enable`,
-            body
-        );
-        return data;
-    };
-
-    const getDataByDataStoreName = async (dataStoreName: string, params?: object) => {
-        const { data }: { data: components['schemas']['DataStoreItem'][] } = await _internalApi.get(
-            `/datastores`
-        );
-        for (let i = 0; i < data.length; i++) {
-            if (data[i].name == dataStoreName) {
-                return await getDataByDataStoreId(data[i].id, params);
-            }
-        }
-        throw Error('Datastore could not be found');
-    };
-
-    const getDataByDataStoreId = async (dataStoreId: string, params?: object) => {
-        const { data }: { data: components['schemas']['DataItemOut'][] } = await _internalApi.get(
-            `/consumers/${consumerId}/datastore/${dataStoreId}/data`,
-            { params: params }
-        );
-        return data;
-    };
-
-    const addDataByDataStoreId = async (
-        dataStoreId: string,
-        data: components['schemas']['DataItem'][]
-    ) => {
-        const { data: response }: { data: components['schemas']['DataItemOut'][] } =
-            await _internalApi.post(`/consumers/${consumerId}/datastore/${dataStoreId}/data`, data);
-        return response;
-    };
-
-    const addDataByDataStoreName = async (
-        dataStoreName: string,
-        data: components['schemas']['DataItem'][]
-    ) => {
-        const { data: datastores }: { data: components['schemas']['DataStoreItem'][] } =
-            await _internalApi.get(`/datastores`);
-        for (let i = 0; i < datastores.length; i++) {
-            if (datastores[i].name == dataStoreName) {
-                return await addDataByDataStoreId(datastores[i].id, data);
-            }
-        }
-    };
-
-    const updateDataStoreData = async (
-        dataStoreId: string,
-        dataStoreDataId: string,
-        data: components['schemas']['DataItem']
-    ) => {
-        const { data: response }: { data: components['schemas']['DataItemOut'][] } =
-            await _internalApi.patch(
-                `/consumers/${consumerId}/datastore/${dataStoreId}/data/${dataStoreDataId}`,
-                data
-            );
-        return response;
-    };
-
-    const deleteDataStoreData = async (dataStoreId: string, dataStoreDataId: string) => {
-        const { data: response }: { data: SimpleResponseModel } = await _internalApi.delete(
-            `/consumers/${consumerId}/datastore/${dataStoreId}/data/${dataStoreDataId}`
-        );
-        return response;
-    };
-
-    /**
-     * This function is used to add logs related to a chainexecution (passed in the header)
-     * INTERNAL USE only
-     * @param logs
-     * @returns
-     */
-    const logData = async (logs: ConsumerLog[]) => {
-        const { data: response }: { data: SimpleResponseModel } = await _internalApi.post(
-            `/consumers/${consumerId}/logs`,
-            logs
-        );
-        return response;
-    };
-
-    return {
-        consumerId,
-        getConnections,
-        createConnection,
-        updateConnection,
-        deleteConnection,
-        enableFlow,
-        getSyncUrl,
-        name,
-        redirect_url,
-        email,
-        pos,
-        pms,
-        accounting,
-        invoicing,
-        ecommerce,
-        custom,
-        getDataByDataStoreId,
-        addDataByDataStoreId,
-        getSyncData,
-        getDataByDataStoreName,
-        addDataByDataStoreName,
-        updateDataStoreData,
-        deleteDataStoreData,
-        logData,
-        setConnectionId,
-        setIntegrationId,
-    };
-};
-
-export { Consumer };

package/src/modules/consumers.ts

@@ -1,82 +0,0 @@
-import { operations } from '../types/public-api/schema';
-import { InternalAPI } from './internalApi';
-import { Consumer } from './consumer';
-import { chiftOperations } from '../types/public-api/mappings';
-
-const Consumers = (internalApi: InternalAPI) => {
-    const _internalApi: InternalAPI = internalApi;
-
-    const getConsumers = async () => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['getConsumers']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.get('/consumers');
-        return data.map((consumer) => Consumer(_internalApi, consumer));
-    };
-
-    const createConsumer = async (
-        body: operations[chiftOperations['createConsumer']]['requestBody']['content']['application/json']
-    ) => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['createConsumer']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.post('/consumers', body);
-        return Consumer(_internalApi, data);
-    };
-
-    const getConsumerById = async (consumerId: string) => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['getConsumerById']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.get(`/consumers/${consumerId}`);
-        return Consumer(_internalApi, { ...data });
-    };
-
-    const getConsumersByName = async (consumerName: string) => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['getConsumers']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.get('/consumers');
-        return data
-            .filter(
-                (consumer) =>
-                    consumer.name.toLowerCase().indexOf(consumerName.toLocaleLowerCase()) !== -1
-            )
-            .map((consumer) => Consumer(_internalApi, consumer));
-    };
-
-    const updateConsumerById = async (
-        consumerId: string,
-        body: operations[chiftOperations['updateConsumer']]['requestBody']['content']['application/json']
-    ) => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['updateConsumer']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.patch(`/consumers/${consumerId}`, body);
-        return Consumer(_internalApi, data);
-    };
-
-    const deleteConsumerById = async (consumerId: string) => {
-        const {
-            data,
-        }: { data: operations[chiftOperations['deleteConsumerById']]['responses'][204] } =
-            await _internalApi.delete(`/consumers/${consumerId}`);
-        return data;
-    };
-
-    return {
-        getConsumers,
-        createConsumer,
-        getConsumerById,
-        getConsumersByName,
-        updateConsumerById,
-        deleteConsumerById,
-    };
-};
-
-export { Consumers };

package/src/modules/custom.ts

@@ -1,36 +0,0 @@
-import { RequestData } from '../types/api';
-
-const customFactory = {
-    get(name: string, resource: string, params?: any): RequestData<any> {
-        return {
-            method: 'get',
-            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
-            params: params,
-        };
-    },
-    post(name: string, resource: string, body: any, params?: any): RequestData<any> {
-        return {
-            method: 'post',
-            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
-            body: body,
-            params: params,
-        };
-    },
-    patch(name: string, resource: string, body: any, params?: any): RequestData<any> {
-        return {
-            method: 'patch',
-            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
-            body: body,
-            params: params,
-        };
-    },
-    delete(name: string, resource: string, params?: any): RequestData<any> {
-        return {
-            method: 'delete',
-            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
-            params: params,
-        };
-    },
-};
-
-export { customFactory };

package/src/modules/datastores.ts

@@ -1,19 +0,0 @@
-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

@@ -1,127 +0,0 @@
-import { operations, components } from '../types/public-api/schema';
-import { AutoPaginatedParams, RequestData } from '../types/api';
-
-type GetOrdersParams = AutoPaginatedParams<
-    operations['ecommerce_get_orders']['parameters']['query']
->;
-
-type GetPaymentMethodsParams = AutoPaginatedParams<
-    operations['ecommerce_get_payments_methods']['parameters']['query']
->;
-
-type GetProductCategoriesParams = AutoPaginatedParams<
-    operations['ecommerce_get_product_categories']['parameters']['query']
->;
-
-type GetTaxesParams = AutoPaginatedParams<operations['ecommerce_get_taxes']['parameters']['query']>;
-
-type GetCountriesParams = AutoPaginatedParams<
-    operations['ecommerce_get_countries']['parameters']['query']
->;
-
-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}`,
-        };
-    },
-    getPaymentMethods(
-        params?: GetPaymentMethodsParams
-    ): RequestData<components['schemas']['PaymentMethodItem'][]> {
-        return {
-            params,
-            method: 'get',
-            url: `/consumers/{consumer_id}/commerce/payment-methods`,
-        };
-    },
-    getProductCategories(
-        params?: GetProductCategoriesParams
-    ): RequestData<components['schemas']['CategoryItem'][]> {
-        return {
-            params,
-            method: 'get',
-            url: `/consumers/{consumer_id}/commerce/product-categories`,
-        };
-    },
-    getTaxes(params?: GetTaxesParams): RequestData<components['schemas']['TaxRateItem'][]> {
-        return {
-            params,
-            method: 'get',
-            url: `/consumers/{consumer_id}/commerce/taxes`,
-        };
-    },
-    getCountries(params?: GetCountriesParams): RequestData<components['schemas']['CountryItem'][]> {
-        return {
-            params,
-            method: 'get',
-            url: `/consumers/{consumer_id}/commerce/countries`,
-        };
-    },
-};
-
-export { ecommerceFactory };

package/src/modules/flow.ts

@@ -1,168 +0,0 @@
-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,
-            triggers: data.triggers,
-            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

@@ -1,24 +0,0 @@
-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 (
-        params: operations[chiftOperations['getIntegrations']]['parameters']['query'] = {}
-    ) => {
-        const {
-            data,
-        }: {
-            data: operations[chiftOperations['getIntegrations']]['responses'][200]['content']['application/json'];
-        } = await _internalApi.get('/integrations', { params });
-        return data;
-    };
-
-    return {
-        getIntegrations,
-    };
-};
-
-export { Integrations };