@nka212bg/backend-utils 0.1.0

package/socket.js

@@ -0,0 +1,157 @@
+const WebSocket = require("ws");
+let http = null;
+let https = null;
+let socketsCount = 0;
+
+exports.socket = ({ httpServer, httpsServer }) => {
+    if (httpServer) {
+        http = new WebSocket.Server({ server: httpServer });
+        http.on("connection", (ws, req) => {
+            ws.params = JSON.parse(`{"${decodeURI(req.url.replace(/\/\?/g, "")).replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g, '":"')}"}`);
+        });
+    } else if (httpsServer) {
+        https = new WebSocket.Server({ server: httpsServer });
+        https.on("connection", (ws, req) => {
+            ws.params = JSON.parse(`{"${decodeURI(req.url.replace(/\/\?/g, "")).replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g, '":"')}"}`);
+        });
+    }
+};
+
+exports.getUsersStatuses = (users) => {
+    if (typeof users == "string") users = users.split(/[, ]/g);
+    if (!Array.isArray(users)) return {};
+
+    const usersObj = {};
+    users.forEach((u) => {
+        usersObj[u] = { online: false };
+        for (const c of https.clients) {
+            if (c.params.userId == u) {
+                usersObj[u] = { online: true };
+                return;
+            }
+        }
+
+        for (const c of http.clients) {
+            if (c.params.userId == u) {
+                usersObj[u] = { online: true };
+                return;
+            }
+        }
+    });
+
+    return usersObj;
+};
+
+// exports.getUsersStatuses = (users = []) => {
+//     users = users.map((u) => {
+//         u = { id: u, online: false };
+//         for (const c of https.clients) {
+//             if (c.params.userId == u.id) {
+//                 u.online = true;
+//                 return u;
+//             }
+//         }
+
+//         for (const c of http.clients) {
+//             if (c.params.userId == u.id) {
+//                 u.online = true;
+//                 return u;
+//             }
+//         }
+
+//         return u;
+//     });
+
+//     return users;
+// };
+
+exports.sendSocketMessage = ({ userId, skipId, skipToken, data, broadcast } = {}) => {
+    let sentCount = 0;
+    let tempCount = 0;
+
+    if (!userId) return;
+    userId = !Array.isArray(userId) ? [String(userId)] : userId.map((e) => String(e));
+
+    if (skipId) skipId = !Array.isArray(skipId) ? [String(skipId)] : skipId.map((e) => String(e));
+    if (skipToken && !Array.isArray(skipToken)) skipToken = [String(skipToken)];
+
+    try {
+        if (typeof data != "string") data = JSON.stringify(data);
+    } catch {}
+
+    (https.clients || []).forEach(manageClient);
+    (http.clients || []).forEach(manageClient);
+
+    socketsCount = tempCount;
+    return sentCount;
+
+    function manageClient(client) {
+        tempCount += 1;
+
+        if (broadcast || userId.includes(client.params.userId)) {
+            if (skipId && skipId.includes(client.params.userId)) return;
+            if (skipToken && skipToken.includes(client.params.token)) return;
+
+            client.send(data);
+            sentCount += 1;
+        }
+    }
+};
+
+exports.socketStat = () => {
+    return {
+        socketsCount,
+    };
+};
+
+// "web-push": "^3.2.2", // package.json
+// const webPush = require("web-push");
+// const VAPID_KEYS = webPush.generateVAPIDKeys();
+
+// webPush.setVapidDetails(process.env.VAPID_ORIGIN, process.env.VAPID_PUBLIC_KEY, process.env.VAPID_PRIVATE_KEY);
+
+// module.exports = (app) => {
+//     app.get("vapidPublicKey", function (req, res) {
+//         res.send(process.env.VAPID_PUBLIC_KEY);
+//     });
+
+//     app.post("register", function (req, res) {
+//         // A real world application would store the subscription info.
+//         res.sendStatus(201);
+//     });
+
+//     app.post("sendNotification", function (req, res) {
+//         const subscription = req.body.subscription;
+//         const payload = req.body.payload;
+//         const options = {
+//             TTL: req.body.ttl,
+//         };
+
+//         setTimeout(function () {
+//             webPush
+//                 .sendNotification(subscription, payload, options)
+//                 .then(function () {
+//                     res.sendStatus(201);
+//                 })
+//                 .catch(function (error) {
+//                     console.log(error);
+//                     res.sendStatus(500);
+//                 });
+//         }, req.body.delay * 1000);
+
+//         fetch("./sendNotification", {
+//             method: "post",
+//             headers: {
+//                 "Content-type": "application/json",
+//             },
+//             body: JSON.stringify({
+//                 subscription: subscription,
+//                 payload: payload,
+//                 delay: delay,
+//                 ttl: ttl,
+//             }),
+//         });
+//     });
+
+//     return app;
+// };

package/stripe.js

@@ -0,0 +1,98 @@
+const stripe = require("stripe")(process.env.STRIPE_SECRET_KEY, {
+    appInfo: {
+        name: "buukmarks.com",
+        version: "1.0.0",
+    },
+});
+
+exports.balance = async () => {
+    return await stripe.balance.retrieve();
+};
+
+exports.createCustomer = async ({ name, email, source, metadata }) => {
+    try {
+        const data = await stripe.customers.create({ name, email, source, metadata });
+        return { data };
+    } catch (error) {
+        return { error };
+    }
+};
+
+exports.updateCustomer = async ({ stripe_id, source, metadata }) => {
+    try {
+        const data = await stripe.customers.update(stripe_id, { source, metadata });
+        return { data };
+    } catch (error) {
+        return { error };
+    }
+};
+
+exports.getCustomerSubscription = async (stripe_id) => {
+    try {
+        const customer = await stripe.customers.retrieve(stripe_id);
+        const paymentMethod = await stripe.customers.retrievePaymentMethod(customer.id, customer.default_source);
+
+        return { data: { customer, paymentMethod } };
+    } catch (error) {
+        return { error };
+    }
+};
+
+exports.getPayments = async (user_id) => {
+    if (!user_id) return { error: "missing_required" };
+
+    try {
+        let { data = [], ...rest } = await stripe.charges.search({ query: `metadata["user_id"]:"${user_id}"` });
+
+        data = data.map((e) => {
+            return {
+                id: e.id,
+                amount: e.amount / 100,
+                currency: e.currency,
+                paid_on: e.created,
+                description: e.description,
+                paid_until: e.metadata.paid_until,
+                card: {
+                    brand: e.source.brand.toLowerCase(),
+                    last4: e.source.last4,
+                    country: e.source.country,
+                },
+                receipt_url: e.receipt_url,
+                status: e.status,
+                // raw: e,
+            };
+        });
+
+        return { data, rest };
+    } catch (error) {
+        return { error };
+    }
+};
+
+exports.chargeCustomer = async ({ stripe_id, description, amount, currency, metadata }) => {
+    amount = Number(amount);
+    if (!amount) return { error: "no_amount" };
+
+    try {
+        const data = await stripe.charges.create({
+            customer: stripe_id,
+            description: description || "OceanDIV undescribed payment from chat app.",
+            currency: currency || "usd",
+            amount,
+            metadata,
+        });
+
+        return { data };
+    } catch (error) {
+        return { error };
+    }
+};
+
+exports.unsubscribeStripe = async (stripe_id) => {
+    try {
+        const data = await stripe.customers.del(stripe_id);
+        return { data };
+    } catch (error) {
+        return { error };
+    }
+};

package/systemLog.js

@@ -0,0 +1,72 @@
+const { existsSync, writeFile, readFileSync, readdirSync, mkdirSync } = require("fs");
+const { sep } = require("path");
+
+const logDir = `${__basedir}/logs`;
+!existsSync(logDir) && mkdirSync(logDir, { recursive: true });
+
+const docStartTemplate = {
+    serverCounters: { ENOENT: {} },
+    //
+};
+
+const fileName = `${logDir}/activeLog.json`;
+let ACTIVE_LOG = existsSync(fileName) ? JSON.parse(readFileSync(fileName, "utf8") || JSON.stringify(docStartTemplate)) : docStartTemplate;
+
+exports.writeLog = () => {
+    const stringifiedLog = JSON.stringify(ACTIVE_LOG);
+    if (stringifiedLog.length < 300000) {
+        writeFile(fileName, stringifiedLog, (error) => error && console.error(error));
+        return;
+    }
+
+    writeFile(`${logDir}/${Date.now()}.json`, stringifiedLog, (error) => error && console.error(error));
+    ACTIVE_LOG = { serverCounters: ACTIVE_LOG.serverCounters };
+};
+
+setInterval(this.writeLog, 1000 * 60);
+
+exports.getLog = (fileName) => {
+    let active;
+
+    if (!fileName || fileName == "activeLog.json") {
+        active = ACTIVE_LOG;
+    } else {
+        const file = `${logDir}/${fileName}`;
+        active = existsSync(file) ? JSON.parse(readFileSync(file, "utf8") || JSON.stringify(docStartTemplate)) : docStartTemplate;
+    }
+
+    return {
+        active,
+        available: readdirSync(logDir),
+    };
+};
+
+exports.setLogMsg = ({ from = "misc", arguments } = {}) => {
+    arguments = argumentsSanitize(arguments);
+
+    const matchMsg = arguments.match(/(enoent).*(users|challenges)/gi)?.[0];
+    if (matchMsg) {
+        ACTIVE_LOG.serverCounters.ENOENT[matchMsg] ? (ACTIVE_LOG.serverCounters.ENOENT[matchMsg] += 1) : (ACTIVE_LOG.serverCounters.ENOENT[matchMsg] = 1);
+        return;
+    }
+
+    from = from.split(sep).slice(-2).join(".");
+    if (!ACTIVE_LOG[from]) ACTIVE_LOG[from] = [];
+
+    ACTIVE_LOG[from].unshift({
+        msg: arguments,
+        date: Date.now(),
+        userIp: __userIp,
+    });
+
+    if (arguments.includes("forceWrite")) {
+    }
+};
+
+/* -------------------- helpers -------------------- */
+function argumentsSanitize(args) {
+    if (!args) return [];
+    if (typeof args == "object") return JSON.stringify(Object.values(args));
+
+    return [String(args)];
+}