Updates

package-shared/functions/api/users/api-create-user.js

@@ -0,0 +1,117 @@
+// @ts-check
+
+const addUsersTableToDb = require("../../backend/addUsersTableToDb");
+const addDbEntry = require("../../backend/db/addDbEntry");
+const varDatabaseDbHandler = require("../../backend/varDatabaseDbHandler");
+const hashPassword = require("../../dsql/hashPassword");
+
+/** @type {import("../../../types").APICreateUserFunction} */
+module.exports = async function apiCreateUser({
+    encryptionKey,
+    payload,
+    database,
+    userId,
+}) {
+    const dbFullName = database;
+
+    const hashedPassword = hashPassword({
+        encryptionKey: encryptionKey,
+        password: String(payload.password),
+    });
+
+    payload.password = hashedPassword;
+
+    let fields = await varDatabaseDbHandler({
+        queryString: `SHOW COLUMNS FROM users`,
+        database: dbFullName,
+    });
+
+    if (!fields) {
+        const newTable = await addUsersTableToDb({
+            userId: Number(userId),
+            database: database,
+        });
+
+        fields = await varDatabaseDbHandler({
+            queryString: `SHOW COLUMNS FROM users`,
+            database: dbFullName,
+        });
+    }
+
+    if (!fields) {
+        return {
+            success: false,
+            msg: "Could not create users table",
+        };
+    }
+
+    const fieldsTitles = fields.map(
+        (/** @type {any} */ fieldObject) => fieldObject.Field
+    );
+
+    let invalidField = null;
+
+    for (let i = 0; i < Object.keys(payload).length; i++) {
+        const key = Object.keys(payload)[i];
+        if (!fieldsTitles.includes(key)) {
+            invalidField = key;
+            break;
+        }
+    }
+
+    if (invalidField) {
+        return {
+            success: false,
+            msg: `${invalidField} is not a valid field!`,
+        };
+    }
+
+    const existingUser = await varDatabaseDbHandler({
+        queryString: `SELECT * FROM users WHERE email = ?${
+            payload.username ? " OR username = ?" : ""
+        }`,
+        queryValuesArray: payload.username
+            ? [payload.email, payload.username]
+            : [payload.email],
+        database: dbFullName,
+    });
+
+    if (existingUser?.[0]) {
+        return {
+            success: false,
+            msg: "User Already Exists",
+            payload: null,
+        };
+    }
+
+    const addUser = await addDbEntry({
+        dbContext: "Dsql User",
+        paradigm: "Full Access",
+        dbFullName: dbFullName,
+        tableName: "users",
+        data: {
+            ...payload,
+            image: "/images/user-preset.png",
+            image_thumbnail: "/images/user-preset-thumbnail.png",
+        },
+    });
+
+    if (addUser?.insertId) {
+        const newlyAddedUser = await varDatabaseDbHandler({
+            queryString: `SELECT id,first_name,last_name,email,username,phone,image,image_thumbnail,city,state,country,zip_code,address,verification_status,more_user_data FROM users WHERE id='${addUser.insertId}'`,
+            database: dbFullName,
+        });
+
+        return {
+            success: true,
+            payload: newlyAddedUser[0],
+        };
+    } else {
+        return {
+            success: false,
+            msg: "Could not create user",
+            sqlResult: addUser,
+            payload: null,
+        };
+    }
+};

package-shared/functions/api/users/api-get-user.js

@@ -0,0 +1,26 @@
+// @ts-check
+
+const varDatabaseDbHandler = require("../../backend/varDatabaseDbHandler");
+
+/** @type {import("../../../types").APIGetUserFunction} */
+module.exports = async function apiGetUser({ fields, dbFullName, userId }) {
+    const query = `SELECT ${fields.join(",")} FROM users WHERE id=?`;
+
+    let foundUser = await varDatabaseDbHandler({
+        queryString: query,
+        queryValuesArray: [userId],
+        database: dbFullName.replace(/[^a-z0-9_]/g, ""),
+    });
+
+    if (!foundUser || !foundUser[0]) {
+        return {
+            success: false,
+            payload: null,
+        };
+    }
+
+    return {
+        success: true,
+        payload: foundUser[0],
+    };
+};

package-shared/functions/api/users/api-login.js

@@ -0,0 +1,159 @@
+// @ts-check
+
+const varDatabaseDbHandler = require("../../backend/varDatabaseDbHandler");
+const hashPassword = require("../../dsql/hashPassword");
+
+/** @type {import("../../../types").APILoginFunction} */
+module.exports = async function apiLoginUser({
+    encryptionKey,
+    email,
+    username,
+    password,
+    database,
+    additionalFields,
+    email_login,
+    email_login_code,
+    email_login_field,
+    token,
+    skipPassword,
+    social,
+}) {
+    const dbFullName = database;
+
+    /**
+     * Check input validity
+     *
+     * @description Check input validity
+     */
+    if (
+        email?.match(/ /) ||
+        (username && username?.match(/ /)) ||
+        (password && password?.match(/ /))
+    ) {
+        return {
+            success: false,
+            msg: "Invalid Email/Password format",
+        };
+    }
+
+    /**
+     * Password hash
+     *
+     * @description Password hash
+     */
+    let hashedPassword = password
+        ? hashPassword({
+              encryptionKey: encryptionKey,
+              password: password,
+          })
+        : null;
+
+    let isSocialValidated = false;
+    let loginFailureReason = null;
+
+    let foundUser = await varDatabaseDbHandler({
+        queryString: `SELECT * FROM users WHERE email = ? OR username = ?`,
+        queryValuesArray: [email, username],
+        database: dbFullName.replace(/[^a-z0-9_]/g, ""),
+    });
+
+    if ((!foundUser || !foundUser[0]) && !social)
+        return {
+            success: false,
+            payload: null,
+            msg: "No user found",
+        };
+
+    let isPasswordCorrect = false;
+
+    if (foundUser?.[0] && !email_login && skipPassword) {
+        isPasswordCorrect = true;
+    } else if (foundUser?.[0] && !email_login) {
+        isPasswordCorrect = hashedPassword === foundUser[0].password;
+    } else if (
+        foundUser &&
+        foundUser[0] &&
+        email_login &&
+        email_login_code &&
+        email_login_field
+    ) {
+        /** @type {string} */
+        const tempCode = foundUser[0][email_login_field];
+
+        if (!tempCode) throw new Error("No code Found!");
+
+        const tempCodeArray = tempCode.split("-");
+        const [code, codeDate] = tempCodeArray;
+        const millisecond15mins = 1000 * 60 * 15;
+
+        if (Date.now() - Number(codeDate) > millisecond15mins) {
+            throw new Error("Code Expired");
+        }
+        isPasswordCorrect = code === email_login_code;
+    }
+
+    let socialUserValid = false;
+
+    if (!isPasswordCorrect && !socialUserValid) {
+        return {
+            success: false,
+            msg: "Wrong password, no social login validity",
+            payload: null,
+        };
+    }
+
+    if (isPasswordCorrect && email_login) {
+        const resetTempCode = await varDatabaseDbHandler({
+            queryString: `UPDATE users SET ${email_login_field} = ? WHERE email = ? OR username = ?`,
+            queryValuesArray: ["", email, username],
+            database: dbFullName.replace(/[^a-z0-9_]/g, ""),
+        });
+    }
+
+    let csrfKey =
+        Math.random().toString(36).substring(2) +
+        "-" +
+        Math.random().toString(36).substring(2);
+
+    /** @type {import("../../../types").DATASQUIREL_LoggedInUser} */
+    let userPayload = {
+        id: foundUser[0].id,
+        first_name: foundUser[0].first_name,
+        last_name: foundUser[0].last_name,
+        username: foundUser[0].username,
+        email: foundUser[0].email,
+        phone: foundUser[0].phone,
+        social_id: foundUser[0].social_id,
+        image: foundUser[0].image,
+        image_thumbnail: foundUser[0].image_thumbnail,
+        verification_status: foundUser[0].verification_status,
+        social_login: foundUser[0].social_login,
+        social_platform: foundUser[0].social_platform,
+        csrf_k: csrfKey,
+        more_data: foundUser[0].more_user_data,
+        logged_in_status: true,
+        date: Date.now(),
+    };
+
+    const resposeObject = {
+        success: true,
+        msg: "Login Successful",
+        payload:
+            /** @type {import("../../../types").DATASQUIREL_LoggedInUser} */ (
+                userPayload
+            ),
+        userId: foundUser[0].id,
+    };
+
+    if (
+        additionalFields &&
+        Array.isArray(additionalFields) &&
+        additionalFields.length > 0
+    ) {
+        additionalFields.forEach((key) => {
+            userPayload[key] = foundUser[0][key];
+        });
+    }
+
+    return resposeObject;
+};

package-shared/functions/api/users/api-reauth-user.js

@@ -0,0 +1,92 @@
+// @ts-check
+
+const varDatabaseDbHandler = require("../../backend/varDatabaseDbHandler");
+const nodemailer = require("nodemailer");
+
+/**
+ * # Re-authenticate API user
+ * @param {object} param
+ * @param {Object<string, any>} param.existingUser
+ * @param {string} param.database
+ * @param {string | number} [param.userId]
+ * @param {string[]} [param.additionalFields]
+ *
+ * @returns {Promise<import("../../../types").ApiReauthUserReturn>}
+ */
+module.exports = async function apiReauthUser({
+    existingUser,
+    database,
+    userId,
+    additionalFields,
+}) {
+    let foundUser =
+        existingUser?.id && existingUser.id.toString().match(/./)
+            ? await varDatabaseDbHandler({
+                  queryString: `SELECT * FROM users WHERE id=?`,
+                  queryValuesArray: [existingUser.id.toString()],
+                  database,
+              })
+            : null;
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    if (!foundUser || !foundUser[0])
+        return {
+            success: false,
+            payload: null,
+            msg: "No user found",
+        };
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    let csrfKey =
+        Math.random().toString(36).substring(2) +
+        "-" +
+        Math.random().toString(36).substring(2);
+
+    /** @type {Object<string, string | number | boolean>} */
+    let userPayload = {
+        id: foundUser[0].id,
+        first_name: foundUser[0].first_name,
+        last_name: foundUser[0].last_name,
+        username: foundUser[0].username,
+        email: foundUser[0].email,
+        phone: foundUser[0].phone,
+        social_id: foundUser[0].social_id,
+        image: foundUser[0].image,
+        image_thumbnail: foundUser[0].image_thumbnail,
+        verification_status: foundUser[0].verification_status,
+        social_login: foundUser[0].social_login,
+        social_platform: foundUser[0].social_platform,
+        csrf_k: csrfKey,
+        more_data: foundUser[0].more_user_data,
+        logged_in_status: true,
+        date: Date.now(),
+    };
+
+    if (
+        additionalFields &&
+        Array.isArray(additionalFields) &&
+        additionalFields.length > 0
+    ) {
+        additionalFields.forEach((key) => {
+            userPayload[key] = foundUser[0][key];
+        });
+    }
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    /** ********************* Send Response */
+    return {
+        success: true,
+        msg: "Login Successful",
+        payload: userPayload,
+        userId,
+    };
+};

package-shared/functions/api/users/api-send-email-code.js

@@ -0,0 +1,116 @@
+// @ts-check
+
+const varDatabaseDbHandler = require("../../backend/varDatabaseDbHandler");
+const nodemailer = require("nodemailer");
+
+/**
+ * # Send Email Login Code
+ *
+ * @param {object} param
+ * @param {string} param.email
+ * @param {string} param.database
+ * @param {string} [param.email_login_field]
+ * @param {string} [param.mail_domain]
+ * @param {number} [param.mail_port]
+ * @param {string} [param.sender]
+ * @param {string} [param.mail_username]
+ * @param {string} [param.mail_password]
+ * @param {string} param.html
+ *
+ * @returns {Promise<{success: boolean, msg?: string}>}
+ */
+module.exports = async function apiSendEmailCode({
+    email,
+    database,
+    email_login_field,
+    mail_domain,
+    mail_port,
+    sender,
+    mail_username,
+    mail_password,
+    html,
+}) {
+    if (email?.match(/ /)) {
+        return {
+            success: false,
+            msg: "Invalid Email/Password format",
+        };
+    }
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    let foundUser = await varDatabaseDbHandler({
+        queryString: `SELECT * FROM users WHERE email = ?`,
+        queryValuesArray: [email],
+        database,
+    });
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    if (!foundUser || !foundUser[0]) {
+        return {
+            success: false,
+            msg: "No user found",
+        };
+    }
+
+    function generateCode() {
+        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        let code = "";
+        for (let i = 0; i < 8; i++) {
+            code += chars[Math.floor(Math.random() * chars.length)];
+        }
+        return code;
+    }
+
+    if (foundUser && foundUser[0] && email_login_field) {
+        const tempCode = generateCode();
+
+        let transporter = nodemailer.createTransport({
+            host: mail_domain || process.env.DSQL_MAIL_HOST,
+            port: mail_port || 465,
+            secure: true,
+            auth: {
+                user: mail_username || process.env.DSQL_MAIL_EMAIL,
+                pass: mail_password || process.env.DSQL_MAIL_PASSWORD,
+            },
+        });
+
+        let mailObject = {};
+
+        mailObject["from"] = `"Datasquirel SSO" <${
+            sender || "support@datasquirel.com"
+        }>`;
+        mailObject["sender"] = sender || "support@datasquirel.com";
+        mailObject["to"] = email;
+        mailObject["subject"] = "One Time Login Code";
+        mailObject["html"] = html.replace(/{{code}}/, tempCode);
+
+        const info = await transporter.sendMail(mailObject);
+
+        if (!info?.accepted) throw new Error("Mail not Sent!");
+
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+
+        let setTempCode = await varDatabaseDbHandler({
+            queryString: `UPDATE users SET ${email_login_field} = ? WHERE email = ?`,
+            queryValuesArray: [tempCode + `-${Date.now()}`, email],
+            database: database,
+        });
+    }
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    return {
+        success: true,
+        msg: "Success",
+    };
+};

package-shared/functions/api/users/api-update-user.js

@@ -0,0 +1,43 @@
+// @ts-check
+
+const updateDbEntry = require("../../backend/db/updateDbEntry");
+
+/**
+ * # Update API User Function
+ *
+ * @param {object} params
+ * @param {{ id: string | number } & Object<string, (string | number | null | undefined)>} params.payload
+ * @param {string} params.dbFullName
+ *
+ * @returns {Promise<{ success: boolean, payload: any }>}
+ */
+module.exports = async function apiUpdateUser({ payload, dbFullName }) {
+    const data = (() => {
+        const reqBodyKeys = Object.keys(payload);
+
+        /** @type {any} */
+        const finalData = {};
+
+        reqBodyKeys.forEach((key) => {
+            if (key?.match(/^date_|^id$/)) return;
+            finalData[key] = payload[key];
+        });
+
+        return finalData;
+    })();
+
+    const updateUser = await updateDbEntry({
+        dbContext: "Dsql User",
+        paradigm: "Full Access",
+        dbFullName,
+        tableName: "users",
+        identifierColumnName: "id",
+        identifierValue: payload.id,
+        data: data,
+    });
+
+    return {
+        success: true,
+        payload: updateUser,
+    };
+};

package-shared/functions/api/users/social/api-github-login.js

@@ -0,0 +1,110 @@
+// @ts-check
+
+const handleSocialDb = require("../../social-login/handleSocialDb");
+const githubLogin = require("../../social-login/githubLogin");
+const camelJoinedtoCamelSpace = require("../../../../utils/camelJoinedtoCamelSpace");
+
+/**
+ * # Login with Github
+ * @param {object} param
+ * @param {string} [param.code]
+ * @param {string} [param.clientId]
+ * @param {string} [param.clientSecret]
+ * @param {string} [param.database]
+ * @param {Object<string, any>} [param.additionalFields]
+ * @param {any} [param.res]
+ * @param {string} [param.email]
+ * @param {string | number} [param.userId]
+ *
+ * @returns {Promise<import("../../../../types").APIGoogleLoginFunctionReturn>}
+ */
+module.exports = async function apiGithubLogin({
+    code,
+    clientId,
+    clientSecret,
+    database,
+    additionalFields,
+    res,
+    email,
+    userId,
+}) {
+    if (!code || !clientId || !clientSecret || !database) {
+        return {
+            success: false,
+            msg: "Missing query params",
+        };
+    }
+
+    if (
+        typeof code !== "string" ||
+        typeof clientId !== "string" ||
+        typeof clientSecret !== "string" ||
+        typeof database !== "string"
+    ) {
+        return {
+            success: false,
+            msg: "Wrong Parameters",
+        };
+    }
+
+    /**
+     * Create new user folder and file
+     *
+     * @description Create new user folder and file
+     */
+    const gitHubUser = await githubLogin({
+        code: code,
+        clientId: clientId,
+        clientSecret: clientSecret,
+    });
+
+    if (!gitHubUser) {
+        return {
+            success: false,
+            msg: "No github user returned",
+        };
+    }
+
+    const socialId = gitHubUser.name || gitHubUser.id || gitHubUser.login;
+    const targetName = gitHubUser.name || gitHubUser.login;
+    const nameArray = targetName?.match(/ /)
+        ? targetName?.split(" ")
+        : targetName?.match(/\-/)
+        ? targetName?.split("-")
+        : [targetName];
+
+    const payload = {
+        email: gitHubUser.email,
+        first_name: camelJoinedtoCamelSpace(nameArray[0]),
+        last_name: camelJoinedtoCamelSpace(nameArray[1]),
+        social_id: socialId,
+        social_platform: "github",
+        image: gitHubUser.avatar_url,
+        image_thumbnail: gitHubUser.avatar_url,
+        username: "github-user-" + socialId,
+    };
+
+    if (additionalFields && Object.keys(additionalFields).length > 0) {
+        Object.keys(additionalFields).forEach((key) => {
+            // @ts-ignore
+            payload[key] = additionalFields[key];
+        });
+    }
+
+    const loggedInGithubUser = await handleSocialDb({
+        database,
+        email: gitHubUser.email,
+        payload: payload,
+        social_platform: "github",
+        res: res,
+        social_id: socialId,
+        supEmail: email,
+        additionalFields,
+    });
+
+    ////////////////////////////////////////////////
+    ////////////////////////////////////////////////
+    ////////////////////////////////////////////////
+
+    return { success: true, ...loggedInGithubUser, dsqlUserId: userId };
+};

package-shared/functions/api/users/social/api-google-login.js

@@ -0,0 +1,88 @@
+// @ts-check
+
+const { OAuth2Client } = require("google-auth-library");
+const handleSocialDb = require("../../social-login/handleSocialDb");
+
+/** @type {import("../../../../types").APIGoogleLoginFunction} */
+module.exports = async function apiGoogleLogin({
+    clientId,
+    token,
+    database,
+    userId,
+    additionalFields,
+    res,
+}) {
+    const client = new OAuth2Client(clientId);
+
+    const ticket = await client.verifyIdToken({
+        idToken: token,
+        audience: clientId,
+    });
+
+    if (!ticket?.getPayload()?.email_verified) {
+        return {
+            success: false,
+            user: null,
+        };
+    }
+
+    const payload = ticket.getPayload();
+
+    if (!payload) throw new Error("No Payload");
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    if (!database || typeof database != "string" || database?.match(/ /)) {
+        return {
+            success: false,
+            user: undefined,
+            msg: "Please provide a database slug(database name in lowercase with no spaces)",
+        };
+    }
+
+    /**
+     * Create new user folder and file
+     *
+     * @description Create new user folder and file
+     */
+    const targetDbName = `datasquirel_user_${userId}_${database}`;
+
+    const { given_name, family_name, email, sub, picture, email_verified } =
+        payload;
+
+    /** @type {Object<string, any>} */
+    const payloadObject = {
+        email: email,
+        first_name: given_name,
+        last_name: family_name,
+        social_id: sub,
+        social_platform: "google",
+        image: picture,
+        image_thumbnail: picture,
+        username: `google-user-${sub}`,
+    };
+
+    if (additionalFields && Object.keys(additionalFields).length > 0) {
+        Object.keys(additionalFields).forEach((key) => {
+            payloadObject[key] = additionalFields[key];
+        });
+    }
+
+    const loggedInGoogleUser = await handleSocialDb({
+        res,
+        database: targetDbName,
+        email: email || "",
+        payload: payloadObject,
+        social_platform: "google",
+        social_id: sub,
+        additionalFields,
+    });
+
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+    ////////////////////////////////////////
+
+    return { success: true, ...loggedInGoogleUser, dsqlUserId: userId };
+};