@authenty/authapi-types 1.0.9 → 1.0.11

package/dist/src/index.js

@@ -0,0 +1,425 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthApi = void 0;
+const package_json_1 = __importDefault(require("../package.json"));
+const tools_1 = require("./tools");
+/**
+ * Namespace principal da API de autenticação
+ * Acesso aos tipos: AuthApi.objects.User, AuthApi.responses.auth.login.post, etc.
+ */
+var AuthApi;
+(function (AuthApi) {
+    /**
+     * Objetos de domínio da aplicação
+     */
+    let objects;
+    (function (objects) {
+        let BundleType;
+        (function (BundleType) {
+            BundleType[BundleType["BUNDLE"] = 0] = "BUNDLE";
+            BundleType[BundleType["SYMBOLIC_PRODUCT"] = 1] = "SYMBOLIC_PRODUCT";
+            BundleType[BundleType["SYMBOLIC_COURSE"] = 2] = "SYMBOLIC_COURSE";
+            BundleType[BundleType["SYMBOLIC_CONSULTANCY"] = 3] = "SYMBOLIC_CONSULTANCY";
+        })(BundleType = objects.BundleType || (objects.BundleType = {}));
+        let PaymentSystem;
+        (function (PaymentSystem) {
+            let PG_PurchaseLicenseStatus;
+            (function (PG_PurchaseLicenseStatus) {
+                // Pagamentos ou Assinaturas
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["UNKNOWN"] = 0] = "UNKNOWN";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["OPEN"] = 3] = "OPEN";
+                // Pagamentos
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["EXPIRED"] = 1] = "EXPIRED";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["PAID"] = 5] = "PAID";
+                // Assinaturas
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["ACTIVE"] = 6] = "ACTIVE";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["RECYCLING"] = 4] = "RECYCLING";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["CANCELED"] = 2] = "CANCELED";
+            })(PG_PurchaseLicenseStatus = PaymentSystem.PG_PurchaseLicenseStatus || (PaymentSystem.PG_PurchaseLicenseStatus = {}));
+            PaymentSystem.PG_PurchaseLicenseStatus_GroupActive = [
+                PG_PurchaseLicenseStatus.PAID,
+                PG_PurchaseLicenseStatus.ACTIVE,
+                PG_PurchaseLicenseStatus.RECYCLING,
+            ];
+            let PG_PurchasePaymentStatus;
+            (function (PG_PurchasePaymentStatus) {
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["UNKNOWN"] = 0] = "UNKNOWN";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["ACTIVE"] = 1] = "ACTIVE";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["CANCELED"] = 2] = "CANCELED";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["REFUNDED"] = 3] = "REFUNDED";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["REMOVED"] = 4] = "REMOVED";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["PENDING"] = 5] = "PENDING";
+            })(PG_PurchasePaymentStatus = PaymentSystem.PG_PurchasePaymentStatus || (PaymentSystem.PG_PurchasePaymentStatus = {}));
+            let PG_PurchaseType;
+            (function (PG_PurchaseType) {
+                PG_PurchaseType[PG_PurchaseType["SESSION"] = 0] = "SESSION";
+                PG_PurchaseType[PG_PurchaseType["STANDARD"] = 1] = "STANDARD";
+                PG_PurchaseType[PG_PurchaseType["RECURRENT"] = 2] = "RECURRENT";
+            })(PG_PurchaseType = PaymentSystem.PG_PurchaseType || (PaymentSystem.PG_PurchaseType = {}));
+            let PG_RecurrenceType;
+            (function (PG_RecurrenceType) {
+                PG_RecurrenceType[PG_RecurrenceType["NONE"] = 0] = "NONE";
+                PG_RecurrenceType[PG_RecurrenceType["DAILY"] = 1] = "DAILY";
+                PG_RecurrenceType[PG_RecurrenceType["WEEKLY"] = 2] = "WEEKLY";
+                PG_RecurrenceType[PG_RecurrenceType["MONTHLY"] = 3] = "MONTHLY";
+                PG_RecurrenceType[PG_RecurrenceType["YEARLY"] = 4] = "YEARLY";
+            })(PG_RecurrenceType = PaymentSystem.PG_RecurrenceType || (PaymentSystem.PG_RecurrenceType = {}));
+        })(PaymentSystem = objects.PaymentSystem || (objects.PaymentSystem = {}));
+    })(objects = AuthApi.objects || (AuthApi.objects = {}));
+    let auxiliarTypes;
+    (function (auxiliarTypes) {
+        let Privilege;
+        (function (Privilege) {
+            Privilege[Privilege["NONE"] = 0] = "NONE";
+            Privilege[Privilege["READ"] = 1] = "READ";
+            Privilege[Privilege["WRITE"] = 2] = "WRITE";
+        })(Privilege = auxiliarTypes.Privilege || (auxiliarTypes.Privilege = {}));
+    })(auxiliarTypes = AuthApi.auxiliarTypes || (AuthApi.auxiliarTypes = {}));
+    /**
+     * Client para comunicação com a API de autenticação
+     */
+    class Client {
+        constructor(config) {
+            this.bearer = '';
+            this.pin1 = '';
+            this.retryAttempts = 0;
+            this.retryDelay = 500;
+            this.isHealth = true;
+            // ==================== MÉTODOS DE AUTENTICAÇÃO ====================
+            this.auth = {
+                /**
+                 * Faz login na API
+                 */
+                login: async (email, password) => {
+                    return this.request('POST', 'auth/login', { email, password });
+                },
+                /**
+                 * Faz logout da API
+                 */
+                logout: async () => {
+                    const result = await this.request('GET', 'auth/logout', {});
+                    this.setToken('');
+                    this.setPin1('');
+                    return result;
+                },
+                /**
+                 * Verifica a sessão atual
+                 */
+                checkSession: async () => {
+                    if (!this.bearer) {
+                        return {
+                            conex: true,
+                            reqStat: 401,
+                            success: false,
+                            data: {},
+                            msg: 'Token not found'
+                        };
+                    }
+                    return this.request('GET', 'auth', {}, { retryAttempts: 2, retryDelay: 1000 });
+                }
+            };
+            this.user = {
+                list: async () => {
+                    return await this.request('GET', 'users', {});
+                },
+                get: async (userId, includePurchases = true) => {
+                    return await this.request('GET', `user/${userId}?includePurchases=${includePurchases}`, {});
+                },
+                update: async (userId, userData) => {
+                    return await this.request('PUT', `user/${userId}`, userData);
+                },
+                updateConfig: async (obj) => {
+                    return await this.request('PUT', `user/${obj.id}/config`, obj);
+                },
+                updateAdmin: async (userId, isAdmin) => {
+                    return await this.request('PUT', `user/${userId}/admin`, { isAdmin });
+                },
+                license: async (userId) => {
+                    return await this.request('GET', `user/${userId}/license`, {});
+                }
+            };
+            this.purchase = {
+                new: async (paymentMethodId, userId) => {
+                    return await this.request('POST', `user/${userId}/purchase/new/${paymentMethodId}`, {});
+                },
+                sync: async (purchaseId, userId, async = false) => {
+                    return await this.request('POST', `user/${userId}/purchase/${purchaseId}/sync`, { async });
+                },
+                update: async (userId, purchase) => {
+                    return await this.request('PUT', `user/${userId}/purchase/${purchase.id}`, purchase);
+                },
+                cancel: async (purchaseId, userId) => {
+                    return await this.request('PUT', `user/${userId}/purchase/${purchaseId}/cancel`, {});
+                },
+                delete: async (purchaseId, userId) => {
+                    return await this.request('DELETE', `user/${userId}/purchase/${purchaseId}`, {});
+                },
+                list: async (page = 1, pageSize, userId) => {
+                    return await this.request('POST', `admin/purchases/search`, { page, pageSize, userId });
+                },
+                getFromGateway: async (purchaseId, userId, async = false) => {
+                    return await this.request('GET', `user/${userId}/purchase/${purchaseId}/getFromGateway`, {});
+                },
+            };
+            this.products = {
+                list: async () => {
+                    return await this.request('GET', 'products', {});
+                },
+                get: async (productId) => {
+                    return await this.request('GET', `product/${productId}`, { mode: 'admin' });
+                },
+                update: async (productId, productData) => {
+                    return await this.request('PUT', `product/${productId}`, productData);
+                }
+            };
+            this.paymentMethods = {
+                create: async (id, paymentMethodData) => {
+                    return await this.request('POST', `bundle/${id}/payment-method`, paymentMethodData);
+                },
+                update: async (id, paymentMethodId, paymentMethodData) => {
+                    return await this.request('PUT', `bundle/${id}/payment-method/${paymentMethodId}`, paymentMethodData);
+                },
+                delete: async (id, paymentMethodId) => {
+                    return await this.request('DELETE', `bundle/${id}/payment-method/${paymentMethodId}`, {});
+                }
+            };
+            this.aux = {
+                countries: async () => {
+                    return await this.request('GET', 'aux/countries', {});
+                },
+                states: async (countryId) => {
+                    return await this.request('GET', `aux/country/${countryId}/states`, {});
+                },
+                cities: async (countryId, stateId) => {
+                    return await this.request('GET', `aux/country/${countryId}/state/${stateId}/cities`, {});
+                }
+            };
+            this.admin = {
+                logs: {
+                    /**
+                     * @param filters
+                     * @returns
+                     */
+                    list: async (filters = {}) => {
+                        const defaultFilters = {
+                            page: 1,
+                            itemsPerPage: 50,
+                            search: '',
+                            ...filters
+                        };
+                        return await this.request('POST', 'logs', defaultFilters);
+                    },
+                    status: async () => {
+                        return await this.request('GET', 'logs/status', {});
+                    }
+                },
+                cronJobs: {
+                    status: async () => {
+                        return await this.request('GET', 'admin/cronjobs/status', {});
+                    },
+                    run: async (name) => {
+                        return await this.request('POST', `admin/cronjobs/run/${name}`, {});
+                    }
+                }
+            };
+            this.report = {
+                new: async (id, data) => {
+                    return await this.request('POST', 'report', {
+                        id,
+                        data: (0, tools_1.safeStringify)(data),
+                        appVersion: package_json_1.default.version
+                    });
+                }
+            };
+            this.baseURL = config.baseURL;
+            this.tokenStorage = config.tokenStorage;
+            this.onTokenUpdate = config.onTokenUpdate;
+            this.onPin1Update = config.onPin1Update;
+            this.retryAttempts = config.retryAttempts ?? 0;
+            this.retryDelay = config.retryDelay ?? 500;
+            // Carrega tokens do storage se disponível
+            if (this.tokenStorage) {
+                this.bearer = this.tokenStorage.getToken() ?? '';
+                this.pin1 = this.tokenStorage.getPin1() ?? '';
+            }
+        }
+        /**
+         * Define o token de autenticação
+         */
+        setToken(token) {
+            this.bearer = token;
+            if (this.tokenStorage) {
+                this.tokenStorage.setToken(token);
+            }
+            if (this.onTokenUpdate) {
+                this.onTokenUpdate(token);
+            }
+        }
+        /**
+         * Define o PIN1
+         */
+        setPin1(pin1) {
+            this.pin1 = pin1;
+            if (this.tokenStorage) {
+                this.tokenStorage.setPin1(pin1);
+            }
+            if (this.onPin1Update) {
+                this.onPin1Update(pin1);
+            }
+        }
+        /**
+         * Obtém o token atual
+         */
+        getToken() {
+            return this.bearer;
+        }
+        /**
+         * Obtém o PIN1 atual
+         */
+        getPin1() {
+            return this.pin1;
+        }
+        /**
+         * Verifica se o servidor está saudável
+         */
+        async isHealthy() {
+            if (!this.isHealth) {
+                try {
+                    const r = await this.request('GET', '', {});
+                    if (r.success) {
+                        this.isHealth = true;
+                        return true;
+                    }
+                }
+                catch { }
+                return false;
+            }
+            return true;
+        }
+        /**
+         * Requisição base para a API
+         */
+        async request(method, endpoint, params = {}, options) {
+            const result = {
+                conex: true,
+                reqStat: 0,
+                success: false,
+                data: {},
+                msg: ''
+            };
+            const headers = {};
+            if (this.bearer)
+                headers['authorization'] = `Bearer ${this.bearer}`;
+            if (this.pin1)
+                headers['pin1'] = this.pin1;
+            const maxAttempts = 1 + (options?.retryAttempts ?? this.retryAttempts);
+            const retryDelay = options?.retryDelay ?? this.retryDelay;
+            let attempts = 0;
+            let response = null;
+            while (attempts < maxAttempts) {
+                attempts++;
+                try {
+                    const url = `${this.baseURL}/${endpoint}${method === 'GET' || method === 'DELETE' ? this.buildQueryString(params) : ''}`;
+                    const fetchOptions = {
+                        method,
+                        headers: {
+                            'Content-Type': 'application/json',
+                            ...headers
+                        },
+                        credentials: 'include'
+                    };
+                    if (method === 'POST' || method === 'PUT') {
+                        fetchOptions.body = JSON.stringify(params);
+                    }
+                    response = await fetch(url, fetchOptions);
+                    // Atualiza tokens se presentes nos headers
+                    const newToken = response.headers.get('authorization');
+                    if (newToken) {
+                        this.setToken(newToken.replace('Bearer ', ''));
+                    }
+                    const newPin1 = response.headers.get('pin1');
+                    if (newPin1) {
+                        this.setPin1(newPin1);
+                    }
+                    // Se receber 503, marca como unhealthy e tenta novamente
+                    if (response.status === 503) {
+                        this.isHealth = false;
+                        if (attempts >= maxAttempts)
+                            break;
+                        await new Promise(res => setTimeout(res, retryDelay));
+                        continue;
+                    }
+                    this.isHealth = true;
+                    result.reqStat = response.status;
+                    result.success = response.status >= 200 && response.status < 300;
+                    try {
+                        const jsonData = await response.json();
+                        result.data = jsonData;
+                        result.msg = jsonData.msg ?? '';
+                    }
+                    catch {
+                        result.msg = `stat_${response.status}`;
+                    }
+                    break;
+                }
+                catch (e) {
+                    this.isHealth = false;
+                    if (attempts >= maxAttempts) {
+                        result.conex = false;
+                        result.msg = `connectionError_${e.code ?? 'unknown'}`;
+                    }
+                    else {
+                        await new Promise(res => setTimeout(res, retryDelay));
+                    }
+                }
+            }
+            if (!result.conex) {
+                result.msg = result.msg || 'generic connection error';
+            }
+            return result;
+        }
+        /**
+         * Constrói query string a partir de um objeto
+         */
+        buildQueryString(params) {
+            if (!params || Object.keys(params).length === 0)
+                return '';
+            const queryParams = new URLSearchParams();
+            Object.keys(params).forEach(key => {
+                const value = params[key];
+                if (value !== undefined && value !== null) {
+                    if (Array.isArray(value)) {
+                        queryParams.append(key, JSON.stringify(value));
+                    }
+                    else if (typeof value === 'object') {
+                        queryParams.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        queryParams.append(key, String(value));
+                    }
+                }
+            });
+            return `?${queryParams.toString()}`;
+        }
+        async checkHealth() {
+            if (!this.isHealth) {
+                try {
+                    const r = await this.request('GET', '', {});
+                    if (r.success) {
+                        this.isHealth = true;
+                        return true;
+                    }
+                }
+                catch { }
+                return false;
+            }
+            return true;
+        }
+    }
+    AuthApi.Client = Client;
+})(AuthApi || (exports.AuthApi = AuthApi = {}));
+// Exporta o namespace como default também
+exports.default = AuthApi;

package/dist/src/tools.d.ts

@@ -0,0 +1 @@
+export declare function safeStringify(obj: any): string;

package/dist/src/tools.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeStringify = safeStringify;
+function safeStringify(obj) {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (key, val) => {
+        if (val != null && typeof val === "object") {
+            if (seen.has(val)) {
+                return '[Circular]';
+            }
+            seen.add(val);
+        }
+        return val;
+    });
+}
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@authenty/authapi-types",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Shared types for Authenty API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",