@c-rex/core 0.0.4 → 0.0.6

package/package.json

@@ -1,36 +1,24 @@
 {
     "name": "@c-rex/core",
-    "version": "0.0.4",
-    "main": "dist/index.js",
-    "module": "dist/index.mjs",
-    "types": "dist/index.d.ts",
+    "version": "0.0.6",
     "files": [
-        "dist"
+        "src"
     ],
     "publishConfig": {
         "access": "public"
     },
     "exports": {
         ".": {
-            "types": "./dist/index.d.ts",
-            "import": "./dist/index.mjs",
-            "require": "./dist/index.js",
-            "default": "./dist/index.js"
+            "types": "./src/index.ts",
+            "import": "./src/index.ts",
+            "require": "./src/index.ts",
+            "default": "./src/index.ts"
         },
-        "./package.json": "./package.json",
-        "./logger.server": {
-            "import": "./dist/logger.server.mjs",
-            "require": "./dist/logger.server.cjs"
-        },
-        "./logger.client": {
-            "import": "./dist/logger.client.mjs",
-            "require": "./dist/logger.client.cjs"
-        }
+        "./package.json": "./package.json"
     },
-    "sideEffects": false,
     "scripts": {
-        "dev": "tsup src/index.ts --splitting --format cjs,esm --dts --watch",
-        "build": "tsup src/index.ts --splitting --format cjs,esm --dts",
+        "dev": "echo 'Nothing to build — using raw TypeScript files'",
+        "build": "echo 'No build needed'",
         "test:watch": "jest --watch",
         "test": "jest"
     },

package/src/__tests__/logger.test.ts

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

package/src/__tests__/requests.test.ts

@@ -0,0 +1,91 @@
+import { CrexApi } from '../requests';
+import { CrexLogger } from '../logger';
+import axios from 'axios';
+
+jest.mock('axios');
+jest.mock('../logger');
+
+describe('CrexApi', () => {
+    const mockBaseUrl = 'http://api.test.com';
+    const mockLogger = new CrexLogger({} as any);
+    let api: CrexApi;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        (axios.create as jest.Mock).mockReturnValue({
+            request: jest.fn()
+        });
+        api = new CrexApi(mockBaseUrl, mockLogger);
+    });
+
+    describe('execute', () => {
+        it('should make a successful API request', async () => {
+            const mockResponse = { data: { id: 1 }, status: 200 };
+            const mockAxiosInstance = axios.create();
+            (mockAxiosInstance.request as jest.Mock).mockResolvedValue(mockResponse);
+
+            const result = await api.execute({
+                url: '/test',
+                method: 'GET',
+                headers: { 'X-Test': 'test' }
+            });
+
+            expect(result).toEqual(mockResponse.data);
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                url: '/test',
+                method: 'GET',
+                headers: { 'X-Test': 'test' },
+                data: undefined,
+                params: undefined
+            });
+        });
+
+        it('should handle request with body and params', async () => {
+            const mockResponse = { data: { success: true }, status: 200 };
+            const mockAxiosInstance = axios.create();
+            (mockAxiosInstance.request as jest.Mock).mockResolvedValue(mockResponse);
+
+            await api.execute({
+                url: '/test',
+                method: 'POST',
+                body: { name: 'test' },
+                params: { id: 1 }
+            });
+
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith({
+                url: '/test',
+                method: 'POST',
+                data: { name: 'test' },
+                params: { id: 1 },
+                headers: undefined
+            });
+        });
+
+        it('should retry failed requests', async () => {
+            const mockError = new Error('Network error');
+            const mockAxiosInstance = axios.create();
+            (mockAxiosInstance.request as jest.Mock).mockRejectedValue(mockError);
+
+            await expect(api.execute({
+                url: '/test',
+                method: 'GET'
+            })).rejects.toThrow('Network error');
+
+            expect(mockLogger.log).toHaveBeenCalledWith(
+                'error',
+                expect.stringContaining('Network error')
+            );
+            expect(mockAxiosInstance.request).toHaveBeenCalledTimes(1);
+        });
+
+        it('should throw error when no valid response after retries', async () => {
+            const mockAxiosInstance = axios.create();
+            (mockAxiosInstance.request as jest.Mock).mockResolvedValue(undefined);
+
+            await expect(api.execute({
+                url: '/test',
+                method: 'GET'
+            })).rejects.toThrow('Failed to retrieve a valid response');
+        });
+    });
+});

package/src/__tests__/sdk.test.ts

@@ -0,0 +1,82 @@
+import { CrexSDK } from '../sdk';
+import { CrexLogger } from '../logger';
+import { CrexApi } from '../requests';
+import { ConfigInterface } from '@c-rex/interfaces';
+
+jest.mock('../logger');
+jest.mock('../requests');
+
+describe('CrexSDK', () => {
+    const mockConfig: ConfigInterface = {
+        projectName: 'test-project',
+        baseUrl: 'http://test.com',
+        search: {
+            fields: [],
+            tags: [],
+            restrict: [],
+            filter: [],
+            sparqlWhere: ''
+        },
+        logs: {
+            graylog: {
+                silent: true,
+                url: 'http://graylog.test',
+                app: 'test-app',
+                minimumLevel: 'info',
+                categoriesLevel: ['Document']
+            },
+            matomo: {
+                silent: false,
+                url: '',
+                app: '',
+                minimumLevel: 'info',
+                categoriesLevel: []
+            },
+            console: {
+                silent: false,
+                url: '',
+                app: '',
+                minimumLevel: 'info',
+                categoriesLevel: []
+            }
+        }
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset the singleton instance
+        (CrexSDK as any).instance = undefined;
+    });
+
+    describe('constructor', () => {
+        it('should create a new instance with correct configuration', () => {
+            const sdk = new CrexSDK(mockConfig);
+
+            expect(sdk.customerConfig).toBe(mockConfig);
+            expect(sdk.logger).toBeInstanceOf(CrexLogger);
+            expect(sdk.api).toBeInstanceOf(CrexApi);
+            expect(CrexLogger).toHaveBeenCalledWith(mockConfig);
+            expect(CrexApi).toHaveBeenCalledWith(mockConfig.baseUrl, expect.any(CrexLogger));
+        });
+
+        it('should return existing instance if already initialized', () => {
+            const firstInstance = new CrexSDK(mockConfig);
+            const secondInstance = new CrexSDK(mockConfig);
+
+            expect(secondInstance).toBe(firstInstance);
+        });
+    });
+
+    describe('getInstance', () => {
+        it('should return existing instance', () => {
+            const sdk = new CrexSDK(mockConfig);
+            const instance = CrexSDK.getInstance();
+
+            expect(instance).toBe(sdk);
+        });
+
+        it('should throw error if instance not initialized', () => {
+            expect(() => CrexSDK.getInstance()).toThrow('SDK not initialized');
+        });
+    });
+});

package/src/cli.ts

@@ -0,0 +1,189 @@
+/*
+import { execSync } from 'child_process';
+import { checkbox, confirm, input, select } from '@inquirer/prompts';
+
+import fs from 'fs';
+import path from 'path';
+import { FILTER_OPTIONS, LOG_CATEGORIES, LOG_LEVELS } from '../constants/log';
+import { RESULT_VIEW_OPTIONS } from '../constants/components';
+
+type Restriction = {
+    key: string;
+    value: string;
+    operator: string;
+}
+const addRestriction = async (word: string): Promise<Restriction[]> => {
+    const restrictions: any = []
+
+    let aux = await confirm({
+        message: `Do you want to add ${word}s to your search?`,
+        default: false,
+    });
+
+    while (aux) {
+        const restriction: Restriction = {
+            key: "",
+            value: '${value}',
+            operator: ""
+        }
+
+        restriction.key = await input({
+            message: `Type the ${word} key:`,
+        });
+
+        restriction.operator = await select({
+            message: `Type the ${word} operator:`,
+            choices: FILTER_OPTIONS.map(key => ({ value: key })),
+            default: FILTER_OPTIONS[0]
+        });
+
+        const byValue = await confirm({
+            message: `Do you want apply your ${word} using a fixed value?`,
+            default: false
+        });
+
+        if (byValue) {
+            restriction.value = await input({
+                message: `Type the ${word} value:`,
+            });
+        }
+
+        restrictions.push(restriction);
+
+        aux = await confirm({
+            message: `Do you want to add more ${word}s?`,
+            default: false
+        });
+    }
+
+    return restrictions;
+}
+
+const log = async (name: string): Promise<any> => {
+    const log = {
+        silent: false,
+        logLevel: [],
+        categoriesLevel: [],
+        url: "",
+        app: "",
+    }
+    log.silent = await confirm({
+        message: `Do you want to silent ${name}?`,
+        default: false
+    });
+
+    if (!log.silent) {
+        log.url = await input({
+            message: `Type the ${name} URL:`,
+        });
+        log.app = await input({
+            message: `Type the ${name} app name:`,
+        });
+        const logLevel = await checkbox({
+            message: `Select the log level to ${name}:`,
+            choices: Object.keys(LOG_LEVELS).map(key => {
+                return {
+                    value: key,
+                    checked: true,
+                };
+            }),
+        });
+        const categoriesLevel = await checkbox({
+            message: `Select the categories level to ${name}:`,
+            choices: LOG_CATEGORIES.map(key => {
+                return {
+                    value: key,
+                    checked: true,
+                };
+            }),
+        });
+
+        log.logLevel = logLevel as any;
+        log.categoriesLevel = categoriesLevel as any;
+    }
+
+    return log;
+}
+
+async function main() {
+    try {
+        const projectName = await input({
+            message: 'Set the project name:',
+            default: "c-rex.net"
+        });
+
+        const baseUrl = await input({
+            message: 'Set the base URL:',
+            default: "https://c-rex.net/ids/api/iirds/v1/"
+        });
+
+        const resultViewStyle = await select({
+            message: 'Results should be shown as:',
+            choices: Object.keys(RESULT_VIEW_OPTIONS).map(key => {
+                return { value: key };
+            }),
+            default: RESULT_VIEW_OPTIONS.table
+        });
+
+        const searchFields = await input({
+            message: 'Type the fields used in search separated by comma:',
+            default: "titles,labels,languages"
+        });
+
+        const searchTags = await input({
+            message: 'Type the tags used in search separated by comma:',
+            default: ""
+        });
+
+        const restrictions = await addRestriction("restriction");
+        const filters = await addRestriction("filter");
+
+        const sparqlWhere = await input({
+            message: 'Type the sparqlWhere string:',
+            default: ""
+        });
+
+        const graylog = await log("Graylog");
+        const matomo = await log("Matomo");
+
+        const config = {
+            projectName: projectName,
+            baseUrl: baseUrl,
+            search: {
+                fields: searchFields.split(','),
+                tags: searchTags.split(','),
+                restrict: restrictions,
+                filter: filters,
+                sparqlWhere: sparqlWhere
+            },
+            resultViewStyle: resultViewStyle,
+            logs: {
+                graylog: graylog,
+                matomo: matomo
+            }
+        }
+
+        const configFilePath = path.join(process.cwd(), 'src', 'config', 'customerConfig.ts');
+
+        const configFileContent = `
+import { ConfigInterface } from "@/interfaces/config";
+export const CUSTOMER_CONFIG: ConfigInterface = ${JSON.stringify(config, null, 4)};
+        `;
+
+        fs.writeFileSync(configFilePath, configFileContent);
+
+        console.log('Installing dependencies...');
+        execSync('npm install', { stdio: 'inherit' });
+
+        console.log('Configuration completed successfully!');
+    } catch (error: any) {
+        if (error instanceof Error && error.name === 'ExitPromptError') {
+            console.log('👋 until next time!');
+        } else {
+            console.error('Error during configuration:', error);
+        }
+    }
+}
+
+main();
+*/

package/src/index.ts

@@ -0,0 +1,3 @@
+//export * from "./logger";
+export * from "./requests";
+export * from "./sdk";

package/src/logger.ts

@@ -0,0 +1,24 @@
+import { ConfigInterface } from "@c-rex/interfaces";
+import { LogCategoriesType, LogLevelType } from "@c-rex/types";
+
+export class CrexLogger {
+    private customerConfig: ConfigInterface;
+
+    constructor(config: ConfigInterface) {
+        this.customerConfig = config;
+    }
+
+    async log(level: LogLevelType, message: string, category?: LogCategoriesType) {
+        if (typeof window === "undefined") {
+            const { LoggerServer } = await import("./logs/server");
+            const serverLog = new LoggerServer(this.customerConfig);
+            serverLog.log(level, message, category);
+        } else {
+            fetch("/api/log", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ level, message, category }),
+            }).catch((err) => console.error("Erro ao enviar log", err));
+        }
+    }
+}

package/src/logs/__tests__/server.test.ts

@@ -0,0 +1,97 @@
+import winston from 'winston';
+import { LogLevelType, LogCategoriesType } from '@c-rex/types';
+import { ConfigInterface } from '@c-rex/interfaces';
+import { LoggerServer } from '../server';
+import { MatomoTransport } from '../../transports/matomo';
+import { GraylogTransport } from '../../transports/graylog';
+
+jest.mock('winston', () => {
+    const actual = jest.requireActual('winston');
+    return {
+        ...actual,
+        createLogger: jest.fn(),
+        transports: {
+            Console: jest.fn().mockImplementation(() => ({
+                name: 'ConsoleTransport',
+            })),
+        },
+    };
+});
+
+jest.mock('../../transports/matomo', () => ({
+    MatomoTransport: jest.fn().mockImplementation(() => ({
+        name: 'MatomoTransport',
+    })),
+}));
+
+jest.mock('../../transports/graylog', () => ({
+    GraylogTransport: jest.fn().mockImplementation(() => ({
+        name: 'GraylogTransport',
+    })),
+}));
+
+describe('LoggerServer', () => {
+    const mockConfig: ConfigInterface = {
+        logs: {
+            console: {
+                minimumLevel: 'info',
+                silent: false,
+            },
+            graylog: {
+                minimumLevel: 'error',
+                silent: true,
+            },
+            matomo: {
+                categoriesLevel: [],
+            },
+        },
+        customerConfig: {
+            logs: {
+                matomo: {
+                    categoriesLevel: [],
+                },
+            },
+        },
+    } as unknown as ConfigInterface;
+
+    const mockLogger = {
+        log: jest.fn(),
+    };
+
+    beforeEach(() => {
+        (winston.createLogger as jest.Mock).mockReturnValue(mockLogger);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('deve criar o logger com os transports corretos', () => {
+        new LoggerServer(mockConfig);
+
+        expect(winston.transports.Console).toHaveBeenCalledWith({
+            level: 'info',
+            silent: false,
+        });
+
+        expect(MatomoTransport).toHaveBeenCalledWith({
+            level: 'info',
+            silent: false,
+        });
+
+        expect(GraylogTransport).toHaveBeenCalledWith({
+            level: 'error',
+            silent: true,
+        });
+
+        expect(winston.createLogger).toHaveBeenCalled();
+    });
+
+    it('deve chamar logger.log com os parâmetros corretos', () => {
+        const loggerServer = new LoggerServer(mockConfig);
+
+        loggerServer.log('info' as LogLevelType, 'mensagem de teste', 'analytics' as LogCategoriesType);
+
+        expect(mockLogger.log).toHaveBeenCalledWith('info', 'mensagem de teste', 'analytics');
+    });
+});

package/src/logs/server.ts

@@ -0,0 +1,38 @@
+import winston from "winston"
+import { LOG_LEVELS } from "@c-rex/constants";
+import { MatomoTransport } from "../transports/matomo"
+import { GraylogTransport } from "../transports/graylog"
+import { LogLevelType, LogCategoriesType } from "@c-rex/types";
+import { ConfigInterface } from "@c-rex/interfaces";
+
+const logger = (config: ConfigInterface) => {
+    return winston.createLogger({
+        levels: LOG_LEVELS,
+        transports: [
+            new winston.transports.Console({
+                level: config.logs.console.minimumLevel as string,
+                silent: config.logs.console.silent,
+            }),
+            new MatomoTransport({
+                level: config.logs.console.minimumLevel,
+                silent: config.logs.console.silent,
+            }),
+            new GraylogTransport({
+                level: config.logs.graylog.minimumLevel,
+                silent: config.logs.graylog.silent,
+            }),
+        ],
+    });
+}
+
+export class LoggerServer {
+    logger: winston.Logger;
+
+    constructor(config: ConfigInterface) {
+        this.logger = logger(config);
+    }
+
+    log(level: LogLevelType, message: string, category?: LogCategoriesType) {
+        this.logger.log(level, message, category);
+    }
+}

package/src/requests.ts

@@ -0,0 +1,62 @@
+import axios, { AxiosResponse, Method, AxiosInstance } from "axios";
+import { API } from "@c-rex/constants";
+import { CrexLogger } from "./logger";
+
+interface APIGenericResponse<T> extends AxiosResponse {
+    data: T;
+    statusCode: number;
+}
+
+interface CallParams {
+    url: string;
+    method: Method;
+    body?: any;
+    headers?: any;
+    params?: any;
+}
+
+export class CrexApi {
+    private apiClient: AxiosInstance;
+    private logger: CrexLogger;
+
+    public constructor(baseUrl: string, logger: CrexLogger) {
+        this.apiClient = axios.create({
+            baseURL: baseUrl,
+            headers: {
+                "content-Type": "application/json",
+            },
+        });
+        this.logger = logger;
+    }
+
+    async execute<T>({
+        url,
+        method,
+        params,
+        body,
+        headers,
+    }: CallParams): Promise<any> {
+        let response: APIGenericResponse<T> | undefined = undefined;
+
+        for (let retry = 0; retry < API.MAX_RETRY; retry++) {
+            try {
+                response = await this.apiClient.request({
+                    url,
+                    method,
+                    data: body,
+                    params,
+                    headers,
+                });
+            } catch (error) {
+                this.logger.log("error", `API.execute error when request ${url}. Error: ${error}`);
+                throw error;
+            }
+        }
+
+        if (response) {
+            return response.data
+        }
+
+        throw new Error("API.execute error: Failed to retrieve a valid response");
+    }
+}

package/src/sdk.ts

@@ -0,0 +1,29 @@
+import { CrexApi } from "./requests";
+import { CrexLogger } from "./logger";
+import { ConfigInterface } from "@c-rex/interfaces";
+
+export class CrexSDK {
+    private static instance: CrexSDK;
+    public customerConfig!: ConfigInterface;
+    public logger!: CrexLogger;
+    public api!: CrexApi;
+
+    public constructor(config: ConfigInterface) {
+        if (CrexSDK.instance) {
+            return CrexSDK.instance;
+        }
+
+        this.customerConfig = config;
+        this.logger = new CrexLogger(this.customerConfig);
+        this.api = new CrexApi(this.customerConfig.baseUrl, this.logger);
+
+        CrexSDK.instance = this;
+    }
+
+    public static getInstance(): CrexSDK {
+        if (!CrexSDK.instance) {
+            throw new Error("SDK not initialized");
+        }
+        return CrexSDK.instance;
+    }
+}