dymo-api 1.0.1 → 1.0.3

package/config.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+    lib: {
+        name: "Dymo API",
+        dir: "dymo-api"
+    }
+}

package/index.js

@@ -1,4 +1,4 @@
-import dymoAPI from './lib/dymo-api.js';
+/*import dymoAPI from './lib/dymo-api.js';
 
 // This module is intended to unwrap Dymo API default export as named.
 // Keep top-level export same with static properties.
@@ -10,4 +10,16 @@ const {
 
 export {
     dymoAPI as default
+}*/
+// Importar para ECMAScript Modules
+import pkg from './lib/dymo-api.cjs';
+
+const { Configuration: _Configuration, DymoAPI: _DymoAPI } = pkg;
+
+// Exportar para ECMAScript Modules
+export { _Configuration as Configuration, _DymoAPI as DymoAPI };
+
+// Exportar para CommonJS
+if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
+    module.exports = { Configuration: _Configuration, DymoAPI: _DymoAPI };
 }

package/lib/dymo-api.cjs

@@ -0,0 +1,63 @@
+const axios = require("axios");
+const config = require("../config.cjs");
+const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
+
+/* INTERNALS */
+const privateAPI = require("./private-api.cjs");
+const publicAPI = require("./public-api.cjs");
+
+class Configuration {
+    constructor({ rootApiKey, apiKey } = {}) {
+        // If neither is provided, set them as empty strings.
+        this.rootApiKey = rootApiKey || null;
+        this.apiKey = apiKey || null;
+        this.tokensResponse = null; // Variable to store the response.
+        this.lastFetchTime = null; // Variable to store the time of last request.
+    }
+    async getTokens() {
+        // Checks if the response is available and if 5 minutes have passed since the last request.
+        const currentTime = new Date();
+        if (this.tokensResponse && this.lastFetchTime && currentTime - this.lastFetchTime < 5 * 60 * 1000) {
+            console.log(`[${config.lib.name}] Using cached tokens response.`);
+            return this.tokensResponse;
+        }
+        const tokens = {};
+        if (this.rootApiKey !== null) tokens.root = `Bearer ${this.rootApiKey}`;
+        if (this.apiKey !== null) tokens.api = `Bearer ${this.apiKey}`;
+        try {
+            if (Object.keys(tokens).length < 1) return;
+            const response = await axios.post('https://api.tpeoficial.com/dvr/tokens', { tokens });
+            if (tokens.root && response.data.root === false) throw customError(3000, "Invalid root token.");
+            if (tokens.private && response.data.private === false) throw customError(3000, "Invalid private token.");
+            // Saves the response and the current request time.
+            this.tokensResponse = response.data;
+            this.lastFetchTime = currentTime;
+            console.log(`[${config.lib.name}] Tokens initialized successfully.`);
+            return response.data;
+        } catch (error) {
+            throw customError(5000, error.message);
+        }
+    }
+}
+
+class DymoAPI {
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.initializeTokens(); // Calls the function to obtain tokens when creating the object.
+    }
+    async initializeTokens() {
+        try {
+            await this.configuration.getTokens();
+        } catch (error) {
+            throw customError(5000, `Error initializing tokens: ${error.message}`);
+        }
+    }
+    // FUNCTIONS / Private.
+    async isValidData(data) { return await privateAPI.isValidData(this.configuration.apiKey, data); }
+    // FUNCTIONS / Public.
+    async getPrayerTimes(data) { return await publicAPI.getPrayerTimes(data); }
+    async isValidPwd(data) { return await publicAPI.isValidPwd(data); }
+    async newURLEncrypt(data) { return await publicAPI.newURLEncrypt(data); }
+}
+
+module.exports = { Configuration, DymoAPI };

package/lib/private-api.cjs

@@ -0,0 +1,38 @@
+const axios = require("axios");
+const config = require("../config.cjs");
+const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
+
+exports.isValidData = async (token, data) => {
+    if (token === null) throw customError(3000, "Invalid private token.");
+    let i = false;
+    for (const key in data) {
+        if (data.hasOwnProperty(key) && (key === 'email' || key === 'tel' || key === 'domain' || key === 'creditCard' || key === 'ip')) {
+            i = true;
+            break;
+        }
+    }
+    if (!i) throw customError(1500, "You must provide at least one parameter.");
+    try {
+        const response = await axios.get(`https://api.tpeoficial.com/private/secure/verify`, { params: data, headers: { 'Authorization': token } });
+        const dicc = {
+            "0000": "email",
+            "0001": "tel",
+            "0002": "domain",
+            "0003": "creditCard",
+            "0004": "ip"
+        }
+        const result = {};
+        response.data.forEach(obj => {
+            Object.keys(dicc).forEach(code => {
+                if (obj.hasOwnProperty('code') && obj.code === code) {
+                    const type = dicc[code];
+                    if (!result.hasOwnProperty(type)) result[type] = {};
+                    result[type] = { ...result[type], ...obj };
+                }
+            });
+        });
+        return result;
+    } catch (error) {
+        throw customError(5000, error.message);
+    }
+};

package/lib/public-api.cjs

@@ -0,0 +1,43 @@
+const axios = require("axios");
+const config = require("../config.cjs");
+const customError = (code, message) => Object.assign(new Error(), { code, message: `[${config.lib.name}] ${message}` });
+
+exports.getPrayerTimes = async (data) => {
+    const { lat, lon } = data;
+    if (!lat || !lon) throw customError(1000, "You must provide a latitude and longitude.");
+    try {
+        const response = await axios.get(`https://api.tpeoficial.com/public/islam/prayertimes`, { params: data });
+        return response.data;
+    } catch (error) {
+        throw customError(5000, error.message);
+    }
+};
+
+exports.isValidPwd = async (data) => {
+    const { email, password } = data;
+    if (!password) throw customError(1000, "You must specify at least the password.");
+    const params = {
+        password: encodeURIComponent(password),
+    };
+    if (email) {
+        if (!/^[a-zA-Z0-9._\-+]+@?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/.test(email)) throw customError(1500, "If you provide an email address it must be valid.");
+        params.email = encodeURIComponent(email);
+    }
+    try {
+        const response = await axios.get(`https://api.tpeoficial.com/public/validPwd`, { params });
+        return response.data;
+    } catch (error) {
+        throw customError(5000, error.message);
+    }
+};
+
+exports.newURLEncrypt = async (data) => {
+    const { url } = data;
+    if (!url || (!url.startsWith("https://") && !url.startsWith("http://"))) throw customError(1500, "You must provide a valid url.");
+    try {
+        const response = await axios.get(`https://api.tpeoficial.com/public/url-encrypt`, { params: data });
+        return response.data;
+    } catch (error) {
+        throw customError(5000, error.message);
+    }
+}

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "dymo-api",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Flow system for Dymo API.",
   "main": "index.js",
   "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": [ "Dymo", "Dymo API", "TPEOficial", "Ciphera" ],
+  "keywords": [
+    "Dymo",
+    "Dymo API",
+    "TPEOficial",
+    "Ciphera"
+  ],
   "author": "TPEOficial LLC",
   "license": "MIT",
   "dependencies": {

package/test/preview.js

@@ -1,11 +1,19 @@
 // npm install dymo-api
 // /* 1. */ const { Configuration, DymoAPI } = require("dymo-api");
 // /* 2. */ import { Configuration, DymoAPI } from "dymo-api";
+import { Configuration, DymoAPI } from "../index.js";
 
 const configuration = new Configuration({
-    rootApiKey: "ROOT_TOKEN_HERE",
-    apiKey: "PRIVATE_TOKEN_HERE",
+    /*rootApiKey: "ROOT_TOKEN_HERE",
+    apiKey: "PRIVATE_TOKEN_HERE",*/
 });
 
-// Creating the client for use
-const dymo = new DymoAPI(configuration);
+// Creating the client for use.
+const dymo = new DymoAPI(configuration);
+
+/*
+console.log(await dymo.isValidData({ email: "test@test.com", tel: "+34617509462", domain: "test.com", creditCard: "5110929780543845", ip: "52.94.236.248" })); // Private authorization required.
+console.log(await dymo.newURLEncrypt({ url: "https://www.tpeoficial.com/" })); // No authorization required.
+console.log(await dymo.getPrayerTimes({ lat: "37.3755847689721", lon: "-4.457957889422379" })); // No authorization required.
+console.log(await dymo.isValidPwd({ email: "username@test.com", password: "ThisIsATest" })); // No authorization required.
+*/

package/lib/dymo-api.ts

@@ -1,38 +0,0 @@
-import axios from 'axios';
-
-export interface TokenResponse {
-  accessToken: string;
-  refreshToken: string;
-  private?: boolean; // We define private as an optional property in TokenResponse
-}
-
-export interface ConfigurationOptions {
-  rootApiKey?: string;
-  apiKey?: string;
-}
-
-export class Configuration {
-  private rootApiKey?: string;
-  private apiKey?: string;
-
-  constructor(options: ConfigurationOptions = {}) {
-    this.rootApiKey = options.rootApiKey;
-    this.apiKey = options.apiKey;
-  }
-
-  async getTokens(): Promise<TokenResponse> {
-    const response = await axios.post<TokenResponse>('https://api.tpeoficial.com/dvr/tokens', {
-      tokens: {
-        root: `Bearer ${this.rootApiKey}`,
-        private: `Bearer ${this.apiKey}`
-      }
-    });
-
-    // 
-    if (response.data.private !== undefined && response.data.private === false) {
-      throw new Error('Invalid private token.');
-    }
-
-    return response.data;
-  }
-}