@2bad/bitrix 2.4.0 → 2.5.0

package/build/module/client/methods/list.d.ts

@@ -3,16 +3,28 @@ import { ListableMethod, MethodParams, MethodPayloadType } from '../../methods';
 import { BatchPayload, ListPayload } from '../../payloads';
 import { Batch } from './batch';
 import { Call } from './call';
+/**
+ * Generates required amount of commands to process specified amount of entries
+ */
 export declare const fillWithCommands: <C extends Command>({ method, params }: C, start: number, toProcess: number, entriesPerCommand: number) => readonly {
     readonly method: C["method"];
     readonly params?: C["params"] | undefined;
 }[];
+/**
+ * Get the highest value from object or an array if there's any
+ */
 export declare const highest: (input: ReadonlyArray<number | undefined> | Record<string, number | undefined>) => number | undefined;
+/**
+ * Converts batch payload to a list payload
+ */
 export declare const batchToListPayload: <P>(payload: BatchPayload<Record<string, P> | readonly P[]>) => ListPayload<P>;
 declare type Dependencies = {
     readonly call: Call;
     readonly batch: Batch;
 };
 export declare type List = <M extends ListableMethod>(method: M, params: MethodParams<M>) => Promise<ListPayload<MethodPayloadType<M>>>;
+/**
+ * Gets all entries by dispatching required amount of requests. Will fill figure out payload type based on the Method.
+ */
 declare const _default: ({ call, batch }: Dependencies) => List;
 export default _default;

package/build/module/client/methods/list.js

@@ -1,10 +1,16 @@
 import range from 'lodash.range';
 const MAX_ENTRIES_PER_COMMAND = 50;
+/**
+ * Generates required amount of commands to process specified amount of entries
+ */
 export const fillWithCommands = ({ method, params }, start, toProcess, entriesPerCommand) => {
     const requiresCommands = Math.ceil((toProcess - start) / entriesPerCommand);
     return range(0, requiresCommands)
         .map((i) => ({ method, params: { ...params, start: start + (entriesPerCommand * i) } }));
 };
+/**
+ * Get the highest value from object or an array if there's any
+ */
 export const highest = (input) => Object.values(input).reduce((a, b) => a !== undefined && b !== undefined
     ? a > b ? a : b
     : a !== undefined && b === undefined
@@ -12,22 +18,31 @@ export const highest = (input) => Object.values(input).reduce((a, b) => a !== un
         : a === undefined && b !== undefined
             ? b
             : undefined, undefined);
+/**
+ * Converts batch payload to a list payload
+ */
 export const batchToListPayload = (payload) => {
-    var _a;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     const { result: { result, result_total, result_error, result_next }, time } = payload;
-    const flattenResult = Object.entries(result).reduce((flatten, [_key, r]) => !r ? flatten : [...flatten, ...r], []);
+    const flattenResult = Object.entries(result).reduce(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    // @ts-expect-error ignore this for now
+    (flatten, [_key, r]) => !r ? flatten : [...flatten, ...r], []);
     return {
         error: Object.values(result_error).join('\n'),
         next: highest(result_next),
         result: flattenResult,
+        // @todo Not accurate, we do not care
         time,
-        total: (_a = highest(result_total)) !== null && _a !== void 0 ? _a : 0
+        total: highest(result_total) ?? 0
     };
 };
+/**
+ * Gets all entries by dispatching required amount of requests. Will fill figure out payload type based on the Method.
+ */
 export default ({ call, batch }) => {
     const list = async (method, params) => {
-        var _a;
-        const start = (_a = params.start) !== null && _a !== void 0 ? _a : 0;
+        const start = params.start ?? 0;
         const listAll = async () => {
             const batchCommands = fillWithCommands({ method, params }, start, firstCall.total, MAX_ENTRIES_PER_COMMAND);
             const payload = await batch(batchCommands);
@@ -38,4 +53,3 @@ export default ({ call, batch }) => {
     };
     return list;
 };
-//# sourceMappingURL=list.js.map

package/build/module/client/methods/list.unit.test.d.ts

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

package/build/module/client/methods/list.unit.test.js

@@ -0,0 +1,252 @@
+import { Method } from '../../methods';
+import List, { batchToListPayload, fillWithCommands, highest } from './list';
+describe('Client `fillWithCommands` method', () => {
+    it('should fill array with required amount of commands to process all entries', () => {
+        const command = { method: Method.CRM_DEAL_LIST, params: { select: ['*'] } };
+        const start = 0;
+        const toProcess = 7;
+        const entriesPerCommand = 2;
+        expect(fillWithCommands(command, start, toProcess, entriesPerCommand)).toMatchSnapshot();
+    });
+    it('should properly take into account start', () => {
+        const command = { method: Method.CRM_DEAL_LIST, params: { select: ['*'] } };
+        const start = 2;
+        const toProcess = 7;
+        const entriesPerCommand = 2;
+        expect(fillWithCommands(command, start, toProcess, entriesPerCommand)).toMatchSnapshot();
+    });
+    it('should override `params.start`', () => {
+        const wrongStart = 99;
+        const command = { method: Method.CRM_DEAL_LIST, params: { start: wrongStart } };
+        const start = 0;
+        const toProcess = 2;
+        const entriesPerCommand = 1;
+        const commands = fillWithCommands(command, start, toProcess, entriesPerCommand);
+        expect(Object.values(commands).map((c) => c.params)).toMatchSnapshot();
+    });
+});
+describe('Client `highest` method', () => {
+    it('should get highest value from object', () => {
+        expect(highest({ a: undefined })).toBe(undefined);
+        expect(highest({ a: undefined, b: undefined })).toBe(undefined);
+        expect(highest({ a: 1, b: undefined })).toBe(1);
+        expect(highest({ a: undefined, b: 1 })).toBe(1);
+        expect(highest({ a: 1, b: 2 })).toBe(2);
+        expect(highest({ a: 2, b: 1 })).toBe(2);
+    });
+    it('should get highest value from array', () => {
+        expect(highest([undefined])).toBe(undefined);
+        expect(highest([undefined, undefined])).toBe(undefined);
+        expect(highest([1, undefined])).toBe(1);
+        expect(highest([undefined, 1])).toBe(1);
+        expect(highest([1, 2])).toBe(2);
+        expect(highest([2, 1])).toBe(2);
+    });
+});
+describe('Client `batchToListPayload` method', () => {
+    it('should convert batch with named payloads to a list payload', () => {
+        const payload = {
+            result: {
+                result: {
+                    a: [{ ID: '1' }, { ID: '2' }],
+                    b: [{ ID: '3' }, { ID: '4' }]
+                },
+                result_error: { a: 'Expected error A', b: 'Expected error B' },
+                result_total: { a: 4, b: 4 },
+                result_next: { a: 2, b: 4 },
+                result_time: {
+                    a: {
+                        start: 1567196891.008149,
+                        finish: 1567196891.022234,
+                        duration: 0.014085054397583008,
+                        processing: 0.013998985290527344,
+                        date_start: '2019-08-30T23:28:11+03:00',
+                        date_finish: '2019-08-30T23:28:11+03:00'
+                    },
+                    b: {
+                        start: 1567196891.022316,
+                        finish: 1567196891.03225,
+                        duration: 0.009933948516845703,
+                        processing: 0.009846210479736328,
+                        date_start: '2019-08-30T23:28:11+03:00',
+                        date_finish: '2019-08-30T23:28:11+03:00'
+                    }
+                }
+            },
+            time: {
+                start: 1567196890.959017,
+                finish: 1567196891.223739,
+                duration: 0.2647218704223633,
+                processing: 0.21567082405090332,
+                date_start: '2019-08-30T23:28:10+03:00',
+                date_finish: '2019-08-30T23:28:11+03:00'
+            }
+        };
+        expect(batchToListPayload(payload)).toMatchSnapshot();
+    });
+    it('should convert batch with payload of arrays to a list payload', () => {
+        const payload = {
+            result: {
+                result: [
+                    [{ ID: '1' }, { ID: '2' }],
+                    [{ ID: '3' }, { ID: '4' }]
+                ],
+                result_error: ['Expected error 1', 'Expected error 2'],
+                result_total: [4, 4],
+                result_next: [2, 4],
+                result_time: [{
+                        start: 1567196891.008149,
+                        finish: 1567196891.022234,
+                        duration: 0.014085054397583008,
+                        processing: 0.013998985290527344,
+                        date_start: '2019-08-30T23:28:11+03:00',
+                        date_finish: '2019-08-30T23:28:11+03:00'
+                    }, {
+                        start: 1567196891.022316,
+                        finish: 1567196891.03225,
+                        duration: 0.009933948516845703,
+                        processing: 0.009846210479736328,
+                        date_start: '2019-08-30T23:28:11+03:00',
+                        date_finish: '2019-08-30T23:28:11+03:00'
+                    }]
+            },
+            time: {
+                start: 1567196890.959017,
+                finish: 1567196891.223739,
+                duration: 0.2647218704223633,
+                processing: 0.21567082405090332,
+                date_start: '2019-08-30T23:28:10+03:00',
+                date_finish: '2019-08-30T23:28:11+03:00'
+            }
+        };
+        expect(batchToListPayload(payload)).toMatchSnapshot();
+    });
+    it('should handle undefined in `result`', () => {
+        const payload = {
+            result: {
+                result: [undefined, [{ ID: '1' }], undefined],
+                result_error: [],
+                result_total: [],
+                result_next: [],
+                result_time: [{
+                        start: 1567196891.008149,
+                        finish: 1567196891.022234,
+                        duration: 0.014085054397583008,
+                        processing: 0.013998985290527344,
+                        date_start: '2019-08-30T23:28:11+03:00',
+                        date_finish: '2019-08-30T23:28:11+03:00'
+                    }, {
+                        start: 1567196891.022316,
+                        finish: 1567196891.03225,
+                        duration: 0.009933948516845703,
+                        processing: 0.009846210479736328,
+                        date_start: '2019-08-30T23:28:11+03:00',
+                        date_finish: '2019-08-30T23:28:11+03:00'
+                    }]
+            },
+            time: {
+                start: 1567196890.959017,
+                finish: 1567196891.223739,
+                duration: 0.2647218704223633,
+                processing: 0.21567082405090332,
+                date_start: '2019-08-30T23:28:10+03:00',
+                date_finish: '2019-08-30T23:28:11+03:00'
+            }
+        };
+        expect(batchToListPayload(payload)).toMatchSnapshot();
+    });
+});
+describe('Client `list` method', () => {
+    it('should make one request when entries can be fetched in one go', async () => {
+        const callMock = jest.fn(() => Promise.resolve({ next: false }));
+        const batchMock = jest.fn(() => Promise.resolve({}));
+        const list = List({ call: callMock, batch: batchMock });
+        await list(Method.CRM_DEAL_LIST, {});
+        expect(callMock.mock.calls).toMatchSnapshot();
+        expect(batchMock).not.toBeCalled();
+    });
+    it('should make multiple requests when entries can not be fetched in one go', async () => {
+        const callMock = jest.fn(() => Promise.resolve({ next: 2, total: 120 }));
+        const batchMock = jest.fn(() => Promise.resolve({
+            result: {
+                result: ['done'],
+                result_error: [],
+                result_next: [],
+                result_time: [],
+                result_total: []
+            },
+            time: {}
+        }));
+        const list = List({ call: callMock, batch: batchMock });
+        await list(Method.CRM_DEAL_LIST, {});
+        expect(callMock.mock.calls).toMatchSnapshot();
+        expect(batchMock.mock.calls).toMatchSnapshot();
+    });
+    it('should return a first request payload when entities can be fetched in a single request', async () => {
+        const mockPayload = { next: false, result: 'test' };
+        const callMock = jest.fn(() => Promise.resolve(mockPayload));
+        const batchMock = jest.fn(() => Promise.resolve({}));
+        const list = List({ call: callMock, batch: batchMock });
+        const payload = await list(Method.CRM_DEAL_LIST, {});
+        expect(payload).toEqual(mockPayload);
+    });
+    it('should return a flatten payload when entities can not be fetched in a single request', async () => {
+        const mockPayload = {
+            result: {
+                result: {
+                    a: [{ ID: '1' }, { ID: '2' }],
+                    b: [{ ID: '3' }, { ID: '4' }]
+                },
+                result_error: { a: 'Expected error A', b: 'Expected error B' },
+                result_total: { a: 4, b: 4 },
+                result_next: { a: 2, b: 4 },
+                result_time: {
+                    a: { start: 1567196891.008149 },
+                    b: { start: 1567196891.022316 }
+                }
+            },
+            time: { start: 1567196890.959017 }
+        };
+        const callMock = jest.fn(() => Promise.resolve({ next: 2 }));
+        const batchMock = jest.fn(() => Promise.resolve(mockPayload));
+        const list = List({ call: callMock, batch: batchMock });
+        const payload = await list(Method.CRM_DEAL_LIST, {});
+        expect(payload).toMatchSnapshot();
+    });
+    it('should default start to 0', async () => {
+        const callMock = jest.fn(() => Promise.resolve({ next: 2, total: 20 }));
+        const batchMock = jest.fn(() => Promise.resolve({
+            result: {
+                result: ['done'],
+                result_error: [],
+                result_next: [],
+                result_time: [],
+                result_total: []
+            },
+            time: {}
+        }));
+        const list = List({ call: callMock, batch: batchMock });
+        await list(Method.CRM_DEAL_LIST, {});
+        expect(callMock.mock.calls[0]).toMatchSnapshot();
+        expect(batchMock.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should properly take into account start', async () => {
+        const callMock = jest.fn(() => Promise.resolve({ next: 2, total: 120 }));
+        const batchMock = jest.fn(() => Promise.resolve({
+            result: {
+                result: ['done'],
+                result_error: [],
+                result_next: [],
+                result_time: [],
+                result_total: []
+            },
+            time: {}
+        }));
+        const list = List({ call: callMock, batch: batchMock });
+        await list(Method.CRM_DEAL_LIST, { start: 27 });
+        expect(callMock.mock.calls).toMatchSnapshot();
+        expect(batchMock.mock.calls).toMatchSnapshot();
+    });
+    it.todo('should cast first request payload to the <P>');
+    it.todo('should cast payload results to the <P>');
+});

package/build/module/commands.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=commands.js.map

package/build/module/methods.d.ts

@@ -59,6 +59,13 @@ export declare type ListParams = {
     };
     readonly select?: readonly string[];
 };
+/**
+ * A mega map of all supported Bitrix methods to their parameters. Used to resolve
+ * low-level client method required params and payload types.
+ * - `type` — a type that method associated with
+ * - `payload` — a payload that method returns
+ * - `params` — params that method accepts
+ */
 export declare type Methods = MethodsMap & CompaniesMethods & ContactsMethods & DealsMethods & LeadsMethods & StatusesMethods & UsersMethods & {
     readonly [Method.BATCH]: {
         readonly type: unknown;
@@ -66,8 +73,20 @@ export declare type Methods = MethodsMap & CompaniesMethods & ContactsMethods &
         readonly params: Commands;
     };
 };
+/**
+ * Retrieve specified method data
+ */
 export declare type MethodData<M extends Method> = ExtractValue<Methods, M>;
+/**
+ * Retrieve associated with specified method type
+ */
 export declare type MethodPayloadType<M extends Method> = MethodData<M>['type'];
+/**
+ * Retrieve specified method payload type
+ */
 export declare type MethodPayload<M extends Method> = MethodData<M>['payload'];
+/**
+ * Retrieve specified method params
+ */
 export declare type MethodParams<M extends Method> = MethodData<M>['params'];
 export {};

package/build/module/methods.js

@@ -36,4 +36,3 @@ const LISTABLE_METHODS = [
     Method.CRM_DEAL_LIST,
     Method.CRM_LEAD_LIST
 ];
-//# sourceMappingURL=methods.js.map

package/build/module/payloads.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=payloads.js.map

package/build/module/services/common.d.ts

@@ -19,3 +19,4 @@ export declare type MultiField = {
     readonly VALUE: string;
     readonly TYPE_ID: string;
 };
+export declare type MultiFieldArray = ReadonlyArray<Pick<MultiField, 'VALUE' | 'VALUE_TYPE'>>;

package/build/module/services/common.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=common.js.map

package/build/module/services/companies/entities.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=entities.js.map

package/build/module/services/companies/index.integration.test.d.ts

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

package/build/module/services/companies/index.integration.test.js

@@ -0,0 +1,14 @@
+import Bitrix from './../../bitrix';
+const WEBHOOK_URL = process.env['WEBHOOK_URL'];
+if (!WEBHOOK_URL) {
+    throw Error('Integration tests require environmental variable `WEBHOOK_URL` to be set');
+}
+const { companies } = Bitrix(WEBHOOK_URL);
+describe('Companies', () => {
+    describe('fields', () => {
+        it('should get all fields', async () => {
+            const { result } = await companies.fields();
+            expect(result).toMatchSnapshot();
+        });
+    });
+});

package/build/module/services/companies/index.js

@@ -6,4 +6,3 @@ export default ({ call, list }) => ({
     list: (params = {}) => list(Method.CRM_COMPANY_LIST, params),
     update: (id, fields, params) => call(Method.CRM_COMPANY_UPDATE, { id, fields, params })
 });
-//# sourceMappingURL=index.js.map

package/build/module/services/companies/index.unit.test.d.ts

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

package/build/module/services/companies/index.unit.test.js

@@ -0,0 +1,67 @@
+import Companies from '.';
+const mockCall = jest.fn(() => Promise.resolve());
+const mockList = jest.fn(() => Promise.resolve());
+const companies = Companies({ call: mockCall, list: mockList });
+const ID = '77';
+describe('Companies', () => {
+    beforeEach(() => {
+        mockCall.mockClear();
+        mockList.mockClear();
+    });
+    it('should expose API methods', () => {
+        expect(companies).toMatchSnapshot();
+    });
+    describe('`create`', () => {
+        it('should invoke `call`', async () => {
+            await companies.create({
+                COMMENTS: 'Some comment'
+            }, {
+                REGISTER_SONET_EVENT: 'Y'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+        it('should work without optional params', async () => {
+            await companies.create({
+                COMMENTS: 'Some comment'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+    });
+    describe('`get`', () => {
+        it('should invoke `call`', async () => {
+            await companies.get(ID);
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+    });
+    describe('`list`', () => {
+        it('should invoke `list`', async () => {
+            await companies.list({
+                start: 0,
+                order: { COMMENTS: 'ASC' },
+                filter: { '>PROBABILITY': 50 },
+                select: ['*', 'UF_*']
+            });
+            expect(mockList.mock.calls).toMatchSnapshot();
+        });
+        it('should work without optional params', async () => {
+            await companies.list();
+            expect(mockList.mock.calls).toMatchSnapshot();
+        });
+    });
+    describe('`update`', () => {
+        it('should invoke `call`', async () => {
+            await companies.update(ID, {
+                COMMENTS: 'Some comment'
+            }, {
+                REGISTER_SONET_EVENT: 'Y'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+        it('should work without optional params', async () => {
+            await companies.update(ID, {
+                COMMENTS: 'Some comment'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+    });
+});

package/build/module/services/companies/methods.js

@@ -1,2 +1 @@
 import { Method } from '../../methods';
-//# sourceMappingURL=methods.js.map

package/build/module/services/contacts/entities.d.ts

@@ -1,6 +1,6 @@
-import { BoolString, ISODate, NumberString } from '../common';
+import { BoolString, ISODate, MultiFieldArray, NumberString } from '../common';
 export declare type Contact = {
-    readonly [key: string]: string | null;
+    readonly [key: string]: MultiFieldArray | string | null;
     readonly ID: NumberString;
     readonly POST: string | null;
     readonly COMMENTS: string | null;

package/build/module/services/contacts/entities.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=entities.js.map

package/build/module/services/contacts/index.integration.test.d.ts

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

package/build/module/services/contacts/index.integration.test.js

@@ -0,0 +1,14 @@
+import Bitrix from './../../bitrix';
+const WEBHOOK_URL = process.env['WEBHOOK_URL'];
+if (!WEBHOOK_URL) {
+    throw Error('Integration tests require environmental variable `WEBHOOK_URL` to be set');
+}
+const { contacts } = Bitrix(WEBHOOK_URL);
+describe('Contacts', () => {
+    describe('fields', () => {
+        it('should get all fields', async () => {
+            const { result } = await contacts.fields();
+            expect(result).toMatchSnapshot();
+        });
+    });
+});

package/build/module/services/contacts/index.js

@@ -6,4 +6,3 @@ export default ({ call, list }) => ({
     list: (params = {}) => list(Method.CRM_CONTACT_LIST, params),
     update: (id, fields, params) => call(Method.CRM_CONTACT_UPDATE, { id, fields, params })
 });
-//# sourceMappingURL=index.js.map

package/build/module/services/contacts/index.unit.test.d.ts

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

package/build/module/services/contacts/index.unit.test.js

@@ -0,0 +1,67 @@
+import Contacts from '.';
+const mockCall = jest.fn(() => Promise.resolve());
+const mockList = jest.fn(() => Promise.resolve());
+const contacts = Contacts({ call: mockCall, list: mockList });
+const ID = '77';
+describe('Contacts', () => {
+    beforeEach(() => {
+        mockCall.mockClear();
+        mockList.mockClear();
+    });
+    it('should expose API methods', () => {
+        expect(contacts).toMatchSnapshot();
+    });
+    describe('`create`', () => {
+        it('should invoke `call`', async () => {
+            await contacts.create({
+                COMMENTS: 'Some comment'
+            }, {
+                REGISTER_SONET_EVENT: 'Y'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+        it('should work without optional params', async () => {
+            await contacts.create({
+                COMMENTS: 'Some comment'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+    });
+    describe('`get`', () => {
+        it('should invoke `call`', async () => {
+            await contacts.get(ID);
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+    });
+    describe('`list`', () => {
+        it('should invoke `list`', async () => {
+            await contacts.list({
+                start: 0,
+                order: { COMMENTS: 'ASC' },
+                filter: { '>PROBABILITY': 50 },
+                select: ['*', 'UF_*']
+            });
+            expect(mockList.mock.calls).toMatchSnapshot();
+        });
+        it('should work without optional params', async () => {
+            await contacts.list();
+            expect(mockList.mock.calls).toMatchSnapshot();
+        });
+    });
+    describe('`update`', () => {
+        it('should invoke `call`', async () => {
+            await contacts.update(ID, {
+                COMMENTS: 'Some comment'
+            }, {
+                REGISTER_SONET_EVENT: 'Y'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+        it('should work without optional params', async () => {
+            await contacts.update(ID, {
+                COMMENTS: 'Some comment'
+            });
+            expect(mockCall.mock.calls).toMatchSnapshot();
+        });
+    });
+});

package/build/module/services/contacts/methods.js

@@ -1,2 +1 @@
 import { Method } from '../../methods';
-//# sourceMappingURL=methods.js.map

package/build/module/services/currencies/entities.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=entities.js.map

package/build/module/services/deals/entities.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=entities.js.map

package/build/module/services/deals/index.integration.test.d.ts

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

package/build/module/services/deals/index.integration.test.js

@@ -0,0 +1,14 @@
+import Bitrix from './../../bitrix';
+const WEBHOOK_URL = process.env['WEBHOOK_URL'];
+if (!WEBHOOK_URL) {
+    throw Error('Integration tests require environmental variable `WEBHOOK_URL` to be set');
+}
+const { deals } = Bitrix(WEBHOOK_URL);
+describe('Deals', () => {
+    describe('fields', () => {
+        it('should get all fields', async () => {
+            const { result } = await deals.fields();
+            expect(result).toMatchSnapshot();
+        });
+    });
+});

package/build/module/services/deals/index.js

@@ -6,4 +6,3 @@ export default ({ call, list }) => ({
     list: (params = {}) => list(Method.CRM_DEAL_LIST, params),
     update: (id, fields, params) => call(Method.CRM_DEAL_UPDATE, { id, fields, params })
 });
-//# sourceMappingURL=index.js.map

package/build/module/services/deals/index.unit.test.d.ts

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