@nka212bg/backend-utils 0.1.21 → 0.1.23

package/misc.js

@@ -113,31 +113,22 @@ exports.handlebars = ({ template, ...params } = {}) => {
     return template;
 };
 
-exports.shortCount = (value, type) => {
+exports.shortCount = (value, bites) => {
     value = Number(value);
-    if (isNaN(value)) return value;
+    if (!value) return "";
 
     let units = {
-        trillion: "T",
-        billion: "B",
-        million: "M",
-        thousand: "K",
+        trillion: bites ? "tb" : "T",
+        billion: bites ? "gb" : "B",
+        million: bites ? "mb" : "M",
+        thousand: bites ? "kb" : "K",
     };
 
-    if (type == "disk") {
-        units = {
-            trillion: " tb",
-            billion: " gb",
-            million: " mb",
-            thousand: " kb",
-        };
-    }
-
-    if (value > 1000000000000) return (value / 1000000000000).toFixed(1) + units.trillion;
-    if (value > 1000000000) return (value / 1000000000).toFixed(1) + units.billion;
-    if (value > 1000000) return (value / 1000000).toFixed(1) + units.million;
-    if (value > 1000) return (value / 1000).toFixed(1) + units.thousand;
-    return value + (type == "disk" ? " bites" : "");
+    if (value >= 1000000000000) return (value / 1000000000000).toFixed(1) + units.trillion;
+    if (value >= 1000000000) return (value / 1000000000).toFixed(1) + units.billion;
+    if (value >= 1000000) return (value / 1000000).toFixed(1) + units.million;
+    if (value >= 1000) return (value / 1000).toFixed(1) + units.thousand;
+    return value + (bites ? "bit" : "");
 };
 
 exports.saveFile = (file, destinationPath, callback) => {
@@ -385,26 +376,37 @@ exports.crypto = ({ salt, embedSalt } = {}) => {
     }
 };
 
-exports.secToTime = (seconds) => {
-    if (!(seconds = parseInt(seconds))) return;
-
-    const years = seconds / 60 / 60 / 24 / 30.5 / 12;
-    const months = seconds / 60 / 60 / 24 / 30.5;
-    const days = seconds / 60 / 60 / 24;
-    const hours = seconds / 60 / 60;
-    const minutes = seconds / 60;
-    seconds = parseInt(seconds % 60);
-
-    if (years >= 1) return parseInt(years) + "y " + parseInt(months % 12) + "m " + parseInt(days % 30.5) + "d";
-    if (months >= 1) return parseInt(months) + "m " + parseInt(days % 30.5) + "d " + parseInt(hours % 24) + "h";
-    if (days >= 1) return parseInt(days) + "d " + parseInt(hours % 24) + "h";
-    if (hours >= 1) return parseInt(hours) + "h " + doMinutes(minutes) + "min";
-    return parseInt(minutes) + "min " + (seconds < 10 ? "0" + seconds : seconds) + "s";
-
-    function doMinutes(minutes) {
-        minutes = parseInt(minutes % 60);
-        return minutes < 10 ? "0" + minutes : minutes;
-    }
+exports.secToTime = (sec) => {
+    sec = parseInt(sec);
+    if (!sec) return;
+
+    const SEC_IN_MIN = 60;
+    const SEC_IN_HOUR = 3600;
+    const SEC_IN_DAY = 86400;
+    const SEC_IN_MONTH = SEC_IN_DAY * 30.5;
+    const SEC_IN_YEAR = SEC_IN_MONTH * 12;
+
+    const years = Math.floor(sec / SEC_IN_YEAR);
+    sec %= SEC_IN_YEAR;
+
+    const months = Math.floor(sec / SEC_IN_MONTH);
+    sec %= SEC_IN_MONTH;
+
+    const days = Math.floor(sec / SEC_IN_DAY);
+    sec %= SEC_IN_DAY;
+
+    const hours = Math.floor(sec / SEC_IN_HOUR);
+    sec %= SEC_IN_HOUR;
+
+    const minutes = Math.floor(sec / SEC_IN_MIN);
+    const seconds = sec % SEC_IN_MIN;
+
+    if (years > 0) return `${years}y ${months}m ${days}d`;
+    if (months > 0) return `${months}m ${days}d ${hours}h`;
+    if (days > 0) return `${days}d ${hours}h`;
+    if (hours > 0) return `${hours}h ${String(minutes).padStart(2, "0")}min`;
+
+    return `${minutes}min ${String(seconds).padStart(2, "0")}s`;
 };
 
 exports.urlMetadata = async ({ url }) => {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@nka212bg/backend-utils",
     "author": "nka212bg",
-    "version": "0.1.21",
+    "version": "0.1.23",
     "main": "index.js",
     "dependencies": {
         "@maxmind/geoip2-node": "^5.0.0",

package/stripe.js

@@ -1,98 +1,97 @@
-const stripe = require("stripe")(process.env.STRIPE_SECRET_KEY, {
-    appInfo: {
-        name: "buukmarks.com",
-        version: "1.0.0",
-    },
-});
+const Stripe = require("stripe");
 
-exports.balance = async () => {
-    return await stripe.balance.retrieve();
-};
+module.exports = (key, appInfo) => {
+    const stripe = Stripe(key, { appInfo });
 
-exports.createCustomer = async ({ name, email, source, metadata }) => {
-    try {
-        const data = await stripe.customers.create({ name, email, source, metadata });
-        return { data };
-    } catch (error) {
-        return { error };
-    }
-};
+    return {
+        async balance() {
+            return await stripe.balance.retrieve();
+        },
 
-exports.updateCustomer = async ({ stripe_id, source, metadata }) => {
-    try {
-        const data = await stripe.customers.update(stripe_id, { source, metadata });
-        return { data };
-    } catch (error) {
-        return { error };
-    }
-};
+        async createCustomer({ name, email, source, metadata }) {
+            try {
+                const data = await stripe.customers.create({ name, email, 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);
+        async updateCustomer({ stripe_id, source, metadata }) {
+            try {
+                const data = await stripe.customers.update(stripe_id, { source, metadata });
+                return { data };
+            } catch (error) {
+                return { error };
+            }
+        },
 
-        return { data: { customer, paymentMethod } };
-    } catch (error) {
-        return { error };
-    }
-};
+        async getCustomerSubscription(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" };
+        async getPayments(user_id) {
+            if (!user_id) return { error: "missing_required" };
 
-    try {
-        let { data = [], ...rest } = await stripe.charges.search({ query: `metadata["user_id"]:"${user_id}"` });
+            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,
-            };
-        });
+                data = data.map((e) => ({
+                    id: e.id,
+                    amount: e.amount,
+                    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,
+                }));
 
-        return { data, rest };
-    } catch (error) {
-        return { error };
-    }
-};
+                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" };
+        async chargeCustomer({ 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,
-        });
+            try {
+                const data = await stripe.charges.create({
+                    customer: stripe_id,
+                    description: description || "misc payment",
+                    currency: currency || "usd",
+                    amount,
+                    metadata,
+                });
 
-        return { data };
-    } catch (error) {
-        return { error };
-    }
-};
+                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 };
-    }
+        async unsubscribeStripe(stripe_id) {
+            try {
+                const data = await stripe.customers.del(stripe_id);
+                return { data };
+            } catch (error) {
+                return { error };
+            }
+        },
+    };
 };