@chift/chift-nodejs 1.0.18 → 1.0.19

package/dist/src/modules/consumers.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumers = void 0;
+const consumer_1 = require("./consumer");
+const Consumers = (internalApi) => {
+    const _internalApi = internalApi;
+    const getConsumers = () => __awaiter(void 0, void 0, void 0, function* () {
+        const { data, } = yield _internalApi.get('/consumers');
+        return data.map((consumer) => (0, consumer_1.Consumer)(_internalApi, consumer));
+    });
+    const createConsumer = (body) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data, } = yield _internalApi.post('/consumers', body);
+        return (0, consumer_1.Consumer)(_internalApi, data);
+    });
+    const getConsumerById = (consumerId) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data, } = yield _internalApi.get(`/consumers/${consumerId}`);
+        return (0, consumer_1.Consumer)(_internalApi, Object.assign({}, data));
+    });
+    const getConsumersByName = (consumerName) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data, } = yield _internalApi.get('/consumers');
+        return data
+            .filter((consumer) => consumer.name.toLowerCase().indexOf(consumerName.toLocaleLowerCase()) !== -1)
+            .map((consumer) => (0, consumer_1.Consumer)(_internalApi, consumer));
+    });
+    const updateConsumerById = (consumerId, body) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data, } = yield _internalApi.patch(`/consumers/${consumerId}`, body);
+        return (0, consumer_1.Consumer)(_internalApi, data);
+    });
+    const deleteConsumerById = (consumerId) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data, } = yield _internalApi.delete(`/consumers/${consumerId}`);
+        return data;
+    });
+    return {
+        getConsumers,
+        createConsumer,
+        getConsumerById,
+        getConsumersByName,
+        updateConsumerById,
+        deleteConsumerById,
+    };
+};
+exports.Consumers = Consumers;

package/dist/src/modules/custom.d.ts

@@ -0,0 +1,8 @@
+import { RequestData } from '../types/api';
+declare const customFactory: {
+    get(name: string, resource: string, params?: any): RequestData<any>;
+    post(name: string, resource: string, body: any, params?: any): RequestData<any>;
+    patch(name: string, resource: string, body: any, params?: any): RequestData<any>;
+    delete(name: string, resource: string, params?: any): RequestData<any>;
+};
+export { customFactory };

package/dist/src/modules/custom.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customFactory = void 0;
+const customFactory = {
+    get(name, resource, params) {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
+            params: params,
+        };
+    },
+    post(name, resource, body, params) {
+        return {
+            method: 'post',
+            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
+            body: body,
+            params: params,
+        };
+    },
+    patch(name, resource, body, params) {
+        return {
+            method: 'patch',
+            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
+            body: body,
+            params: params,
+        };
+    },
+    delete(name, resource, params) {
+        return {
+            method: 'delete',
+            url: `/consumers/{consumer_id}/custom/${name}/${resource}`,
+            params: params,
+        };
+    },
+};
+exports.customFactory = customFactory;

package/dist/src/modules/datastores.d.ts

@@ -0,0 +1,18 @@
+import { InternalAPI } from './internalApi';
+declare const DataStores: (internalApi: InternalAPI) => {
+    getDataStores: () => Promise<{
+        id: string;
+        name: string;
+        status: "active" | "inactive";
+        definition: {
+            columns: {
+                name: string;
+                title: string;
+                type: string;
+                optional: boolean;
+            }[];
+            search_column?: string | undefined;
+        };
+    }[]>;
+};
+export { DataStores };

package/dist/src/modules/datastores.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStores = void 0;
+const DataStores = (internalApi) => {
+    const _internalApi = internalApi;
+    const getDataStores = () => __awaiter(void 0, void 0, void 0, function* () {
+        const { data } = yield _internalApi.get('/datastores');
+        return data;
+    });
+    return {
+        getDataStores,
+    };
+};
+exports.DataStores = DataStores;

package/dist/src/modules/ecommerce.d.ts

@@ -0,0 +1,24 @@
+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']>;
+declare const ecommerceFactory: {
+    getCustomers(): RequestData<components['schemas']['CommerceCustomerItem'][]>;
+    getProducts(): RequestData<components['schemas']['backbone_api__app__routers__commerce__ProductItem'][]>;
+    getCustomer(customerId: string): RequestData<components['schemas']['CommerceCustomerItem']>;
+    getProduct(productId: string): RequestData<components['schemas']['backbone_api__app__routers__commerce__ProductItem']>;
+    getProductVariantById(variantId: string): RequestData<components['schemas']['VariantItem']>;
+    updateAvailableQuantity(variantId: string, inventoryDetails: components['schemas']['InventoryDetailsUpdate']): RequestData<components['schemas']['InventoryDetailsItem']>;
+    getLocations(): RequestData<components['schemas']['CommerceLocationItem'][]>;
+    getOrders(params?: GetOrdersParams): RequestData<components['schemas']['OrderItemOut'][]>;
+    createOrder(order: components['schemas']['OrderItemIn']): RequestData<components['schemas']['OrderItemOut']>;
+    getOrder(orderId: string): RequestData<components['schemas']['OrderItemOut']>;
+    getPaymentMethods(params?: GetPaymentMethodsParams): RequestData<components['schemas']['PaymentMethodItem'][]>;
+    getProductCategories(params?: GetProductCategoriesParams): RequestData<components['schemas']['CategoryItem'][]>;
+    getTaxes(params?: GetTaxesParams): RequestData<components['schemas']['TaxRateItem'][]>;
+    getCountries(params?: GetCountriesParams): RequestData<components['schemas']['CountryItem'][]>;
+};
+export { ecommerceFactory };

package/dist/src/modules/ecommerce.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ecommerceFactory = void 0;
+const ecommerceFactory = {
+    getCustomers() {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/customers',
+        };
+    },
+    getProducts() {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/products',
+        };
+    },
+    getCustomer(customerId) {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/customers/${customerId}`,
+        };
+    },
+    getProduct(productId) {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/products/${productId}`,
+        };
+    },
+    getProductVariantById(variantId) {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/variants/${variantId}`,
+        };
+    },
+    updateAvailableQuantity(variantId, inventoryDetails) {
+        return {
+            method: 'post',
+            url: `/consumers/{consumer_id}/commerce/variants/set_quantity/${variantId}`,
+            body: inventoryDetails,
+        };
+    },
+    getLocations() {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/locations',
+        };
+    },
+    getOrders(params) {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/commerce/orders',
+            params: params,
+        };
+    },
+    createOrder(order) {
+        return {
+            method: 'post',
+            url: `/consumers/{consumer_id}/commerce/orders`,
+            body: order,
+        };
+    },
+    getOrder(orderId) {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/orders/${orderId}`,
+        };
+    },
+    getPaymentMethods(params) {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/payment-methods`,
+        };
+    },
+    getProductCategories(params) {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/product-categories`,
+        };
+    },
+    getTaxes(params) {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/taxes`,
+        };
+    },
+    getCountries(params) {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/commerce/countries`,
+        };
+    },
+};
+exports.ecommerceFactory = ecommerceFactory;

package/dist/src/modules/flow.d.ts

@@ -0,0 +1,15 @@
+import { components } from '../types/public-api/schema';
+import { Consumer } from './consumer';
+declare const Flow: (internalApi: any, body: components['schemas']['ReadFlowItem'], syncid: string, consumers: string[], process?: ((consumer: any, context: any) => any) | undefined) => {
+    execute: ({ testData, context }: any) => Promise<void>;
+    getExecution: (executionId: string) => Promise<{
+        id: string;
+        start: string;
+        end?: string | undefined;
+        status: string;
+    }>;
+    executeLocal: (process: (consumer: typeof Consumer, context: any) => any, log?: boolean) => Promise<void>;
+    flowId: string;
+    name: string;
+};
+export { Flow };

package/dist/src/modules/flow.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flow = void 0;
+const consumers_1 = require("./consumers");
+const Flow = (internalApi, body, syncid, consumers, process) => {
+    const _internalApi = internalApi;
+    const data = body;
+    const _syncid = syncid;
+    const _consumers = consumers;
+    const _process = process;
+    const sendEvent = (payload) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data: response } = yield _internalApi.post(`/syncs/${_syncid}/flows/${data.id}/event`, payload);
+        return response;
+    });
+    const getExecution = (executionId) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data: response } = yield _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 = ({ testData = {}, context = {} }) => __awaiter(void 0, void 0, void 0, function* () {
+        // first create the process in Chift (it will check if it's already created or not and execute it)
+        yield _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 {
+            yield sendEvent(testData);
+        }
+    });
+    /**
+     * Internal use: Function used to execute a flow locally based on the configured consumers.
+     */
+    const localExecution = (process) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        _internalApi.debug = true;
+        for (let i = 0; i < _consumers.length; i++) {
+            // we do not care about the customer
+            let consumer;
+            try {
+                consumer = yield (0, consumers_1.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 = yield consumer.getSyncData(_syncid);
+                const flow = (_a = syncData.enabled_flows) === null || _a === void 0 ? void 0 : _a.find((flow) => flow.id === data.id);
+                if (flow && syncData.status === 'active') {
+                    const context = Object.assign(Object.assign({}, syncData), { flow_id: flow.id, flow_name: flow.name, flow_values: flow.values, flow_config: flow.config });
+                    delete context['enabled_flows'];
+                    yield 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 = (process, log = false) => __awaiter(void 0, void 0, void 0, function* () {
+        if (log) {
+            // create executions on the platform to add the logs to the server
+            const { data: response } = yield _internalApi.post(`/syncs/${_syncid}/flows/${data.id}/local`, { type: 'START' });
+            if (response.data) {
+                const { executionid, chainexecutionid } = response.data;
+                _internalApi.setRelatedChainExecutionId(chainexecutionid);
+                try {
+                    yield localExecution(process);
+                    yield _internalApi.post(`/syncs/${_syncid}/flows/${data.id}/local`, {
+                        type: 'END',
+                        executionid: executionid,
+                        chainexecutionid: chainexecutionid,
+                    });
+                }
+                catch (err) {
+                    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)}`);
+                        yield _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());
+                        yield _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 {
+                yield localExecution(process);
+            }
+            catch (err) {
+                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,
+    };
+};
+exports.Flow = Flow;

package/dist/src/modules/integrations.d.ts

@@ -0,0 +1,23 @@
+import { operations } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+import { chiftOperations } from '../types/public-api/mappings';
+declare const Integrations: (internalApi: InternalAPI) => {
+    getIntegrations: (params?: operations[chiftOperations['getIntegrations']]['parameters']['query']) => Promise<{
+        integrationid: number;
+        name: string;
+        status: "active" | "inactive";
+        api: "Payment" | "Point of Sale" | "eCommerce" | "Accounting" | "Invoicing" | "Communication" | "Banking" | "Custom" | "Property Management System";
+        logo_url: string;
+        icon_url: string;
+        post_connections: {
+            title: string;
+            optional: boolean;
+            resource: string;
+        }[];
+        credentials: {
+            name: string;
+            optional: boolean;
+        }[];
+    }[]>;
+};
+export { Integrations };

package/dist/src/modules/integrations.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Integrations = void 0;
+const Integrations = (internalApi) => {
+    const _internalApi = internalApi;
+    const getIntegrations = (params = {}) => __awaiter(void 0, void 0, void 0, function* () {
+        const { data, } = yield _internalApi.get('/integrations', { params });
+        return data;
+    });
+    return {
+        getIntegrations,
+    };
+};
+exports.Integrations = Integrations;

package/dist/src/modules/internalApi.d.ts

@@ -0,0 +1,24 @@
+import { AxiosInstance } from 'axios';
+import { AuthType, TokenType, RequestData } from '../types/api';
+declare class InternalAPI {
+    instance: AxiosInstance;
+    auth: AuthType;
+    token?: TokenType;
+    debug: boolean;
+    relatedChainExecutionId?: string;
+    connectionId?: string;
+    integrationId?: string;
+    get: <T = any, R = import("axios").AxiosResponse<T, any>, D = any>(url: string, config?: import("axios").AxiosRequestConfig<D> | undefined) => Promise<R>;
+    post: <T = any, R = import("axios").AxiosResponse<T, any>, D = any>(url: string, data?: D | undefined, config?: import("axios").AxiosRequestConfig<D> | undefined) => Promise<R>;
+    patch: <T = any, R = import("axios").AxiosResponse<T, any>, D = any>(url: string, data?: D | undefined, config?: import("axios").AxiosRequestConfig<D> | undefined) => Promise<R>;
+    delete: <T = any, R = import("axios").AxiosResponse<T, any>, D = any>(url: string, config?: import("axios").AxiosRequestConfig<D> | undefined) => Promise<R>;
+    constructor(auth: AuthType);
+    getToken: () => Promise<void>;
+    getPaginationParams: (currPage: number) => {
+        page: number;
+        size: number;
+    };
+    setRelatedChainExecutionId(chainExecutionId: string): void;
+    makeRequest<TResponse>(requestData: RequestData<TResponse>): Promise<any>;
+}
+export { InternalAPI };