@rudderstack/integrations-lib 0.2.16 → 0.2.18

package/build/sdks/zoho/zoho.test.js

@@ -0,0 +1,315 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const _1 = require(".");
+describe('Zoho SDK', () => {
+    let authObject;
+    let mock;
+    beforeEach(() => {
+        mock = new axios_mock_adapter_1.default(axios_1.default, { onNoMatch: 'throwException' });
+        authObject = {
+            accessToken: 'test-access-token',
+            dataCenter: 'EU',
+            refreshAccesTokenFunc: () => Promise.resolve('test-access-token-refreshed'),
+        };
+    });
+    afterEach(() => {
+        mock.restore();
+    });
+    describe('fetch ZOHO Modules', () => {
+        const acrualModules = [
+            {
+                api_name: 'Leads',
+                creatable: true,
+                api_supported: true,
+                plural_label: 'Leads',
+                module_name: 'Leads',
+            },
+            {
+                api_name: 'Contacts',
+                creatable: true,
+                api_supported: true,
+                plural_label: 'Contacts',
+                module_name: 'Contacts',
+            },
+        ];
+        it('it should return an error if the request is invalid', async () => {
+            mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');
+                return [400, { code: 'INVALID_REQUEST' }];
+            });
+            const zoho = new _1.ZOHO(authObject);
+            const res = await zoho.fetchModules();
+            if (res.type !== 'application-error') {
+                fail('Expected response to be an application error');
+            }
+            expect(res.type).toBe('application-error');
+            expect(res.statusCode).toBe(400);
+            expect(res.responseBody.code).toBe('INVALID_REQUEST');
+        });
+        it('it should return the modules if the request is valid', async () => {
+            mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');
+                return [200, { modules: acrualModules }];
+            });
+            const zoho = new _1.ZOHO(authObject);
+            const res = await zoho.fetchModules();
+            if (res.type !== 'success') {
+                fail('Expected response to be a success');
+            }
+            expect(res.type).toBe('success');
+            expect(res.statusCode).toBe(200);
+            const { modules } = res.responseBody;
+            expect(modules.length).toBe(2);
+            expect(modules[0]).toStrictEqual({
+                api_name: 'Leads',
+                creatable: true,
+                api_supported: true,
+                plural_label: 'Leads',
+                module_name: 'Leads',
+            });
+            expect(modules[1]).toStrictEqual({
+                api_name: 'Contacts',
+                creatable: true,
+                api_supported: true,
+                plural_label: 'Contacts',
+                module_name: 'Contacts',
+            });
+        });
+        it('it should refresh the access token if it is expired', async () => {
+            mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token') {
+                    return [401, { code: 'INVALID_TOKEN' }];
+                }
+                if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token-refreshed') {
+                    return [200, { modules: acrualModules }];
+                }
+                return [400, { code: 'INVALID_REQUEST' }];
+            });
+            const zoho = new _1.ZOHO(authObject);
+            const res = await zoho.fetchModules();
+            if (res.type !== 'success') {
+                fail('Expected response to be a success');
+            }
+            expect(res.type).toBe('success');
+            expect(res.statusCode).toBe(200);
+            const { modules } = res.responseBody;
+            expect(modules.length).toBe(2);
+            expect(modules[0]).toStrictEqual({
+                api_name: 'Leads',
+                creatable: true,
+                api_supported: true,
+                plural_label: 'Leads',
+                module_name: 'Leads',
+            });
+            expect(modules[1]).toStrictEqual({
+                api_name: 'Contacts',
+                creatable: true,
+                api_supported: true,
+                plural_label: 'Contacts',
+                module_name: 'Contacts',
+            });
+        });
+        it('it should return an error if the refresh function fails', async () => {
+            mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token') {
+                    return [401, { code: 'INVALID_TOKEN' }];
+                }
+                return [400, { code: 'INVALID_REQUEST' }];
+            });
+            authObject.refreshAccesTokenFunc = () => Promise.reject(new Error('Invalid refresh token'));
+            const zoho = new _1.ZOHO(authObject);
+            try {
+                await zoho.fetchModules();
+            }
+            catch (error) {
+                expect(error.message).toBe('Unable to refresh token, with error: Error: Invalid refresh token');
+            }
+        });
+    });
+    describe('fetch ZOHO Fields', () => {
+        const actualFields = [
+            {
+                id: 'id',
+                display_label: 'ID',
+                data_type: 'string',
+                api_name: 'id',
+                length: 255,
+                required: true,
+                sequence_number: 1,
+                read_only: false,
+                searchable: true,
+                operation_type: {
+                    api_create: true,
+                    api_update: true,
+                },
+            },
+            {
+                id: 'name',
+                display_label: 'Name',
+                data_type: 'string',
+                api_name: 'name',
+                length: 255,
+                required: true,
+                sequence_number: 2,
+                read_only: false,
+                searchable: true,
+                operation_type: {
+                    api_create: true,
+                    api_update: true,
+                },
+            },
+        ];
+        it('it should return an error if the request is invalid', async () => {
+            mock.onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=Leads').reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');
+                return [400, { code: 'INVALID_REQUEST' }];
+            });
+            const zoho = new _1.ZOHO(authObject);
+            const res = await zoho.fetchDynamicFields('Leads');
+            if (res.type !== 'application-error') {
+                fail('Expected response to be an application error');
+            }
+            expect(res.type).toBe('application-error');
+            expect(res.statusCode).toBe(400);
+            expect(res.responseBody.code).toBe('INVALID_REQUEST');
+        });
+        it('it should return an error if the object is not valid', async () => {
+            mock
+                .onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=invalid_object')
+                .reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');
+                return [400, { code: 'INVALID_REQUEST' }];
+            });
+            const zoho = new _1.ZOHO(authObject);
+            const res = await zoho.fetchDynamicFields('invalid_object');
+            if (res.type !== 'application-error') {
+                fail('Expected response to be an application error');
+            }
+            expect(res.type).toBe('application-error');
+            expect(res.statusCode).toBe(400);
+        });
+        it('it should return the fields if the request is valid', async () => {
+            mock.onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=Leads').reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');
+                return [200, { fields: actualFields }];
+            });
+            const zoho = new _1.ZOHO(authObject);
+            const res = await zoho.fetchDynamicFields('Leads');
+            if (res.type !== 'success') {
+                fail('Expected response to be a success');
+            }
+            expect(res.type).toBe('success');
+            expect(res.statusCode).toBe(200);
+            const { fields } = res.responseBody;
+            expect(fields.length).toBe(2);
+            expect(fields[0]).toStrictEqual({
+                id: 'id',
+                display_label: 'ID',
+                data_type: 'string',
+                api_name: 'id',
+                length: 255,
+                required: true,
+                sequence_number: 1,
+                read_only: false,
+                searchable: true,
+                operation_type: {
+                    api_create: true,
+                    api_update: true,
+                },
+            });
+            expect(fields[1]).toStrictEqual({
+                id: 'name',
+                display_label: 'Name',
+                data_type: 'string',
+                api_name: 'name',
+                length: 255,
+                required: true,
+                sequence_number: 2,
+                read_only: false,
+                searchable: true,
+                operation_type: {
+                    api_create: true,
+                    api_update: true,
+                },
+            });
+        });
+        it('it should refresh the access token if it is expired', async () => {
+            mock.onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=Leads').reply((config) => {
+                expect(config.headers).toHaveProperty('Authorization');
+                if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token') {
+                    return [401, { code: 'INVALID_TOKEN' }];
+                }
+                if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token-refreshed') {
+                    return [200, { fields: actualFields }];
+                }
+                return [400, { code: 'INVALID_REQUEST' }];
+            });
+            const zoho = new _1.ZOHO(authObject);
+            const res = await zoho.fetchDynamicFields('Leads');
+            if (res.type !== 'success') {
+                fail('Expected response to be a success');
+            }
+            expect(res.type).toBe('success');
+            expect(res.statusCode).toBe(200);
+            const { fields } = res.responseBody;
+            expect(fields.length).toBe(2);
+            expect(fields[0]).toStrictEqual({
+                id: 'id',
+                display_label: 'ID',
+                data_type: 'string',
+                api_name: 'id',
+                length: 255,
+                required: true,
+                sequence_number: 1,
+                read_only: false,
+                searchable: true,
+                operation_type: {
+                    api_create: true,
+                    api_update: true,
+                },
+            });
+            expect(fields[1]).toStrictEqual({
+                id: 'name',
+                display_label: 'Name',
+                data_type: 'string',
+                api_name: 'name',
+                length: 255,
+                required: true,
+                sequence_number: 2,
+                read_only: false,
+                searchable: true,
+                operation_type: {
+                    api_create: true,
+                    api_update: true,
+                },
+            });
+        });
+    });
+    describe('validateAuthObject', () => {
+        it('it should throw an error if the authObject is not provided', () => {
+            expect(() => new _1.ZOHO(undefined)).toThrow('authObject is required.');
+        });
+        it('it should throw an error if the accessToken is not provided', () => {
+            expect(() => new _1.ZOHO({})).toThrow('ZOHO accessToken is required.');
+        });
+        it('it should throw an error if the dataCenter is not provided', () => {
+            expect(() => new _1.ZOHO({ accessToken: 'test-access-token' })).toThrow('ZOHO dataCenter is required.');
+        });
+        it('it should throw an error if the refreshAccesTokenFunc is not provided', () => {
+            expect(() => new _1.ZOHO({ accessToken: 'test-access-token', dataCenter: 'EU' })).toThrow('ZOHO a refresh access token function is required.');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zoho.test.js","sourceRoot":"","sources":["../../../src/sdks/zoho/zoho.test.ts"],"names":[],"mappings":"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","sourcesContent":["import axios from 'axios';\nimport AxiosMockAdapter from 'axios-mock-adapter';\n\nimport { ZOHO, AuthObject } from '.';\n\ndescribe('Zoho SDK', () => {\n  let authObject: AuthObject;\n  let mock: AxiosMockAdapter;\n\n  beforeEach(() => {\n    mock = new AxiosMockAdapter(axios, { onNoMatch: 'throwException' });\n    authObject = {\n      accessToken: 'test-access-token',\n      dataCenter: 'EU',\n      refreshAccesTokenFunc: () => Promise.resolve('test-access-token-refreshed'),\n    };\n  });\n\n  afterEach(() => {\n    mock.restore();\n  });\n\n  describe('fetch ZOHO Modules', () => {\n    const acrualModules = [\n      {\n        api_name: 'Leads',\n        creatable: true,\n        api_supported: true,\n        plural_label: 'Leads',\n        module_name: 'Leads',\n      },\n      {\n        api_name: 'Contacts',\n        creatable: true,\n        api_supported: true,\n        plural_label: 'Contacts',\n        module_name: 'Contacts',\n      },\n    ];\n\n    it('it should return an error if the request is invalid', async () => {\n      mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {\n        expect(config.headers).toHaveProperty('Authorization');\n        expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');\n        return [400, { code: 'INVALID_REQUEST' }];\n      });\n      const zoho = new ZOHO(authObject);\n      const res = await zoho.fetchModules();\n      if (res.type !== 'application-error') {\n        fail('Expected response to be an application error');\n      }\n      expect(res.type).toBe('application-error');\n      expect(res.statusCode).toBe(400);\n      expect(res.responseBody.code).toBe('INVALID_REQUEST');\n    });\n\n    it('it should return the modules if the request is valid', async () => {\n      mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {\n        expect(config.headers).toHaveProperty('Authorization');\n        expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');\n        return [200, { modules: acrualModules }];\n      });\n      const zoho = new ZOHO(authObject);\n      const res = await zoho.fetchModules();\n      if (res.type !== 'success') {\n        fail('Expected response to be a success');\n      }\n      expect(res.type).toBe('success');\n      expect(res.statusCode).toBe(200);\n\n      const { modules } = res.responseBody;\n      expect(modules.length).toBe(2);\n      expect(modules[0]).toStrictEqual({\n        api_name: 'Leads',\n        creatable: true,\n        api_supported: true,\n        plural_label: 'Leads',\n        module_name: 'Leads',\n      });\n      expect(modules[1]).toStrictEqual({\n        api_name: 'Contacts',\n        creatable: true,\n        api_supported: true,\n        plural_label: 'Contacts',\n        module_name: 'Contacts',\n      });\n    });\n\n    it('it should refresh the access token if it is expired', async () => {\n      mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {\n        expect(config.headers).toHaveProperty('Authorization');\n        if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token') {\n          return [401, { code: 'INVALID_TOKEN' }];\n        }\n        if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token-refreshed') {\n          return [200, { modules: acrualModules }];\n        }\n        return [400, { code: 'INVALID_REQUEST' }];\n      });\n      const zoho = new ZOHO(authObject);\n      const res = await zoho.fetchModules();\n      if (res.type !== 'success') {\n        fail('Expected response to be a success');\n      }\n      expect(res.type).toBe('success');\n      expect(res.statusCode).toBe(200);\n      const { modules } = res.responseBody;\n      expect(modules.length).toBe(2);\n      expect(modules[0]).toStrictEqual({\n        api_name: 'Leads',\n        creatable: true,\n        api_supported: true,\n        plural_label: 'Leads',\n        module_name: 'Leads',\n      });\n      expect(modules[1]).toStrictEqual({\n        api_name: 'Contacts',\n        creatable: true,\n        api_supported: true,\n        plural_label: 'Contacts',\n        module_name: 'Contacts',\n      });\n    });\n\n    it('it should return an error if the refresh function fails', async () => {\n      mock.onGet('https://www.zohoapis.eu/crm/v6/settings/modules').reply((config) => {\n        expect(config.headers).toHaveProperty('Authorization');\n        if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token') {\n          return [401, { code: 'INVALID_TOKEN' }];\n        }\n        return [400, { code: 'INVALID_REQUEST' }];\n      });\n      authObject.refreshAccesTokenFunc = () => Promise.reject(new Error('Invalid refresh token'));\n\n      const zoho = new ZOHO(authObject);\n      try {\n        await zoho.fetchModules();\n      } catch (error) {\n        expect((error as Error).message).toBe(\n          'Unable to refresh token, with error: Error: Invalid refresh token',\n        );\n      }\n    });\n  });\n\n  describe('fetch ZOHO Fields', () => {\n    const actualFields = [\n      {\n        id: 'id',\n        display_label: 'ID',\n        data_type: 'string',\n        api_name: 'id',\n        length: 255,\n        required: true,\n        sequence_number: 1,\n        read_only: false,\n        searchable: true,\n        operation_type: {\n          api_create: true,\n          api_update: true,\n        },\n      },\n      {\n        id: 'name',\n        display_label: 'Name',\n        data_type: 'string',\n        api_name: 'name',\n        length: 255,\n        required: true,\n        sequence_number: 2,\n        read_only: false,\n        searchable: true,\n        operation_type: {\n          api_create: true,\n          api_update: true,\n        },\n      },\n    ];\n\n    it('it should return an error if the request is invalid', async () => {\n      mock.onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=Leads').reply((config) => {\n        expect(config.headers).toHaveProperty('Authorization');\n        expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');\n        return [400, { code: 'INVALID_REQUEST' }];\n      });\n      const zoho = new ZOHO(authObject);\n      const res = await zoho.fetchDynamicFields('Leads');\n      if (res.type !== 'application-error') {\n        fail('Expected response to be an application error');\n      }\n      expect(res.type).toBe('application-error');\n      expect(res.statusCode).toBe(400);\n      expect(res.responseBody.code).toBe('INVALID_REQUEST');\n    });\n\n    it('it should return an error if the object is not valid', async () => {\n      mock\n        .onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=invalid_object')\n        .reply((config) => {\n          expect(config.headers).toHaveProperty('Authorization');\n          expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');\n          return [400, { code: 'INVALID_REQUEST' }];\n        });\n      const zoho = new ZOHO(authObject);\n      const res = await zoho.fetchDynamicFields('invalid_object');\n      if (res.type !== 'application-error') {\n        fail('Expected response to be an application error');\n      }\n      expect(res.type).toBe('application-error');\n      expect(res.statusCode).toBe(400);\n    });\n\n    it('it should return the fields if the request is valid', async () => {\n      mock.onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=Leads').reply((config) => {\n        expect(config.headers).toHaveProperty('Authorization');\n        expect(config.headers?.Authorization).toBe('Zoho-oauthtoken test-access-token');\n        return [200, { fields: actualFields }];\n      });\n      const zoho = new ZOHO(authObject);\n      const res = await zoho.fetchDynamicFields('Leads');\n      if (res.type !== 'success') {\n        fail('Expected response to be a success');\n      }\n      expect(res.type).toBe('success');\n      expect(res.statusCode).toBe(200);\n      const { fields } = res.responseBody;\n      expect(fields.length).toBe(2);\n      expect(fields[0]).toStrictEqual({\n        id: 'id',\n        display_label: 'ID',\n        data_type: 'string',\n        api_name: 'id',\n        length: 255,\n        required: true,\n        sequence_number: 1,\n        read_only: false,\n        searchable: true,\n        operation_type: {\n          api_create: true,\n          api_update: true,\n        },\n      });\n      expect(fields[1]).toStrictEqual({\n        id: 'name',\n        display_label: 'Name',\n        data_type: 'string',\n        api_name: 'name',\n        length: 255,\n        required: true,\n        sequence_number: 2,\n        read_only: false,\n        searchable: true,\n        operation_type: {\n          api_create: true,\n          api_update: true,\n        },\n      });\n    });\n\n    it('it should refresh the access token if it is expired', async () => {\n      mock.onGet('https://www.zohoapis.eu/crm/v6/settings/fields?module=Leads').reply((config) => {\n        expect(config.headers).toHaveProperty('Authorization');\n        if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token') {\n          return [401, { code: 'INVALID_TOKEN' }];\n        }\n        if (config.headers?.Authorization === 'Zoho-oauthtoken test-access-token-refreshed') {\n          return [200, { fields: actualFields }];\n        }\n        return [400, { code: 'INVALID_REQUEST' }];\n      });\n      const zoho = new ZOHO(authObject);\n      const res = await zoho.fetchDynamicFields('Leads');\n      if (res.type !== 'success') {\n        fail('Expected response to be a success');\n      }\n      expect(res.type).toBe('success');\n      expect(res.statusCode).toBe(200);\n      const { fields } = res.responseBody;\n      expect(fields.length).toBe(2);\n      expect(fields[0]).toStrictEqual({\n        id: 'id',\n        display_label: 'ID',\n        data_type: 'string',\n        api_name: 'id',\n        length: 255,\n        required: true,\n        sequence_number: 1,\n        read_only: false,\n        searchable: true,\n        operation_type: {\n          api_create: true,\n          api_update: true,\n        },\n      });\n      expect(fields[1]).toStrictEqual({\n        id: 'name',\n        display_label: 'Name',\n        data_type: 'string',\n        api_name: 'name',\n        length: 255,\n        required: true,\n        sequence_number: 2,\n        read_only: false,\n        searchable: true,\n        operation_type: {\n          api_create: true,\n          api_update: true,\n        },\n      });\n    });\n  });\n\n  describe('validateAuthObject', () => {\n    it('it should throw an error if the authObject is not provided', () => {\n      expect(() => new ZOHO(undefined as any)).toThrow('authObject is required.');\n    });\n    it('it should throw an error if the accessToken is not provided', () => {\n      expect(() => new ZOHO({} as any)).toThrow('ZOHO accessToken is required.');\n    });\n    it('it should throw an error if the dataCenter is not provided', () => {\n      expect(() => new ZOHO({ accessToken: 'test-access-token' } as any)).toThrow(\n        'ZOHO dataCenter is required.',\n      );\n    });\n    it('it should throw an error if the refreshAccesTokenFunc is not provided', () => {\n      expect(() => new ZOHO({ accessToken: 'test-access-token', dataCenter: 'EU' } as any)).toThrow(\n        'ZOHO a refresh access token function is required.',\n      );\n    });\n  });\n});\n"]}

package/build/utils/index.d.ts

@@ -1,5 +1,7 @@
+export * from './json-schema-generator';
 export * from './json';
 export * from './misc';
 export * from './request';
 export * from './sem';
+export * from './tests';
 //# sourceMappingURL=index.d.ts.map

package/build/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC"}

package/build/utils/index.js

@@ -14,8 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./json-schema-generator"), exports);
 __exportStar(require("./json"), exports);
 __exportStar(require("./misc"), exports);
 __exportStar(require("./request"), exports);
 __exportStar(require("./sem"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlDQUF1QjtBQUN2Qix5Q0FBdUI7QUFDdkIsNENBQTBCO0FBQzFCLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vanNvbic7XG5leHBvcnQgKiBmcm9tICcuL21pc2MnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vc2VtJztcbiJdfQ==
+__exportStar(require("./tests"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBEQUF3QztBQUN4Qyx5Q0FBdUI7QUFDdkIseUNBQXVCO0FBQ3ZCLDRDQUEwQjtBQUMxQix3Q0FBc0I7QUFDdEIsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9qc29uLXNjaGVtYS1nZW5lcmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9qc29uJztcbmV4cG9ydCAqIGZyb20gJy4vbWlzYyc7XG5leHBvcnQgKiBmcm9tICcuL3JlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9zZW0nO1xuZXhwb3J0ICogZnJvbSAnLi90ZXN0cyc7XG4iXX0=

package/build/utils/json-schema-generator.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Type definition for a JSON Schema.
+ */
+export type JSONSchemaType = {
+    type?: string | string[];
+    properties?: {
+        [key: string]: JSONSchemaType;
+    };
+    items?: JSONSchemaType;
+    required?: string[];
+    enum?: any[];
+    anyOf?: JSONSchemaType[];
+};
+/**
+ * Options for generating JSON Schemas.
+ */
+export type JsonSchemaGeneratorOptions = {
+    /** If true, marks every property in an object as required */
+    requireAll?: boolean;
+    /** If true, attempts to detect and include enums for arrays of strings */
+    detectEnums?: boolean;
+};
+/**
+ * Utility for generating and validating JSON Schemas from data.
+ */
+export declare class JsonSchemaGenerator {
+    private static validator;
+    /**
+     * Validates the provided data against the given JSON Schema.
+     *
+     * @param data - The data to validate.
+     * @param schema - The JSON Schema to use for validation.
+     * @throws Error if the validation fails.
+     */
+    static validate(data: unknown, schema: JSONSchemaType): void;
+    /**
+     * Generates a JSON Schema for the given data.
+     *
+     * @param data - The data for which to generate a JSON Schema.
+     * @param options - Generation options.
+     * @returns The generated JSON Schema.
+     */
+    static generate(data: unknown, options?: JsonSchemaGeneratorOptions): JSONSchemaType;
+    /**
+     * Determines the primitive type of a value.
+     *
+     * @param data - The data whose type is to be inferred.
+     * @returns A string representing the type.
+     */
+    private static inferType;
+    /**
+     * Recursively builds a JSON Schema from the provided data.
+     *
+     * @param data - The data to interpret.
+     * @param options - Generation options.
+     * @returns A JSON Schema object.
+     */
+    private static buildSchema;
+    /**
+     * Checks if all types in an array are one of the primitive types:
+     * string, number, or boolean.
+     *
+     * @param types - An array of type strings.
+     * @returns True if every type is primitive.
+     */
+    private static allTypesArePrimitive;
+    /**
+     * Generates a JSON Schema for an array.
+     *
+     * @param data - The array data.
+     * @param options - Generation options.
+     * @returns The JSON Schema corresponding to the array data.
+     */
+    private static buildArraySchema;
+    /**
+     * Generates a JSON Schema for an array containing mixed types.
+     *
+     * @param data - The array data.
+     * @param options - Generation options.
+     * @returns The JSON Schema with an "anyOf" clause.
+     */
+    private static buildMixedArraySchema;
+    /**
+     * Generates a JSON Schema for an object.
+     *
+     * @param data - The object data.
+     * @param options - Generation options.
+     * @returns The JSON Schema for the object.
+     */
+    private static buildObjectSchema;
+    /**
+     * Attempts to merge two JSON Schemas. Merging is only successful if both schemas have the same type
+     * and there are no conflicts within defined properties.
+     *
+     * @param schemaA - The first JSON Schema.
+     * @param schemaB - The second JSON Schema.
+     * @returns The merged schema if successful; otherwise, null.
+     */
+    private static mergeTwoSchemas;
+    /**
+     * Merges an array of JSON Schemas. Schemas with the same type and non-conflicting
+     * definitions are merged together.
+     *
+     * @param schemas - The list of schemas to merge.
+     * @returns A deduplicated list of merged schemas.
+     */
+    private static mergeSimilarSchemas;
+}
+//# sourceMappingURL=json-schema-generator.d.ts.map

package/build/utils/json-schema-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-generator.d.ts","sourceRoot":"","sources":["../../src/utils/json-schema-generator.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;KAAE,CAAC;IAC/C,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAmB;IAE3C;;;;;;OAMG;WACW,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI;IAOnE;;;;;;OAMG;WACW,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,0BAA+B,GAAG,cAAc;IAM/F;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAOxB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAc1B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAInC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA4B/B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAYpC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAoBhC;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAoC9B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;CAkCnC"}