@c-rex/services 0.0.6 → 0.0.7

package/src/__tests__/informationUnits.test.ts

@@ -1,161 +0,0 @@
-import { InformationUnitsService } from '../';
-import { CrexSDK } from '@c-rex/core';
-import { createParams, generateQueryParams } from '@c-rex/utils';
-import { transformInformationUnits } from '../transforms/information';
-
-jest.mock('@c-rex/core', () => ({
-    CrexSDK: {
-        getInstance: jest.fn().mockReturnValue({
-            api: {
-                execute: jest.fn()
-            },
-            logger: {
-                log: jest.fn()
-            }
-        })
-    }
-}));
-
-jest.mock('@c-rex/utils', () => ({
-    createParams: jest.fn(),
-    generateQueryParams: jest.fn()
-}));
-
-jest.mock('../transforms/information', () => ({
-    transformInformationUnits: jest.fn()
-}));
-
-describe('InformationUnitsService', () => {
-    let service: InformationUnitsService;
-    const sdk = CrexSDK.getInstance();
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        service = new InformationUnitsService();
-
-        (generateQueryParams as jest.Mock).mockReturnValue("");
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    describe('getList', () => {
-        const fields = ['field1', 'field2'];
-        const mockFieldParams = [{ key: 'Fields', value: 'field1' }];
-        const mockResponse = { items: [], pageInfo: {} };
-        const language = 'EN-us';
-
-        beforeEach(() => {
-            (createParams as jest.Mock).mockReturnValue(mockFieldParams);
-            (transformInformationUnits as jest.Mock).mockReturnValue(mockResponse);
-            (generateQueryParams as jest.Mock).mockReturnValue("mockedParams=true");
-            (sdk.api.execute as jest.Mock).mockResolvedValue(mockResponse);
-        });
-
-        it('should fetch information units list with correct parameters', async () => {
-            const result = await service.getList('test', 2, fields, [language]);
-
-            expect(createParams).toHaveBeenCalledWith(fields, "Fields");
-            expect(transformInformationUnits).toHaveBeenCalledWith(mockResponse);
-            expect(generateQueryParams).toHaveBeenCalledWith([
-                {
-                    key: 'pageSize',
-                    value: '8'
-                },
-                {
-                    key: 'PageNumber',
-                    value: '1'
-                },
-                {
-                    key: 'Query',
-                    value: 'test'
-                },
-                ...mockFieldParams,
-                {
-                    key: 'Restrict',
-                    value: 'languages~EN-us'
-                },
-            ]);
-            expect(sdk.api.execute).toHaveBeenCalledWith({
-                url: 'InformationUnits/?mockedParams=true',
-                method: 'get',
-                headers: {},
-            });
-            expect(result).toEqual(mockResponse);
-        });
-
-        it('should handle null language parameter', async () => {
-            const spy = jest.spyOn(service, 'request' as any);
-            await service.getList('test', 1, ['field1'], null);
-
-            expect(spy).toHaveBeenCalledWith(
-                expect.not.objectContaining({
-                    params: expect.arrayContaining([
-                        expect.objectContaining({ key: 'Restrict' })
-                    ])
-                })
-            );
-        });
-    });
-
-    describe('getItem', () => {
-        it('should fetch a single information unit', async () => {
-            const id = '123';
-            const mockResponse = { id: '123', title: 'Test' };
-
-            (sdk.api.execute as jest.Mock).mockResolvedValue({ data: mockResponse });
-            (generateQueryParams as jest.Mock).mockReturnValueOnce("mockedParams=true");
-
-            const result = await service.getItem(id);
-
-            expect(generateQueryParams).toHaveBeenCalledWith([
-                { key: "Fields", value: "renditions" },
-                { key: "Fields", value: "directoryNodes" },
-            ]);
-            expect(sdk.api.execute).toHaveBeenCalledWith({
-                url: 'InformationUnits/123?mockedParams=true',
-                method: 'get',
-                headers: {},
-            });
-            expect(result).toEqual(mockResponse);
-        });
-    });
-
-    describe('getLanguages', () => {
-        it('should fetch and transform languages', async () => {
-            const mockResponse = [{ value: 'EN', score: 1 }, { value: 'DE', score: 1 }];
-            (sdk.api.execute as jest.Mock).mockResolvedValue(mockResponse);
-
-            const result = await service.getLanguages();
-
-            expect(sdk.api.execute).toHaveBeenCalledWith({
-                url: 'InformationUnits/Languages',
-                method: 'get',
-                headers: {}
-            });
-            expect(result).toEqual(['EN', 'DE']);
-        });
-    });
-
-    describe('getSuggestions', () => {
-        it('should fetch and transform suggestions', async () => {
-            const query = 'test';
-            const mockResponse = { suggestions: [{ value: 'test1' }, { value: 'test2' }] };
-
-            (sdk.api.execute as jest.Mock).mockResolvedValue(mockResponse);
-            (generateQueryParams as jest.Mock).mockReturnValueOnce("mockedParams=true");
-
-            const result = await service.getSuggestions(query);
-
-            expect(generateQueryParams).toHaveBeenCalledWith([
-                { key: "prefix", value: "test" },
-            ]);
-            expect(sdk.api.execute).toHaveBeenCalledWith({
-                url: 'InformationUnits/Suggestions?mockedParams=true',
-                method: 'get',
-                headers: {},
-            });
-            expect(result).toEqual(['test1', 'test2']);
-        });
-    });
-});

package/src/__tests__/renditions.test.ts

@@ -1,7 +0,0 @@
-import '../renditions';
-
-describe('Force coverage inclusion', () => {
-    it('Dummy', () => {
-        expect(true).toBe(true);
-    });
-});

package/src/baseService.ts

@@ -1,57 +0,0 @@
-import { CrexSDK, CrexApi } from "@c-rex/core";
-import { LogCategoriesType, LogLevelType, QueryParams } from "@c-rex/types";
-import { generateQueryParams } from "@c-rex/utils";
-import { Method } from "axios";
-
-export class BaseService {
-    protected api: CrexApi;
-    private log: (level: LogLevelType, message: string, category?: LogCategoriesType) => void;
-    private endpoint: string;
-    private SDK: CrexSDK;
-
-    constructor(endpoint: string) {
-        this.SDK = CrexSDK.getInstance();
-        this.api = this.SDK.api;
-        this.log = this.SDK.logger.log;
-        this.endpoint = endpoint;
-    }
-
-    protected async request<T>(
-        {
-            path = "",
-            method = "get",
-            params = [],
-            headers = {},
-            transformer = (response: any) => response,
-        }: {
-            path?: string,
-            method?: Method,
-            params?: QueryParams[],
-            headers?: any,
-            transformer?: (data: any) => T,
-        }
-    ): Promise<T> {
-        try {
-            let url = `${this.endpoint}${path}`;
-
-            const queryParams = generateQueryParams(params);
-            if (queryParams.length > 0) {
-                url += `?${queryParams}`;
-            }
-
-            const response = await this.api.execute({
-                url,
-                method,
-                headers,
-            })
-
-            return await transformer(response);
-
-        } catch (error) {
-            this.log("error", `BaseService.request error when request ${path}. Error: ${error}`);
-
-            throw error;
-        }
-    }
-}
-

package/src/directoryNodes.ts

@@ -1,15 +0,0 @@
-import { BaseService } from "./baseService";
-import { DirectoryNodes } from "@c-rex/interfaces";
-
-
-export class DirectoryNodesService extends BaseService {
-    constructor() {
-        super("DirectoryNodes/");
-    }
-
-    public async getItem(id: string): Promise<DirectoryNodes> {
-        return await this.request({
-            path: id,
-        });
-    }
-}

package/src/documentTypes.ts

@@ -1,23 +0,0 @@
-import { createParams } from "@c-rex/utils";
-import { transformDocumentTypes } from "./transforms/documentTypes";
-import { BaseService } from "./baseService";
-
-export class DocumentTypesService extends BaseService {
-    constructor() {
-        super("DocumentTypes/");
-    }
-    public async getLabels(fields: string[]): Promise<string[]> {
-        const params = [
-            {
-                key: "Restrict",
-                value: `languages~EN-us`,
-            },
-            ...createParams(fields, "Fields"),
-        ];
-
-        return await this.request({
-            params,
-            transformer: transformDocumentTypes,
-        });
-    }
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./renditions"
-export * from "./directoryNodes"
-export * from "./documentTypes"
-export * from "./informationUnits"

package/src/informationUnits.ts

@@ -1,75 +0,0 @@
-import {
-    AutocompleteSuggestion,
-    informationUnits,
-    informationUnitsItems,
-} from "@c-rex/interfaces";
-import { transformInformationUnits } from "./transforms/information";
-import { createParams } from "@c-rex/utils";
-import { BaseService } from "./baseService";
-
-export class InformationUnitsService extends BaseService {
-    constructor() {
-        super("InformationUnits/");
-    }
-
-    public async getList(
-        queries: string,
-        page: number,
-        fields: string[],
-        language: string[] | null,
-    ): Promise<informationUnits> {
-        const remainFields = createParams(fields, "Fields");
-
-        const params = [
-            { key: "pageSize", value: "8" },
-            { key: "PageNumber", value: (page - 1).toString() },
-            { key: "Query", value: queries },
-            ...remainFields,
-        ];
-
-        if (language != null) {
-            language.forEach((item) => {
-                params.push({
-                    key: "Restrict",
-                    value: `languages~${item}`,
-                });
-            });
-        }
-
-        return await this.request({
-            params: params,
-            transformer: transformInformationUnits
-        });
-    }
-
-    public async getItem(id: string): Promise<informationUnitsItems> {
-        const params = [
-            { key: "Fields", value: "renditions" },
-            { key: "Fields", value: "directoryNodes" },
-        ];
-
-        return await this.request({
-            path: id,
-            params,
-        });
-    }
-
-    public async getLanguages(): Promise<string[]> {
-        return await this.request({
-            path: `Languages`,
-            transformer: (data: { value: string; score: number }[]) => {
-                return data.map((item) => item.value);
-            },
-        });
-    }
-
-    public async getSuggestions(query: string): Promise<string[]> {
-        return await this.request({
-            path: `Suggestions`,
-            params: [{ key: "prefix", value: query }],
-            transformer: (data: AutocompleteSuggestion) => {
-                return data.suggestions.map((item) => item.value);
-            },
-        });
-    }
-}

package/src/renditions.ts

@@ -1,38 +0,0 @@
-import { BaseService } from "./baseService";
-import { informationUnitsRenditions } from "@c-rex/interfaces";
-
-
-export class RenditionsService extends BaseService {
-    constructor() {
-        super("Renditions/");
-    }
-
-    public async getHTMLRendition(renditions: informationUnitsRenditions[]): Promise<string> {
-        const filteredRenditions = renditions.filter(
-            (item) => item.format == "application/xhtml+xml",
-        );
-
-        if (filteredRenditions.length == 0) return "";
-        if (filteredRenditions[0] == undefined) return "";
-
-        const item = filteredRenditions[0];
-
-        const filteredLinks = item.links.filter((item) => item.rel == "view");
-
-        if (filteredLinks.length == 0) return "";
-        if (filteredLinks[0] == undefined) return "";
-
-
-        const url = filteredLinks[0].href;
-
-        const response = await this.api.execute({
-            url,
-            method: "get",
-            headers: {
-                Accept: "application/xhtml+xml",
-            },
-        })
-
-        return response;
-    }
-}

package/src/transforms/__tests__/documentTypes.test.ts

@@ -1,28 +0,0 @@
-import { DefaultRequest, DocumentTypesItem } from '@c-rex/interfaces';
-import { transformDocumentTypes } from '../documentTypes';
-
-describe('transformDocumentTypes', () => {
-    it('should transform information units', () => {
-        const mockResponse = {
-            items: [
-                {
-                    labels: [
-                        {
-                            value: "Title 1",
-                            language: 'en',
-                        }, {
-                            value: "Title 2",
-                            language: 'fr',
-                        }, {
-                            value: "Title 3",
-                            language: 'en',
-                        }
-                    ],
-                },
-            ],
-        } as unknown as DefaultRequest<DocumentTypesItem>;
-
-        const result = transformDocumentTypes(mockResponse);
-        expect(result).toEqual(['Title 1', 'Title 3']);
-    });
-});

package/src/transforms/__tests__/information.test.ts

@@ -1,34 +0,0 @@
-import { DefaultRequest } from '@c-rex/interfaces';
-import { transformInformationUnits } from '../information';
-import { informationUnitsItems } from '@c-rex/interfaces';
-
-describe('transformInformationUnits', () => {
-    it('should transform information units', () => {
-        const mockResponse = {
-            items: [
-                {
-                    id: '1',
-                    title: 'Title 1',
-                    description: 'Description 1',
-                }
-            ],
-            pageInfo: {
-                totalCount: 1
-            },
-        } as unknown as DefaultRequest<informationUnitsItems>;
-
-        const result = transformInformationUnits(mockResponse);
-        expect(result).toEqual({
-            items: [
-                {
-                    id: '1',
-                    title: 'Title 1',
-                    description: 'Description 1',
-                }
-            ],
-            pageInfo: {
-                totalCount: 1
-            },
-        });
-    });
-});

package/src/transforms/documentTypes.ts

@@ -1,16 +0,0 @@
-import { DefaultRequest } from "@c-rex/interfaces";
-import { DocumentTypesItem } from "@c-rex/interfaces";
-
-export const transformDocumentTypes = (data: DefaultRequest<DocumentTypesItem>) => {
-    const labels: string[] = [];
-
-    data.items.forEach((documentItem: DocumentTypesItem) => {
-        const aux = documentItem.labels.flatMap((item) => item);
-
-        aux.forEach((item) => {
-            if (item.language == "en") labels.push(item.value);
-        });
-    });
-
-    return labels;
-};

package/src/transforms/information.ts

@@ -1,14 +0,0 @@
-import { DefaultRequest } from "@c-rex/interfaces";
-import {
-    informationUnits,
-    informationUnitsItems,
-} from "@c-rex/interfaces";
-
-export const transformInformationUnits = (
-    data: DefaultRequest<informationUnitsItems>,
-): informationUnits => {
-    return {
-        items: data.items.map((item) => item),
-        pageInfo: data.pageInfo,
-    };
-};