@chift/chift-nodejs 0.0.1

package/src/modules/accounting.ts

@@ -0,0 +1,357 @@
+import { operations, components } from '../types/public-api/schema';
+import { RequestData } from '../types/api';
+
+type getChartOfAccountsParams = Omit<
+    operations['accounting_get_chart_of_accounts']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getMiscOperationsParams = Omit<
+    operations['accounting_get_miscellaneous_operations']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getJournalEntriesWithMultiplePlansParams = Omit<
+    operations['accounting_get_journal_entries_mutli_plan']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getJournalEntriesParams = Omit<
+    operations['accounting_get_journal_entries']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getInvoicesByTypeWithMultiplePlansParams = Omit<
+    operations['accounting_get_invoices_by_type_multi_analytic_plans']['parameters']['query'],
+    'page' | 'size'
+>;
+
+type getInvoicesByTypeParams = Omit<
+    operations['accounting_get_invoices_by_type']['parameters']['query'],
+    'page' | 'size'
+>;
+
+const accountingFactory = {
+    getAnalyticPlans(): RequestData<components['schemas']['AnalyticPlanItem'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/analytic-plans',
+        };
+    },
+    getClients(): RequestData<components['schemas']['ClientItemOut'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/clients',
+        };
+    },
+    createClient(
+        client: components['schemas']['ClientItemIn'],
+        params: operations['accounting_create_client']['parameters']['query']
+    ): RequestData<components['schemas']['ClientItemOut']> {
+        return {
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/clients',
+            body: client,
+            params: params,
+        };
+    },
+    getClient(clientId: string): RequestData<components['schemas']['ClientItemOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/clients/${clientId}`,
+        };
+    },
+    updateClient(
+        clientId: string,
+        client: components['schemas']['ClientItemUpdate']
+    ): RequestData<components['schemas']['ClientItemOut']> {
+        return {
+            method: 'patch',
+            url: `/consumers/{consumer_id}/accounting/clients/${clientId}`,
+            body: client,
+        };
+    },
+    getSuppliers(): RequestData<components['schemas']['SupplierItemOut'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/suppliers',
+        };
+    },
+    createSupplier(
+        supplier: components['schemas']['SupplierItemIn'],
+        params: operations['accounting_create_supplier']['parameters']['query']
+    ): RequestData<components['schemas']['SupplierItemOut']> {
+        return {
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/suppliers',
+            body: supplier,
+            params: params,
+        };
+    },
+    getSupplier(supplierId: string): RequestData<components['schemas']['SupplierItemOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/suppliers/${supplierId}`,
+        };
+    },
+    updateSupplier(
+        supplierId: string,
+        supplier: components['schemas']['SupplierItemUpdate']
+    ): RequestData<components['schemas']['SupplierItemOut']> {
+        return {
+            method: 'patch',
+            url: `/consumers/{consumer_id}/accounting/suppliers/${supplierId}`,
+            body: supplier,
+        };
+    },
+    createInvoice(
+        invoice: components['schemas']['InvoiceItemInMonoAnalyticPlan'],
+        params: operations['accounting_create_invoice']['parameters']['query']
+    ): RequestData<components['schemas']['InvoiceItemOutMonoAnalyticPlan']> {
+        return {
+            params,
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/invoices',
+            body: invoice,
+        };
+    },
+    createInvoiceWithMultiplePlans(
+        invoice: components['schemas']['InvoiceItemInMultiAnalyticPlans'],
+        params: operations['accounting_create_invoice_multiple_plans']['parameters']['query']
+    ): RequestData<components['schemas']['InvoiceItemOutMultiAnalyticPlans']> {
+        return {
+            params,
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/invoices/multi-analytic-plans',
+            body: invoice,
+        };
+    },
+    getInvoicesByType(
+        invoice_type: components['schemas']['app__routers__accounting__InvoiceType'],
+        params: getInvoicesByTypeParams
+    ): RequestData<components['schemas']['InvoiceItemOutMonoAnalyticPlan'][]> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/invoices/type/${invoice_type}`,
+        };
+    },
+    getInvoice(
+        invoiceId: string,
+        params: operations['accounting_get_invoice']['parameters']['query']
+    ): RequestData<components['schemas']['InvoiceItemOutMonoAnalyticPlan']> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/invoices/${invoiceId}`,
+        };
+    },
+    getInvoiceWithMultiplePlans(
+        invoiceId: string,
+        params: operations['accounting_get_invoice_multi_analytic_plans']['parameters']['query']
+    ): RequestData<components['schemas']['InvoiceItemOutMultiAnalyticPlans']> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/invoices/multi-analytic-plans/${invoiceId}`,
+        };
+    },
+    getInvoicesByTypeWithMultiplePlans(
+        invoice_type: components['schemas']['app__routers__accounting__InvoiceType'],
+        params: getInvoicesByTypeWithMultiplePlansParams
+    ): RequestData<components['schemas']['InvoiceItemOutMultiAnalyticPlans'][]> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/invoices/multi-analytic-plans/type/${invoice_type}`,
+        };
+    },
+    createAnalyticAccount(
+        analyticAccount: components['schemas']['AnalyticAccountItemIn']
+    ): RequestData<components['schemas']['AnalyticAccountItemOut']> {
+        return {
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/analytic-accounts',
+            body: analyticAccount,
+        };
+    },
+    getAnalyticAccounts(): RequestData<components['schemas']['AnalyticAccountItemOut'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/analytic-accounts',
+        };
+    },
+    createAnalyticAccountWithMultiplePlans(
+        analytic_plan: string,
+        analyticAccount: components['schemas']['AnalyticAccountItemIn']
+    ): RequestData<components['schemas']['AnalyticAccountItemOutMultiAnalyticPlans']> {
+        return {
+            method: 'post',
+            url: `/consumers/{consumer_id}/accounting/analytic-accounts/multi-analytic-plans/${analytic_plan}`,
+            body: analyticAccount,
+        };
+    },
+    getAnalyticAccount(
+        analytic_account_id: string
+    ): RequestData<components['schemas']['AnalyticAccountItemOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/analytic-accounts/${analytic_account_id}`,
+        };
+    },
+    updateAnalyticAccount(
+        analytic_account_id: string,
+        analyticAccount: components['schemas']['AnalyticAccountItemUpdate']
+    ): RequestData<components['schemas']['AnalyticAccountItemOut']> {
+        return {
+            method: 'patch',
+            url: `/consumers/{consumer_id}/accounting/analytic-accounts/${analytic_account_id}`,
+            body: analyticAccount,
+        };
+    },
+    getAnalyticAccountWithMultiplePlans(
+        analytic_account_id: string,
+        analytic_plan: string
+    ): RequestData<components['schemas']['AnalyticAccountItemOutMultiAnalyticPlans']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/analytic-accounts/${analytic_account_id}/multi-analytic-plans/${analytic_plan}`,
+        };
+    },
+    updateAnalyticAccountWithMultiplePlans(
+        analytic_account_id: string,
+        analytic_plan: string,
+        analyticAccount: components['schemas']['AnalyticAccountItemUpdate']
+    ): RequestData<components['schemas']['AnalyticAccountItemOutMultiAnalyticPlans']> {
+        return {
+            method: 'patch',
+            url: `/consumers/{consumer_id}/accounting/analytic-accounts/${analytic_account_id}/multi-analytic-plans/${analytic_plan}`,
+            body: analyticAccount,
+        };
+    },
+    getAnalyticAccountsWithMultiplePlans(): RequestData<
+        components['schemas']['AnalyticAccountItemOutMultiAnalyticPlans'][]
+    > {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/analytic-accounts/multi-analytic-plans',
+        };
+    },
+    getAnalyticLinesOfAccount(
+        analytic_account_id: string
+    ): RequestData<components['schemas']['AnalyticAccountLineItemOut'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/analytic-account-lines/account/${analytic_account_id}`,
+        };
+    },
+    getJournalEntries(
+        params: getJournalEntriesParams
+    ): RequestData<components['schemas']['JournalEntryMonoAnalyticPlan'][]> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/journal/entries`,
+        };
+    },
+    getJournalEntriesWithMultiplePlans(
+        params: getJournalEntriesWithMultiplePlansParams
+    ): RequestData<components['schemas']['JournalEntryMultiAnalyticPlan'][]> {
+        return {
+            params,
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/journal/entries/multi-analytic-plans`,
+        };
+    },
+    getPaymentsByInvoiceId(invoice_id: string): RequestData<components['schemas']['Payment'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/invoices/id/${invoice_id}/payments`,
+        };
+    },
+    getJournals(): RequestData<components['schemas']['Journal'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/journals`,
+        };
+    },
+    getVatCodes(): RequestData<components['schemas']['app__routers__accounting__VatCode'][]> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/vat-codes`,
+        };
+    },
+    getMiscOperations(
+        params: getMiscOperationsParams
+    ): RequestData<components['schemas']['MiscellaneousOperationOut'][]> {
+        return {
+            params,
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/miscellaneous-operation',
+        };
+    },
+    createMiscOperation(
+        operation: components['schemas']['MiscellaneousOperationIn']
+    ): RequestData<components['schemas']['MiscellaneousOperationOut']> {
+        return {
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/miscellaneous-operation',
+            body: operation,
+        };
+    },
+    getMiscOperation(
+        operation_id: string
+    ): RequestData<components['schemas']['MiscellaneousOperationOut']> {
+        return {
+            method: 'get',
+            url: `/consumers/{consumer_id}/accounting/miscellaneous-operation/${operation_id}`,
+        };
+    },
+    attachPDF(
+        invoice_id: string,
+        attachment: components['schemas']['AttachmentItem'],
+        params: operations['accounting_add_attachment']['parameters']['query']
+    ): RequestData<operations['accounting_add_attachment']['responses'][201]> {
+        return {
+            params,
+            method: 'post',
+            url: `/consumers/{consumer_id}/accounting/invoices/pdf/${invoice_id}`,
+            body: attachment,
+        };
+    },
+    getChartOfAccounts(
+        params: getChartOfAccountsParams
+    ): RequestData<components['schemas']['AccountItem'][]> {
+        return {
+            params,
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/chart-of-accounts',
+        };
+    },
+    getBalanceOfAccounts(
+        filter: components['schemas']['AccountBalanceFilter']
+    ): RequestData<components['schemas']['AccountBalance'][]> {
+        return {
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/chart-of-accounts/balance',
+            body: filter,
+        };
+    },
+    getEmployees(): RequestData<components['schemas']['EmployeeItem'][]> {
+        return {
+            method: 'get',
+            url: '/consumers/{consumer_id}/accounting/employees',
+        };
+    },
+    createFinancialEntry(
+        financial_entry: components['schemas']['FinancialEntryItemIn']
+    ): RequestData<components['schemas']['FinancialEntryItemOut']> {
+        return {
+            method: 'post',
+            url: '/consumers/{consumer_id}/accounting/financial-entry',
+            body: financial_entry,
+        };
+    },
+};
+
+export { accountingFactory };

package/src/modules/api.ts

@@ -0,0 +1,35 @@
+import { AuthType } from '../types/api';
+import { InternalAPI } from './internalApi';
+import { Consumers } from './consumers';
+import { Syncs } from './syncs';
+import { Integrations } from './integrations';
+import { Webhooks } from './webhooks';
+import { DataStores } from './datastores';
+
+export class API {
+    auth: AuthType;
+    token?: string;
+    internalApi?: any;
+    Consumers;
+    Syncs;
+    Integrations;
+    Webhooks;
+    DataStores;
+
+    constructor(auth: AuthType) {
+        this.auth = auth;
+        this._setup();
+        this.Consumers = Consumers(this.internalApi);
+        this.Syncs = Syncs(this.internalApi);
+        this.Integrations = Integrations(this.internalApi);
+        this.Webhooks = Webhooks(this.internalApi);
+        this.DataStores = DataStores(this.internalApi);
+    }
+
+    private _setup = async () => {
+        if (!this.auth.clientId || !this.auth.clientSecret || !this.auth.accountId) {
+            throw new Error('Missing mandatory auth parameters');
+        }
+        this.internalApi = new InternalAPI(this.auth);
+    };
+}

package/src/modules/consumer.ts

@@ -0,0 +1,177 @@
+import { operations, components } from '../types/public-api/schema';
+import { InternalAPI } from './internalApi';
+import { chiftOperations } from '../types/public-api/mappings';
+import { posFactory } from './pos';
+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 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 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']['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 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;
+    };
+
+    /**
+     * 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,
+        getSyncUrl,
+        name,
+        redirect_url,
+        email,
+        pos,
+        accounting,
+        invoicing,
+        ecommerce,
+        custom,
+        getDataByDataStoreId,
+        addDataByDataStoreId,
+        getSyncData,
+        getDataByDataStoreName,
+        addDataByDataStoreName,
+        updateDataStoreData,
+        logData,
+    };
+};
+
+export { Consumer };

package/src/modules/consumers.ts

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

@@ -0,0 +1,36 @@
+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 };