@coveo/push-api-client 3.0.122 → 3.0.123

package/dist/fieldAnalyser/fieldAnalyser.spec.js

@@ -1,231 +1,231 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-jest.mock('@coveo/platform-client');
-const platform_client_1 = require("@coveo/platform-client");
-const __1 = require("..");
-const fieldErrors_1 = require("../errors/fieldErrors");
-const fieldAnalyser_1 = require("./fieldAnalyser");
-const buildDocument = (metadata) => {
-    const doc = new __1.DocumentBuilder('https://my.document.uri', 'some title');
-    if (metadata) {
-        doc.withMetadata(metadata);
-    }
-    return doc;
-};
-const docWithNewFields = buildDocument({
-    some_integer: 100,
-    promo_price: 23.99,
-    description: 'Plumbus can generate and store vast amounts of heat, allowing it to be used for cooking, ironing or just heating the room.',
-    additional_info: 'Plumbus can secrete various agents from itself and has adaptive rubbing surfaces, making it useful for cleaning.',
-    price: 'six-and-a-half Brapples',
-    category: 'Various',
-    available: true,
-});
-const docWithExistingFields = buildDocument({
-    type: 'Teleportation Device',
-    category: 'Electronics',
-})
-    .withAuthor('Rick')
-    .withFileExtension('.pewpew');
-const dummyPlatformClient = () => {
-    return new platform_client_1.default({ accessToken: 'xxx' });
-};
-describe('FieldAnalyser', () => {
-    let analyser;
-    const mockedPlatformClient = jest.mocked(platform_client_1.default);
-    const mockedListFields = jest.fn();
-    const mockEvaluate = jest.fn();
-    const mockListFieldsWithValidPermanentId = () => {
-        mockedListFields
-            .mockResolvedValueOnce({
-            items: [
-                { name: 'brand', type: platform_client_1.FieldTypes.STRING },
-                { name: 'category', type: platform_client_1.FieldTypes.STRING },
-                { name: 'permanentid', type: platform_client_1.FieldTypes.STRING },
-            ],
-            totalPages: 2,
-        })
-            .mockResolvedValueOnce({
-            items: [{ name: 'type' }],
-            totalPages: 2,
-        });
-    };
-    const mockListFieldsWithInvalidPermanentId = () => {
-        mockedListFields.mockResolvedValueOnce({
-            items: [{ name: 'permanentid', type: platform_client_1.FieldTypes.DATE }],
-            totalPages: 1,
-        });
-    };
-    const mockListFieldsWithNoPermanentId = () => {
-        mockedListFields.mockResolvedValueOnce({
-            items: [],
-            totalPages: 1,
-        });
-    };
-    const doMockPlatformClient = () => {
-        mockedPlatformClient.mockImplementation(() => ({
-            privilegeEvaluator: { evaluate: mockEvaluate },
-            field: { list: mockedListFields },
-        }));
-    };
-    beforeAll(() => {
-        doMockPlatformClient();
-    });
-    beforeEach(() => {
-        mockEvaluate.mockResolvedValue({ approved: true });
-        mockedListFields.mockReset();
-        analyser = new fieldAnalyser_1.FieldAnalyser(dummyPlatformClient());
-    });
-    describe('when client is not allowed to create fields', () => {
-        beforeEach(async () => {
-            mockEvaluate.mockReset();
-            mockListFieldsWithValidPermanentId();
-        });
-        it('should throw an error', async () => {
-            mockEvaluate.mockResolvedValue({ approved: false });
-            await expect(analyser.add([docWithExistingFields])).rejects.toThrow();
-        });
-    });
-    describe('when fields from the batch already exist in the org', () => {
-        let report;
-        beforeEach(async () => {
-            mockListFieldsWithValidPermanentId();
-            report = (await analyser.add([docWithExistingFields])).report();
-        });
-        afterEach(() => { });
-        it('should not return fields to create', async () => {
-            expect(report.fields).toStrictEqual([]);
-        });
-        it('should not detect inconsistencies', async () => {
-            expect(report.inconsistencies.size).toStrictEqual(0);
-        });
-    });
-    describe('when batch contain new fields', () => {
-        beforeEach(() => {
-            mockListFieldsWithValidPermanentId();
-        });
-        it('should return fields to create', async () => {
-            const docBuilders = [docWithNewFields, docWithExistingFields];
-            const { fields } = (await analyser.add(docBuilders)).report();
-            expect(fields).toStrictEqual([
-                {
-                    name: 'some_integer',
-                    type: 'LONG',
-                },
-                {
-                    name: 'promo_price',
-                    type: 'DOUBLE',
-                },
-                {
-                    name: 'description',
-                    type: 'STRING',
-                },
-                {
-                    name: 'additional_info',
-                    type: 'STRING',
-                },
-                {
-                    name: 'price',
-                    type: 'STRING',
-                },
-                {
-                    name: 'available',
-                    type: 'STRING',
-                },
-            ]);
-        });
-        it('should always take the most englobing numeric type regardless of the transition direction', async () => {
-            const docBuilders = [
-                buildDocument({
-                    from_long_to_double: 10,
-                    from_double_to_long: 20.1,
-                }),
-                buildDocument({
-                    from_long_to_double: 10.1,
-                    from_double_to_long: 20,
-                }),
-            ];
-            const { fields } = (await analyser.add(docBuilders)).report();
-            expect(fields).toStrictEqual([
-                {
-                    name: 'from_long_to_double',
-                    type: 'DOUBLE',
-                },
-                {
-                    name: 'from_double_to_long',
-                    type: 'DOUBLE',
-                },
-            ]);
-        });
-    });
-    describe('when the batch contains inconsistent metadata', () => {
-        let report;
-        const docBuilders = [
-            docWithNewFields,
-            docWithExistingFields,
-            buildDocument({ price: 6.5, available: 0 }),
-            buildDocument({ available: 1 }),
-        ];
-        beforeEach(async () => {
-            mockListFieldsWithValidPermanentId();
-            report = (await analyser.add(docBuilders)).report();
-        });
-        it('should detect 2 inconsistencies', () => {
-            expect(report.inconsistencies.size).toBe(2);
-        });
-        it('should detect type inconsistencies', () => {
-            const inconsistenciesSet = report.inconsistencies;
-            expect(inconsistenciesSet.get('price')).toStrictEqual(new Set(['DOUBLE', 'STRING']));
-            expect(inconsistenciesSet.get('available')).toStrictEqual(new Set(['LONG', 'STRING']));
-        });
-        it('should still provide fields to create', () => {
-            expect(report.fields).toStrictEqual([
-                {
-                    name: 'some_integer',
-                    type: 'LONG',
-                },
-                {
-                    name: 'promo_price',
-                    type: 'DOUBLE',
-                },
-                {
-                    name: 'description',
-                    type: 'STRING',
-                },
-                {
-                    name: 'additional_info',
-                    type: 'STRING',
-                },
-            ]);
-        });
-        it('should not return fields with inconsistencies', () => {
-            report.fields.forEach((field) => {
-                expect(field.name).not.toEqual('available');
-                expect(field.name).not.toEqual('price');
-            });
-        });
-    });
-    describe('when permanentId is not correctly configured', () => {
-        beforeEach(() => {
-            mockListFieldsWithInvalidPermanentId();
-        });
-        it('should throw an error', async () => {
-            await analyser.add([docWithExistingFields]);
-            expect(() => analyser.report()).toThrow(fieldErrors_1.InvalidPermanentId);
-        });
-    });
-    describe('when permanentId is missing from the organization', () => {
-        beforeEach(() => {
-            mockListFieldsWithNoPermanentId();
-        });
-        it('should include permanentid field in the analysis report', async () => {
-            await analyser.add([docWithExistingFields]);
-            const report = analyser.report();
-            expect(report.fields).toContainEqual({
-                name: 'permanentid',
-                type: 'STRING',
-            });
-        });
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@coveo/platform-client');
+const platform_client_1 = require("@coveo/platform-client");
+const __1 = require("..");
+const fieldErrors_1 = require("../errors/fieldErrors");
+const fieldAnalyser_1 = require("./fieldAnalyser");
+const buildDocument = (metadata) => {
+    const doc = new __1.DocumentBuilder('https://my.document.uri', 'some title');
+    if (metadata) {
+        doc.withMetadata(metadata);
+    }
+    return doc;
+};
+const docWithNewFields = buildDocument({
+    some_integer: 100,
+    promo_price: 23.99,
+    description: 'Plumbus can generate and store vast amounts of heat, allowing it to be used for cooking, ironing or just heating the room.',
+    additional_info: 'Plumbus can secrete various agents from itself and has adaptive rubbing surfaces, making it useful for cleaning.',
+    price: 'six-and-a-half Brapples',
+    category: 'Various',
+    available: true,
+});
+const docWithExistingFields = buildDocument({
+    type: 'Teleportation Device',
+    category: 'Electronics',
+})
+    .withAuthor('Rick')
+    .withFileExtension('.pewpew');
+const dummyPlatformClient = () => {
+    return new platform_client_1.default({ accessToken: 'xxx' });
+};
+describe('FieldAnalyser', () => {
+    let analyser;
+    const mockedPlatformClient = jest.mocked(platform_client_1.default);
+    const mockedListFields = jest.fn();
+    const mockEvaluate = jest.fn();
+    const mockListFieldsWithValidPermanentId = () => {
+        mockedListFields
+            .mockResolvedValueOnce({
+            items: [
+                { name: 'brand', type: platform_client_1.FieldTypes.STRING },
+                { name: 'category', type: platform_client_1.FieldTypes.STRING },
+                { name: 'permanentid', type: platform_client_1.FieldTypes.STRING },
+            ],
+            totalPages: 2,
+        })
+            .mockResolvedValueOnce({
+            items: [{ name: 'type' }],
+            totalPages: 2,
+        });
+    };
+    const mockListFieldsWithInvalidPermanentId = () => {
+        mockedListFields.mockResolvedValueOnce({
+            items: [{ name: 'permanentid', type: platform_client_1.FieldTypes.DATE }],
+            totalPages: 1,
+        });
+    };
+    const mockListFieldsWithNoPermanentId = () => {
+        mockedListFields.mockResolvedValueOnce({
+            items: [],
+            totalPages: 1,
+        });
+    };
+    const doMockPlatformClient = () => {
+        mockedPlatformClient.mockImplementation(() => ({
+            privilegeEvaluator: { evaluate: mockEvaluate },
+            field: { list: mockedListFields },
+        }));
+    };
+    beforeAll(() => {
+        doMockPlatformClient();
+    });
+    beforeEach(() => {
+        mockEvaluate.mockResolvedValue({ approved: true });
+        mockedListFields.mockReset();
+        analyser = new fieldAnalyser_1.FieldAnalyser(dummyPlatformClient());
+    });
+    describe('when client is not allowed to create fields', () => {
+        beforeEach(async () => {
+            mockEvaluate.mockReset();
+            mockListFieldsWithValidPermanentId();
+        });
+        it('should throw an error', async () => {
+            mockEvaluate.mockResolvedValue({ approved: false });
+            await expect(analyser.add([docWithExistingFields])).rejects.toThrow();
+        });
+    });
+    describe('when fields from the batch already exist in the org', () => {
+        let report;
+        beforeEach(async () => {
+            mockListFieldsWithValidPermanentId();
+            report = (await analyser.add([docWithExistingFields])).report();
+        });
+        afterEach(() => { });
+        it('should not return fields to create', async () => {
+            expect(report.fields).toStrictEqual([]);
+        });
+        it('should not detect inconsistencies', async () => {
+            expect(report.inconsistencies.size).toStrictEqual(0);
+        });
+    });
+    describe('when batch contain new fields', () => {
+        beforeEach(() => {
+            mockListFieldsWithValidPermanentId();
+        });
+        it('should return fields to create', async () => {
+            const docBuilders = [docWithNewFields, docWithExistingFields];
+            const { fields } = (await analyser.add(docBuilders)).report();
+            expect(fields).toStrictEqual([
+                {
+                    name: 'some_integer',
+                    type: 'LONG',
+                },
+                {
+                    name: 'promo_price',
+                    type: 'DOUBLE',
+                },
+                {
+                    name: 'description',
+                    type: 'STRING',
+                },
+                {
+                    name: 'additional_info',
+                    type: 'STRING',
+                },
+                {
+                    name: 'price',
+                    type: 'STRING',
+                },
+                {
+                    name: 'available',
+                    type: 'STRING',
+                },
+            ]);
+        });
+        it('should always take the most englobing numeric type regardless of the transition direction', async () => {
+            const docBuilders = [
+                buildDocument({
+                    from_long_to_double: 10,
+                    from_double_to_long: 20.1,
+                }),
+                buildDocument({
+                    from_long_to_double: 10.1,
+                    from_double_to_long: 20,
+                }),
+            ];
+            const { fields } = (await analyser.add(docBuilders)).report();
+            expect(fields).toStrictEqual([
+                {
+                    name: 'from_long_to_double',
+                    type: 'DOUBLE',
+                },
+                {
+                    name: 'from_double_to_long',
+                    type: 'DOUBLE',
+                },
+            ]);
+        });
+    });
+    describe('when the batch contains inconsistent metadata', () => {
+        let report;
+        const docBuilders = [
+            docWithNewFields,
+            docWithExistingFields,
+            buildDocument({ price: 6.5, available: 0 }),
+            buildDocument({ available: 1 }),
+        ];
+        beforeEach(async () => {
+            mockListFieldsWithValidPermanentId();
+            report = (await analyser.add(docBuilders)).report();
+        });
+        it('should detect 2 inconsistencies', () => {
+            expect(report.inconsistencies.size).toBe(2);
+        });
+        it('should detect type inconsistencies', () => {
+            const inconsistenciesSet = report.inconsistencies;
+            expect(inconsistenciesSet.get('price')).toStrictEqual(new Set(['DOUBLE', 'STRING']));
+            expect(inconsistenciesSet.get('available')).toStrictEqual(new Set(['LONG', 'STRING']));
+        });
+        it('should still provide fields to create', () => {
+            expect(report.fields).toStrictEqual([
+                {
+                    name: 'some_integer',
+                    type: 'LONG',
+                },
+                {
+                    name: 'promo_price',
+                    type: 'DOUBLE',
+                },
+                {
+                    name: 'description',
+                    type: 'STRING',
+                },
+                {
+                    name: 'additional_info',
+                    type: 'STRING',
+                },
+            ]);
+        });
+        it('should not return fields with inconsistencies', () => {
+            report.fields.forEach((field) => {
+                expect(field.name).not.toEqual('available');
+                expect(field.name).not.toEqual('price');
+            });
+        });
+    });
+    describe('when permanentId is not correctly configured', () => {
+        beforeEach(() => {
+            mockListFieldsWithInvalidPermanentId();
+        });
+        it('should throw an error', async () => {
+            await analyser.add([docWithExistingFields]);
+            expect(() => analyser.report()).toThrow(fieldErrors_1.InvalidPermanentId);
+        });
+    });
+    describe('when permanentId is missing from the organization', () => {
+        beforeEach(() => {
+            mockListFieldsWithNoPermanentId();
+        });
+        it('should include permanentid field in the analysis report', async () => {
+            await analyser.add([docWithExistingFields]);
+            const report = analyser.report();
+            expect(report.fields).toContainEqual({
+                name: 'permanentid',
+                type: 'STRING',
+            });
+        });
+    });
+});
 //# sourceMappingURL=fieldAnalyser.spec.js.map

package/dist/fieldAnalyser/fieldStore.js

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldStore = void 0;
-class FieldStore extends Map {
-    concat(fieldBuilder) {
-        fieldBuilder.forEach((type, name) => {
-            this.set(name, type);
-        });
-    }
-    marshal() {
-        const fieldModels = [];
-        this.forEach((fieldType, fieldName) => {
-            fieldModels.push({
-                name: fieldName,
-                type: fieldType,
-            });
-        });
-        return fieldModels;
-    }
-}
-exports.FieldStore = FieldStore;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldStore = void 0;
+class FieldStore extends Map {
+    concat(fieldBuilder) {
+        fieldBuilder.forEach((type, name) => {
+            this.set(name, type);
+        });
+    }
+    marshal() {
+        const fieldModels = [];
+        this.forEach((fieldType, fieldName) => {
+            fieldModels.push({
+                name: fieldName,
+                type: fieldType,
+            });
+        });
+        return fieldModels;
+    }
+}
+exports.FieldStore = FieldStore;
 //# sourceMappingURL=fieldStore.js.map

package/dist/fieldAnalyser/fieldUtils.js

@@ -1,42 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFieldNameValid = exports.createFieldsFromReport = exports.createFields = exports.listAllFieldsFromOrg = void 0;
-const fieldErrors_1 = require("../errors/fieldErrors");
-const apiKeyPrivilege_1 = require("../validation/preconditions/apiKeyPrivilege");
-const platformPrivilege_1 = require("../validation/preconditions/platformPrivilege");
-const allowedCharRegExp = new RegExp('^[a-z]+[a-z0-9_]*$');
-const listAllFieldsFromOrg = async (client, page = 0, fields = []) => {
-    await (0, apiKeyPrivilege_1.ensureNecessaryCoveoPrivileges)(client, platformPrivilege_1.readFieldsPrivilege);
-    const list = await client.field.list({
-        page,
-        perPage: 1000,
-    });
-    fields.push(...list.items);
-    if (page < list.totalPages - 1) {
-        return (0, exports.listAllFieldsFromOrg)(client, page + 1, fields);
-    }
-    return fields;
-};
-exports.listAllFieldsFromOrg = listAllFieldsFromOrg;
-const createFields = async (client, fields, fieldBatch = 500) => {
-    await (0, apiKeyPrivilege_1.ensureNecessaryCoveoPrivileges)(client, platformPrivilege_1.writeFieldsPrivilege);
-    for (let i = 0; i < fields.length; i += fieldBatch) {
-        const batch = fields.slice(i, fieldBatch + i);
-        await client.field.createFields(batch);
-    }
-};
-exports.createFields = createFields;
-const createFieldsFromReport = async (client, report) => {
-    {
-        if (report.inconsistencies.size > 0) {
-            throw new fieldErrors_1.FieldTypeInconsistencyError(report.inconsistencies);
-        }
-        await (0, exports.createFields)(client, report.fields);
-    }
-};
-exports.createFieldsFromReport = createFieldsFromReport;
-const isFieldNameValid = (fieldName) => {
-    return allowedCharRegExp.test(fieldName.toLowerCase());
-};
-exports.isFieldNameValid = isFieldNameValid;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFieldNameValid = exports.createFieldsFromReport = exports.createFields = exports.listAllFieldsFromOrg = void 0;
+const fieldErrors_1 = require("../errors/fieldErrors");
+const apiKeyPrivilege_1 = require("../validation/preconditions/apiKeyPrivilege");
+const platformPrivilege_1 = require("../validation/preconditions/platformPrivilege");
+const allowedCharRegExp = new RegExp('^[a-z]+[a-z0-9_]*$');
+const listAllFieldsFromOrg = async (client, page = 0, fields = []) => {
+    await (0, apiKeyPrivilege_1.ensureNecessaryCoveoPrivileges)(client, platformPrivilege_1.readFieldsPrivilege);
+    const list = await client.field.list({
+        page,
+        perPage: 1000,
+    });
+    fields.push(...list.items);
+    if (page < list.totalPages - 1) {
+        return (0, exports.listAllFieldsFromOrg)(client, page + 1, fields);
+    }
+    return fields;
+};
+exports.listAllFieldsFromOrg = listAllFieldsFromOrg;
+const createFields = async (client, fields, fieldBatch = 500) => {
+    await (0, apiKeyPrivilege_1.ensureNecessaryCoveoPrivileges)(client, platformPrivilege_1.writeFieldsPrivilege);
+    for (let i = 0; i < fields.length; i += fieldBatch) {
+        const batch = fields.slice(i, fieldBatch + i);
+        await client.field.createFields(batch);
+    }
+};
+exports.createFields = createFields;
+const createFieldsFromReport = async (client, report) => {
+    {
+        if (report.inconsistencies.size > 0) {
+            throw new fieldErrors_1.FieldTypeInconsistencyError(report.inconsistencies);
+        }
+        await (0, exports.createFields)(client, report.fields);
+    }
+};
+exports.createFieldsFromReport = createFieldsFromReport;
+const isFieldNameValid = (fieldName) => {
+    return allowedCharRegExp.test(fieldName.toLowerCase());
+};
+exports.isFieldNameValid = isFieldNameValid;
 //# sourceMappingURL=fieldUtils.js.map