mp-front-cli 0.0.1

package/README.md

@@ -0,0 +1 @@
+# front-utils

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA"}

package/dist/core/index.js

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/core/rxSubjects/RxSubjectManager.d.ts

@@ -0,0 +1,10 @@
+import { Subject } from "rxjs";
+declare class RxSubjectManager<T> {
+    private subject$;
+    getSubject(): import("rxjs").Observable<T>;
+    setSubject(data: T): void;
+    completeSubject(): void;
+    unsubscribeSubject(): Subject<T>;
+}
+export default RxSubjectManager;
+//# sourceMappingURL=RxSubjectManager.d.ts.map

package/dist/core/rxSubjects/RxSubjectManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RxSubjectManager.d.ts","sourceRoot":"","sources":["../../../src/core/rxSubjects/RxSubjectManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,cAAM,gBAAgB,CAAC,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAoB;IAEpC,UAAU;IAGV,UAAU,CAAC,IAAI,EAAE,CAAC;IAGlB,eAAe;IAGf,kBAAkB;CAKnB;AAED,eAAe,gBAAgB,CAAC"}

package/dist/core/rxSubjects/RxSubjectManager.js

@@ -0,0 +1,19 @@
+import { Subject } from "rxjs";
+class RxSubjectManager {
+    subject$ = new Subject();
+    getSubject() {
+        return this.subject$.asObservable();
+    }
+    setSubject(data) {
+        this.subject$.next(data);
+    }
+    completeSubject() {
+        this.subject$.complete();
+    }
+    unsubscribeSubject() {
+        this.subject$.unsubscribe();
+        this.subject$ = new Subject();
+        return this.subject$;
+    }
+}
+export default RxSubjectManager;

package/dist/core/rxSubjects/subjectsManager.d.ts

@@ -0,0 +1,4 @@
+import { IMessageErrorBFF } from "../utils/interfaces/notifications";
+import RxSubjectManager from "./RxSubjectManager";
+export declare const ErrorHandler: RxSubjectManager<IMessageErrorBFF>;
+//# sourceMappingURL=subjectsManager.d.ts.map

package/dist/core/rxSubjects/subjectsManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subjectsManager.d.ts","sourceRoot":"","sources":["../../../src/core/rxSubjects/subjectsManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,gBAAgB,MAAM,oBAAoB,CAAC;AAElD,eAAO,MAAM,YAAY,oCAA2C,CAAC"}

package/dist/core/rxSubjects/subjectsManager.js

@@ -0,0 +1,2 @@
+import RxSubjectManager from "./RxSubjectManager";
+export const ErrorHandler = new RxSubjectManager();

package/dist/core/services/ServiceToken.d.ts

@@ -0,0 +1,13 @@
+import { CustomLogger } from "../utils/CustomLogger";
+export declare class ServiceToken extends CustomLogger {
+    private API_AUTH_BACK_URL;
+    private API_AUTH_BACK_USERNAME_AUTH;
+    private API_AUTH_BACK_PASSWORD_AUTH;
+    private API_AUTH_BACK_USER;
+    private API_AUTH_BACK_SCOPE;
+    private API_AUTH_BACK_PASSWORD;
+    private headers;
+    constructor();
+    get(): import("rxjs").Observable<any>;
+}
+//# sourceMappingURL=ServiceToken.d.ts.map

package/dist/core/services/ServiceToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceToken.d.ts","sourceRoot":"","sources":["../../../src/core/services/ServiceToken.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,iBAAiB,CAAQ;IACjC,OAAO,CAAC,2BAA2B,CAAQ;IAC3C,OAAO,CAAC,2BAA2B,CAAQ;IAC3C,OAAO,CAAC,kBAAkB,CAAQ;IAClC,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,sBAAsB,CAAQ;IACtC,OAAO,CAAC,OAAO,CAAa;;IAqB5B,GAAG;CAsBJ"}

package/dist/core/services/ServiceToken.js

@@ -0,0 +1,46 @@
+import { catchError, of, switchMap } from "rxjs";
+import { fromFetch } from "rxjs/fetch";
+import { CustomLogger } from "../utils/CustomLogger";
+export class ServiceToken extends CustomLogger {
+    API_AUTH_BACK_URL;
+    API_AUTH_BACK_USERNAME_AUTH;
+    API_AUTH_BACK_PASSWORD_AUTH;
+    API_AUTH_BACK_USER;
+    API_AUTH_BACK_SCOPE;
+    API_AUTH_BACK_PASSWORD;
+    headers;
+    constructor() {
+        super();
+        this.API_AUTH_BACK_URL = process.env.API_AUTH_BACK_URL;
+        this.API_AUTH_BACK_USERNAME_AUTH = process.env.API_AUTH_BACK_USERNAME_AUTH;
+        this.API_AUTH_BACK_PASSWORD_AUTH = process.env.API_AUTH_BACK_PASSWORD_AUTH;
+        this.API_AUTH_BACK_USER = process.env.API_AUTH_BACK_USER;
+        this.API_AUTH_BACK_SCOPE = process.env.API_AUTH_BACK_SCOPE;
+        this.API_AUTH_BACK_PASSWORD = process.env.API_AUTH_BACK_PASSWORD;
+        const authString = `${this.API_AUTH_BACK_USERNAME_AUTH}:${this.API_AUTH_BACK_PASSWORD_AUTH}`;
+        const encodedAuthString = Buffer.from(authString).toString("base64");
+        this.headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json;charset=UTF-8",
+            Authorization: `Basic ${encodedAuthString}`,
+        };
+    }
+    get() {
+        this.logDebug("get ServiceToken");
+        return fromFetch(this.API_AUTH_BACK_URL, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify({
+                user: this.API_AUTH_BACK_USER,
+                scope: this.API_AUTH_BACK_SCOPE,
+                password: this.API_AUTH_BACK_PASSWORD,
+            }),
+        }).pipe(switchMap((response) => response.json()), switchMap((data) => {
+            this.logDebug(`ServiceToken <URL>: \x1b[33m ${this.API_AUTH_BACK_URL} \x1b[37m <HEADERS>: \x1b[33m ${JSON.stringify(this.headers)} \x1b[37m <BODY>: \x1b[33m ${JSON.stringify(data)} \x1b[37m`);
+            return of(data?.data?.Token || "");
+        }), catchError((error) => {
+            this.logError(`ServiceToken ${error}`);
+            return of("");
+        }));
+    }
+}

package/dist/core/utils/ApiMiddleware/index.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import type { NextApiRequest, NextApiResponse } from "next";
+import { ApiResponse } from "../interfaces/ApiResponse";
+import { CustomValidator } from "../CustomValidator";
+export declare class ApiMiddleware<TRes, TData> extends CustomValidator {
+    get(handle: (params: TData) => Observable<ApiResponse<TRes>>): (req: NextApiRequest, res: NextApiResponse) => void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/core/utils/ApiMiddleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/ApiMiddleware/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA6B,MAAM,MAAM,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,qBAAa,aAAa,CAAC,IAAI,EAAE,KAAK,CAAE,SAAQ,eAAe;IAE7D,GAAG,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,KAAK,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,SAI7C,cAAc,OAAO,eAAe;CA6BpD"}

package/dist/core/utils/ApiMiddleware/index.js

@@ -0,0 +1,27 @@
+import { catchError, of, switchMap } from "rxjs";
+import { ErrorHandler } from "@/core/rxSubjects/subjectsManager";
+import { CustomValidator } from "../CustomValidator";
+export class ApiMiddleware extends CustomValidator {
+    get(handle) {
+        this.logDebug("get ApiMiddleware");
+        return (req, res) => {
+            this.logDebug("return ApiMiddleware");
+            ErrorHandler.getSubject().subscribe({
+                next: (response) => {
+                    this.logError(`ApiMiddleware ErrorHandler ${JSON.stringify(response)}`);
+                    ErrorHandler.unsubscribeSubject();
+                    return res.status(response.code ?? 520).json(response);
+                }
+            });
+            of(req).pipe(switchMap((req) => this.validateTokenFront(req)), switchMap((req) => of(this.decode(req.body))), switchMap((params) => handle(params)), catchError((error) => {
+                ErrorHandler.setSubject(error);
+                return of({});
+            })).subscribe({
+                next: (Resp) => {
+                    ErrorHandler.unsubscribeSubject();
+                    res.status(200).json(Resp);
+                },
+            });
+        };
+    }
+}

package/dist/core/utils/CustomEncoder/index.d.ts

@@ -0,0 +1,8 @@
+import { CustomLogger } from "../CustomLogger";
+export declare class CustomEncoder extends CustomLogger {
+    encode<T>(data: T): string;
+    decode<T>(data: {
+        base64: string | T | Record<string, unknown>;
+    }): T;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/core/utils/CustomEncoder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/CustomEncoder/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,qBAAa,aAAc,SAAQ,YAAY;IAE7C,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IAajB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;CAiBjE"}

package/dist/core/utils/CustomEncoder/index.js

@@ -0,0 +1,32 @@
+import { isString } from "lodash";
+import { CustomLogger } from "../CustomLogger";
+export class CustomEncoder extends CustomLogger {
+    encode(data) {
+        try {
+            this.logDebug("encode CustomEncoder", JSON.stringify(data));
+            const json = JSON.stringify(data);
+            const base64 = Buffer.from(json).toString("base64");
+            return JSON.stringify({ base64 });
+        }
+        catch (error) {
+            this.logError("error convert to base64");
+        }
+        return JSON.stringify(data);
+    }
+    decode(data) {
+        const { base64 } = data;
+        try {
+            this.logDebug("decode CustomEncoder", JSON.stringify(base64));
+            const regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+            if (isString(base64) && regex.test(base64)) {
+                const json = Buffer.from(base64, "base64").toString();
+                const data = JSON.parse(json);
+                return data;
+            }
+        }
+        catch (error) {
+            this.logError("error convert to base64");
+        }
+        return base64;
+    }
+}

package/dist/core/utils/CustomHeader/index.d.ts

@@ -0,0 +1,232 @@
+import { CustomValidator } from "../CustomValidator";
+export declare class CustomHeader extends CustomValidator {
+    private headers;
+    constructor();
+    addTokenBackend(headers: HeadersInit): import("rxjs").Observable<{
+        Authorization: string;
+        length: number;
+        toString(): string;
+        toLocaleString(): string;
+        pop(): [string, string] | undefined;
+        push(...items: [string, string][]): number;
+        concat(...items: ConcatArray<[string, string]>[]): [string, string][];
+        concat(...items: ([string, string] | ConcatArray<[string, string]>)[]): [string, string][];
+        join(separator?: string | undefined): string;
+        reverse(): [string, string][];
+        shift(): [string, string] | undefined;
+        slice(start?: number | undefined, end?: number | undefined): [string, string][];
+        sort(compareFn?: ((a: [string, string], b: [string, string]) => number) | undefined): [string, string][];
+        splice(start: number, deleteCount?: number | undefined): [string, string][];
+        splice(start: number, deleteCount: number, ...items: [string, string][]): [string, string][];
+        unshift(...items: [string, string][]): number;
+        indexOf(searchElement: [string, string], fromIndex?: number | undefined): number;
+        lastIndexOf(searchElement: [string, string], fromIndex?: number | undefined): number;
+        every<S extends [string, string]>(predicate: (value: [string, string], index: number, array: [string, string][]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: [string, string], index: number, array: [string, string][]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: [string, string], index: number, array: [string, string][]) => U, thisArg?: any): U[];
+        filter<S_1 extends [string, string]>(predicate: (value: [string, string], index: number, array: [string, string][]) => value is S_1, thisArg?: any): S_1[];
+        filter(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): [string, string][];
+        reduce(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string]): [string, string];
+        reduce(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string], initialValue: [string, string]): [string, string];
+        reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: [string, string], currentIndex: number, array: [string, string][]) => U_1, initialValue: U_1): U_1;
+        reduceRight(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string]): [string, string];
+        reduceRight(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string], initialValue: [string, string]): [string, string];
+        reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: [string, string], currentIndex: number, array: [string, string][]) => U_2, initialValue: U_2): U_2;
+        find<S_2 extends [string, string]>(predicate: (value: [string, string], index: number, obj: [string, string][]) => value is S_2, thisArg?: any): S_2 | undefined;
+        find(predicate: (value: [string, string], index: number, obj: [string, string][]) => unknown, thisArg?: any): [string, string] | undefined;
+        findIndex(predicate: (value: [string, string], index: number, obj: [string, string][]) => unknown, thisArg?: any): number;
+        fill(value: [string, string], start?: number | undefined, end?: number | undefined): [string, string][];
+        copyWithin(target: number, start: number, end?: number | undefined): [string, string][];
+        entries(): IterableIterator<[number, [string, string]]>;
+        keys(): IterableIterator<number>;
+        values(): IterableIterator<[string, string]>;
+        includes(searchElement: [string, string], fromIndex?: number | undefined): boolean;
+        flatMap<U_3, This = undefined>(callback: (this: This, value: [string, string], index: number, array: [string, string][]) => U_3 | readonly U_3[], thisArg?: This | undefined): U_3[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        at(index: number): [string, string] | undefined;
+        findLast<S_3 extends [string, string]>(predicate: (value: [string, string], index: number, array: [string, string][]) => value is S_3, thisArg?: any): S_3 | undefined;
+        findLast(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): [string, string] | undefined;
+        findLastIndex(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): number;
+        toReversed(): [string, string][];
+        toSorted(compareFn?: ((a: [string, string], b: [string, string]) => number) | undefined): [string, string][];
+        toSpliced(start: number, deleteCount: number, ...items: [string, string][]): [string, string][];
+        toSpliced(start: number, deleteCount?: number | undefined): [string, string][];
+        with(index: number, value: [string, string]): [string, string][];
+        [Symbol.iterator](): IterableIterator<[string, string]>;
+        [Symbol.unscopables]: {
+            [x: number]: boolean | undefined;
+            length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            pop?: boolean | undefined;
+            push?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            reverse?: boolean | undefined;
+            shift?: boolean | undefined;
+            slice?: boolean | undefined;
+            sort?: boolean | undefined;
+            splice?: boolean | undefined;
+            unshift?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            fill?: boolean | undefined;
+            copyWithin?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            at?: boolean | undefined;
+            findLast?: boolean | undefined;
+            findLastIndex?: boolean | undefined;
+            toReversed?: boolean | undefined;
+            toSorted?: boolean | undefined;
+            toSpliced?: boolean | undefined;
+            with?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
+    } | {
+        Authorization: string;
+    } | {
+        Authorization: string;
+        append(name: string, value: string): void;
+        delete(name: string): void;
+        get(name: string): string | null;
+        getSetCookie(): string[];
+        has(name: string): boolean;
+        set(name: string, value: string): void;
+        forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+        entries(): IterableIterator<[string, string]>;
+        keys(): IterableIterator<string>;
+        values(): IterableIterator<string>;
+        [Symbol.iterator](): IterableIterator<[string, string]>;
+    }>;
+    getHeaders(): import("rxjs").Observable<{
+        Authorization: string;
+        length: number;
+        toString(): string;
+        toLocaleString(): string;
+        pop(): [string, string] | undefined;
+        push(...items: [string, string][]): number;
+        concat(...items: ConcatArray<[string, string]>[]): [string, string][];
+        concat(...items: ([string, string] | ConcatArray<[string, string]>)[]): [string, string][];
+        join(separator?: string | undefined): string;
+        reverse(): [string, string][];
+        shift(): [string, string] | undefined;
+        slice(start?: number | undefined, end?: number | undefined): [string, string][];
+        sort(compareFn?: ((a: [string, string], b: [string, string]) => number) | undefined): [string, string][];
+        splice(start: number, deleteCount?: number | undefined): [string, string][];
+        splice(start: number, deleteCount: number, ...items: [string, string][]): [string, string][];
+        unshift(...items: [string, string][]): number;
+        indexOf(searchElement: [string, string], fromIndex?: number | undefined): number;
+        lastIndexOf(searchElement: [string, string], fromIndex?: number | undefined): number;
+        every<S extends [string, string]>(predicate: (value: [string, string], index: number, array: [string, string][]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: [string, string], index: number, array: [string, string][]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: [string, string], index: number, array: [string, string][]) => U, thisArg?: any): U[];
+        filter<S_1 extends [string, string]>(predicate: (value: [string, string], index: number, array: [string, string][]) => value is S_1, thisArg?: any): S_1[];
+        filter(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): [string, string][];
+        reduce(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string]): [string, string];
+        reduce(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string], initialValue: [string, string]): [string, string];
+        reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: [string, string], currentIndex: number, array: [string, string][]) => U_1, initialValue: U_1): U_1;
+        reduceRight(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string]): [string, string];
+        reduceRight(callbackfn: (previousValue: [string, string], currentValue: [string, string], currentIndex: number, array: [string, string][]) => [string, string], initialValue: [string, string]): [string, string];
+        reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: [string, string], currentIndex: number, array: [string, string][]) => U_2, initialValue: U_2): U_2;
+        find<S_2 extends [string, string]>(predicate: (value: [string, string], index: number, obj: [string, string][]) => value is S_2, thisArg?: any): S_2 | undefined;
+        find(predicate: (value: [string, string], index: number, obj: [string, string][]) => unknown, thisArg?: any): [string, string] | undefined;
+        findIndex(predicate: (value: [string, string], index: number, obj: [string, string][]) => unknown, thisArg?: any): number;
+        fill(value: [string, string], start?: number | undefined, end?: number | undefined): [string, string][];
+        copyWithin(target: number, start: number, end?: number | undefined): [string, string][];
+        entries(): IterableIterator<[number, [string, string]]>;
+        keys(): IterableIterator<number>;
+        values(): IterableIterator<[string, string]>;
+        includes(searchElement: [string, string], fromIndex?: number | undefined): boolean;
+        flatMap<U_3, This = undefined>(callback: (this: This, value: [string, string], index: number, array: [string, string][]) => U_3 | readonly U_3[], thisArg?: This | undefined): U_3[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        at(index: number): [string, string] | undefined;
+        findLast<S_3 extends [string, string]>(predicate: (value: [string, string], index: number, array: [string, string][]) => value is S_3, thisArg?: any): S_3 | undefined;
+        findLast(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): [string, string] | undefined;
+        findLastIndex(predicate: (value: [string, string], index: number, array: [string, string][]) => unknown, thisArg?: any): number;
+        toReversed(): [string, string][];
+        toSorted(compareFn?: ((a: [string, string], b: [string, string]) => number) | undefined): [string, string][];
+        toSpliced(start: number, deleteCount: number, ...items: [string, string][]): [string, string][];
+        toSpliced(start: number, deleteCount?: number | undefined): [string, string][];
+        with(index: number, value: [string, string]): [string, string][];
+        [Symbol.iterator](): IterableIterator<[string, string]>;
+        [Symbol.unscopables]: {
+            [x: number]: boolean | undefined;
+            length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            pop?: boolean | undefined;
+            push?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            reverse?: boolean | undefined;
+            shift?: boolean | undefined;
+            slice?: boolean | undefined;
+            sort?: boolean | undefined;
+            splice?: boolean | undefined;
+            unshift?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            fill?: boolean | undefined;
+            copyWithin?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            at?: boolean | undefined;
+            findLast?: boolean | undefined;
+            findLastIndex?: boolean | undefined;
+            toReversed?: boolean | undefined;
+            toSorted?: boolean | undefined;
+            toSpliced?: boolean | undefined;
+            with?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
+    } | {
+        Authorization: string;
+    } | {
+        Authorization: string;
+        append(name: string, value: string): void;
+        delete(name: string): void;
+        get(name: string): string | null;
+        getSetCookie(): string[];
+        has(name: string): boolean;
+        set(name: string, value: string): void;
+        forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+        entries(): IterableIterator<[string, string]>;
+        keys(): IterableIterator<string>;
+        values(): IterableIterator<string>;
+        [Symbol.iterator](): IterableIterator<[string, string]>;
+    }>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/core/utils/CustomHeader/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/CustomHeader/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD,qBAAa,YAAa,SAAQ,eAAe;IAC/C,OAAO,CAAC,OAAO,CAAa;;IAU5B,eAAe,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOpC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQX"}

package/dist/core/utils/CustomHeader/index.js

@@ -0,0 +1,23 @@
+import { of, switchMap } from "rxjs";
+import { ServiceToken } from "@/core/services/ServiceToken";
+import { CustomValidator } from "../CustomValidator";
+export class CustomHeader extends CustomValidator {
+    headers;
+    constructor() {
+        super();
+        this.headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+    }
+    addTokenBackend(headers) {
+        this.logDebug("addTokenBackend CustomHeader", JSON.stringify(headers));
+        return new ServiceToken().get().pipe(switchMap((token) => of({ ...headers, Authorization: `Bearer ${token}` })));
+    }
+    getHeaders() {
+        this.logDebug("getHeaders CustomHeader");
+        return of({
+            ...this.headers
+        }).pipe(switchMap((headers) => this.addTokenBackend(headers)));
+    }
+}

package/dist/core/utils/CustomLogger/index.d.ts

@@ -0,0 +1,16 @@
+export declare class CustomLogger {
+    private appName;
+    private logsLevel;
+    private silentLogs;
+    constructor();
+    private consoleFormat;
+    private log;
+    logError(...message: string[]): void;
+    logWarn(...message: string[]): void;
+    logInfo(...message: string[]): void;
+    logHttp(...message: string[]): void;
+    logVerbose(...message: string[]): void;
+    logDebug(...message: string[]): void;
+    logSilly(...message: string[]): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/core/utils/CustomLogger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/CustomLogger/index.ts"],"names":[],"mappings":"AAoBA,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,UAAU,CAAS;;IAQ3B,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,GAAG;IAMX,QAAQ,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAIpC,OAAO,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAInC,OAAO,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAInC,OAAO,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAInC,UAAU,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAItC,QAAQ,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAIpC,QAAQ,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;CAGrC"}

package/dist/core/utils/CustomLogger/index.js

@@ -0,0 +1,63 @@
+var Level;
+(function (Level) {
+    Level[Level["error"] = 0] = "error";
+    Level[Level["warn"] = 1] = "warn";
+    Level[Level["info"] = 2] = "info";
+    Level[Level["http"] = 3] = "http";
+    Level[Level["verbose"] = 4] = "verbose";
+    Level[Level["debug"] = 5] = "debug";
+    Level[Level["silly"] = 6] = "silly";
+})(Level || (Level = {}));
+const colors = {
+    error: "\x1b[31m",
+    warn: "\x1b[33m",
+    info: "\x1b[34m",
+    http: "\x1b[35m",
+    verbose: "\x1b[32m",
+    debug: "\x1b[37m",
+    silly: "\x1b[37m",
+};
+export class CustomLogger {
+    appName;
+    logsLevel;
+    silentLogs;
+    constructor() {
+        this.appName = process.env.APP_LOGS_NAME;
+        this.logsLevel = process.env.LOGS_LEVEL;
+        this.silentLogs = process.env.SILENT_LOGS === "true";
+    }
+    consoleFormat(level, message) {
+        try {
+            return `${colors[level]} ${this.appName} [${new Date().toISOString()}] [${level.toUpperCase()}]: ${message.toString()} \x1b[37m`;
+        }
+        catch (error) {
+            return message;
+        }
+    }
+    log(level, message) {
+        if (level <= Level[this.logsLevel] && !this.silentLogs) {
+            console.log(this.consoleFormat(Level[level], message));
+        }
+    }
+    logError(...message) {
+        this.log(Level.error, message);
+    }
+    logWarn(...message) {
+        this.log(Level.warn, message);
+    }
+    logInfo(...message) {
+        this.log(Level.info, message);
+    }
+    logHttp(...message) {
+        this.log(Level.http, message);
+    }
+    logVerbose(...message) {
+        this.log(Level.verbose, message);
+    }
+    logDebug(...message) {
+        this.log(Level.debug, message);
+    }
+    logSilly(...message) {
+        this.log(Level.silly, message);
+    }
+}

package/dist/core/utils/CustomValidator/index.d.ts

@@ -0,0 +1,7 @@
+import type { NextApiRequest } from "next";
+import type { NextRequest } from "next/server";
+import { CustomEncoder } from "../CustomEncoder";
+export declare class CustomValidator extends CustomEncoder {
+    validateTokenFront(req: NextApiRequest | NextRequest): Promise<NextApiRequest | NextRequest>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/core/utils/CustomValidator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/CustomValidator/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAA;AAE1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEhD,qBAAa,eAAgB,SAAQ,aAAa;IAE1C,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,WAAW;CAU3D"}

package/dist/core/utils/CustomValidator/index.js

@@ -0,0 +1,14 @@
+import { getToken } from "next-auth/jwt";
+import MessageErrorBFF from "../MessageErrorBFF";
+import { CustomEncoder } from "../CustomEncoder";
+export class CustomValidator extends CustomEncoder {
+    async validateTokenFront(req) {
+        this.logDebug("entra validate Token Front");
+        const token = await getToken({ req: req });
+        this.logDebug("Token Front", JSON.stringify(token));
+        if (!token) {
+            throw new MessageErrorBFF("UNAUTHORIZED").get();
+        }
+        return req;
+    }
+}

package/dist/core/utils/ErrorCatalog/index.d.ts

@@ -0,0 +1,14 @@
+import { ApiError } from "../interfaces/ApiResponse";
+import { CustomLogger } from "../CustomLogger";
+export declare class ErrorCatalog extends CustomLogger {
+    get(error?: string | Error | ApiError): {
+        title: string;
+        message: string;
+        code?: number | undefined;
+        type: "modal" | "message";
+        level: "error" | "success" | "warning" | "info" | "confirm";
+        payload?: {} | undefined;
+        clearCookieSession?: boolean | undefined;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/core/utils/ErrorCatalog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/ErrorCatalog/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AA0G9C,qBAAa,YAAa,SAAQ,YAAY;IAC5C,GAAG,CAAC,KAAK,GAAE,MAAM,GAAG,KAAK,GAAG,QAAoB;;;;;;;;;CAqBjD"}