Updates

dist/package-shared/functions/api/users/api-create-user.d.ts

@@ -0,0 +1,25 @@
+import { APICreateUserFunctionParams } from "../../../types";
+/**
+ * # API Create User
+ */
+export default function apiCreateUser({ encryptionKey, payload, database, userId, useLocal, }: APICreateUserFunctionParams): Promise<{
+    success: boolean;
+    msg: string;
+    payload: null;
+    sqlResult?: undefined;
+} | {
+    success: boolean;
+    msg: string;
+    payload?: undefined;
+    sqlResult?: undefined;
+} | {
+    success: boolean;
+    payload: any;
+    msg?: undefined;
+    sqlResult?: undefined;
+} | {
+    success: boolean;
+    msg: string;
+    sqlResult: any;
+    payload: null;
+}>;

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

@@ -0,0 +1,142 @@
+"use strict";
+// @ts-check
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiCreateUser;
+const addUsersTableToDb_1 = __importDefault(require("../../backend/addUsersTableToDb"));
+const addDbEntry_1 = __importDefault(require("../../backend/db/addDbEntry"));
+const updateUsersTableSchema_1 = __importDefault(require("../../backend/updateUsersTableSchema"));
+const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
+/**
+ * # API Create User
+ */
+function apiCreateUser(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ encryptionKey, payload, database, userId, useLocal, }) {
+        const dbFullName = database;
+        const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
+        const finalEncryptionKey = encryptionKey || process.env.DSQL_ENCRYPTION_PASSWORD;
+        if (!finalEncryptionKey) {
+            return {
+                success: false,
+                msg: "No encryption key provided",
+                payload: null,
+            };
+        }
+        if (!(finalEncryptionKey === null || finalEncryptionKey === void 0 ? void 0 : finalEncryptionKey.match(/.{8,}/))) {
+            return {
+                success: false,
+                msg: "Encryption key must be at least 8 characters long",
+                payload: null,
+            };
+        }
+        const hashedPassword = (0, hashPassword_1.default)({
+            encryptionKey: finalEncryptionKey,
+            password: String(payload.password),
+        });
+        payload.password = hashedPassword;
+        const fieldsQuery = `SHOW COLUMNS FROM users`;
+        let fields = yield (0, varDatabaseDbHandler_1.default)({
+            queryString: fieldsQuery,
+            database: dbFullName,
+            useLocal,
+        });
+        if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
+            const newTable = yield (0, addUsersTableToDb_1.default)({
+                userId: Number(API_USER_ID),
+                database: dbFullName,
+                useLocal,
+                payload: payload,
+            });
+            fields = yield (0, varDatabaseDbHandler_1.default)({
+                queryString: fieldsQuery,
+                database: dbFullName,
+                useLocal,
+            });
+        }
+        if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
+            return {
+                success: false,
+                msg: "Could not create users table",
+            };
+        }
+        const fieldsTitles = fields.map((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)) {
+                yield (0, updateUsersTableSchema_1.default)({
+                    userId: Number(API_USER_ID),
+                    database: dbFullName,
+                    newPayload: {
+                        [key]: payload[key],
+                    },
+                });
+            }
+        }
+        if (invalidField) {
+            return {
+                success: false,
+                msg: `${invalidField} is not a valid field!`,
+            };
+        }
+        const existingUserQuery = `SELECT * FROM users WHERE email = ?${payload.username ? " OR username = ?" : ""}`;
+        const existingUserValues = payload.username
+            ? [payload.email, payload.username]
+            : [payload.email];
+        const existingUser = yield (0, varDatabaseDbHandler_1.default)({
+            queryString: existingUserQuery,
+            queryValuesArray: existingUserValues,
+            database: dbFullName,
+            useLocal,
+        });
+        if (existingUser === null || existingUser === void 0 ? void 0 : existingUser[0]) {
+            return {
+                success: false,
+                msg: "User Already Exists",
+                payload: null,
+            };
+        }
+        const addUser = yield (0, addDbEntry_1.default)({
+            dbContext: "Dsql User",
+            paradigm: "Full Access",
+            dbFullName: dbFullName,
+            tableName: "users",
+            data: Object.assign(Object.assign({}, payload), { image: process.env.DSQL_DEFAULT_USER_IMAGE ||
+                    "/images/user-preset.png", image_thumbnail: process.env.DSQL_DEFAULT_USER_IMAGE ||
+                    "/images/user-preset-thumbnail.png" }),
+            useLocal,
+        });
+        if (addUser === null || addUser === void 0 ? void 0 : addUser.insertId) {
+            const newlyAddedUserQuery = `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}'`;
+            const newlyAddedUser = yield (0, varDatabaseDbHandler_1.default)({
+                queryString: newlyAddedUserQuery,
+                database: dbFullName,
+                useLocal,
+            });
+            return {
+                success: true,
+                payload: newlyAddedUser[0],
+            };
+        }
+        else {
+            return {
+                success: false,
+                msg: "Could not create user",
+                sqlResult: addUser,
+                payload: null,
+            };
+        }
+    });
+}

dist/package-shared/functions/api/users/api-delete-user.d.ts

@@ -0,0 +1,15 @@
+type Param = {
+    dbFullName: string;
+    deletedUserId: string | number;
+    useLocal?: boolean;
+};
+type Return = {
+    success: boolean;
+    result?: any;
+    msg?: string;
+};
+/**
+ * # Update API User Function
+ */
+export default function apiDeleteUser({ dbFullName, deletedUserId, useLocal, }: Param): Promise<Return>;
+export {};

dist/package-shared/functions/api/users/api-delete-user.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiDeleteUser;
+const deleteDbEntry_1 = __importDefault(require("../../backend/db/deleteDbEntry"));
+const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+/**
+ * # Update API User Function
+ */
+function apiDeleteUser(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ dbFullName, deletedUserId, useLocal, }) {
+        const existingUserQuery = `SELECT * FROM users WHERE id = ?`;
+        const existingUserValues = [deletedUserId];
+        const existingUser = yield (0, varDatabaseDbHandler_1.default)({
+            queryString: existingUserQuery,
+            queryValuesArray: existingUserValues,
+            database: dbFullName,
+            useLocal,
+        });
+        if (!(existingUser === null || existingUser === void 0 ? void 0 : existingUser[0])) {
+            return {
+                success: false,
+                msg: "User not found",
+            };
+        }
+        const deleteUser = yield (0, deleteDbEntry_1.default)({
+            dbContext: "Dsql User",
+            paradigm: "Full Access",
+            dbFullName,
+            tableName: "users",
+            identifierColumnName: "id",
+            identifierValue: deletedUserId,
+            useLocal,
+        });
+        return {
+            success: true,
+            result: deleteUser,
+        };
+    });
+}

dist/package-shared/functions/api/users/api-get-user.d.ts

@@ -0,0 +1,5 @@
+import { APIGetUserFunctionParams, GetUserFunctionReturn } from "../../../types";
+/**
+ * # API Get User
+ */
+export default function apiGetUser({ fields, dbFullName, userId, useLocal, }: APIGetUserFunctionParams): Promise<GetUserFunctionReturn>;

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

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiGetUser;
+const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+/**
+ * # API Get User
+ */
+function apiGetUser(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ fields, dbFullName, userId, useLocal, }) {
+        const query = `SELECT ${fields.join(",")} FROM users WHERE id=?`;
+        const API_USER_ID = userId || process.env.DSQL_API_USER_ID;
+        let foundUser = yield (0, varDatabaseDbHandler_1.default)({
+            queryString: query,
+            queryValuesArray: [API_USER_ID],
+            database: dbFullName.replace(/[^a-z0-9_]/g, ""),
+            useLocal,
+        });
+        if (!foundUser || !foundUser[0]) {
+            return {
+                success: false,
+                payload: null,
+            };
+        }
+        return {
+            success: true,
+            payload: foundUser[0],
+        };
+    });
+}

dist/package-shared/functions/api/users/api-login.d.ts

@@ -0,0 +1,5 @@
+import { APILoginFunctionParams, APILoginFunctionReturn } from "../../../types";
+/**
+ * # API Login
+ */
+export default function apiLoginUser({ encryptionKey, email, username, password, database, additionalFields, email_login, email_login_code, email_login_field, token, skipPassword, social, useLocal, }: APILoginFunctionParams): Promise<APILoginFunctionReturn>;

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

@@ -0,0 +1,137 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiLoginUser;
+const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
+/**
+ * # API Login
+ */
+function apiLoginUser(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ encryptionKey, email, username, password, database, additionalFields, email_login, email_login_code, email_login_field, token, skipPassword, social, useLocal, }) {
+        const dbFullName = database;
+        /**
+         * Check input validity
+         *
+         * @description Check input validity
+         */
+        if ((email === null || email === void 0 ? void 0 : email.match(/ /)) ||
+            (username && (username === null || username === void 0 ? void 0 : username.match(/ /))) ||
+            (password && (password === null || password === void 0 ? void 0 : password.match(/ /)))) {
+            return {
+                success: false,
+                msg: "Invalid Email/Password format",
+            };
+        }
+        /**
+         * Password hash
+         *
+         * @description Password hash
+         */
+        let hashedPassword = password
+            ? (0, hashPassword_1.default)({
+                encryptionKey: encryptionKey,
+                password: password,
+            })
+            : null;
+        let foundUser = yield (0, varDatabaseDbHandler_1.default)({
+            queryString: `SELECT * FROM users WHERE email = ? OR username = ?`,
+            queryValuesArray: [email, username],
+            database: dbFullName.replace(/[^a-z0-9_]/g, ""),
+            useLocal,
+        });
+        if ((!foundUser || !foundUser[0]) && !social)
+            return {
+                success: false,
+                payload: null,
+                msg: "No user found",
+            };
+        let isPasswordCorrect = false;
+        if ((foundUser === null || foundUser === void 0 ? void 0 : foundUser[0]) && !email_login && skipPassword) {
+            isPasswordCorrect = true;
+        }
+        else if ((foundUser === null || foundUser === void 0 ? void 0 : 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 = yield (0, varDatabaseDbHandler_1.default)({
+                queryString: `UPDATE users SET ${email_login_field} = '' WHERE email = ? OR username = ?`,
+                queryValuesArray: [email, username],
+                database: dbFullName.replace(/[^a-z0-9_]/g, ""),
+                useLocal,
+            });
+        }
+        let csrfKey = Math.random().toString(36).substring(2) +
+            "-" +
+            Math.random().toString(36).substring(2);
+        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: userPayload,
+            userId: foundUser[0].id,
+            csrf: csrfKey,
+        };
+        if (additionalFields &&
+            Array.isArray(additionalFields) &&
+            additionalFields.length > 0) {
+            additionalFields.forEach((key) => {
+                userPayload[key] = foundUser[0][key];
+            });
+        }
+        return resposeObject;
+    });
+}

dist/package-shared/functions/api/users/api-reauth-user.d.ts

@@ -0,0 +1,14 @@
+import { APILoginFunctionReturn } from "../../../types";
+type Param = {
+    existingUser: {
+        [s: string]: any;
+    };
+    database?: string;
+    additionalFields?: string[];
+    useLocal?: boolean;
+};
+/**
+ * # Re-authenticate API user
+ */
+export default function apiReauthUser({ existingUser, database, additionalFields, useLocal, }: Param): Promise<APILoginFunctionReturn>;
+export {};

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

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiReauthUser;
+const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+/**
+ * # Re-authenticate API user
+ */
+function apiReauthUser(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ existingUser, database, additionalFields, useLocal, }) {
+        let foundUser = (existingUser === null || existingUser === void 0 ? void 0 : existingUser.id) && existingUser.id.toString().match(/./)
+            ? yield (0, varDatabaseDbHandler_1.default)({
+                queryString: `SELECT * FROM users WHERE id=?`,
+                queryValuesArray: [existingUser.id.toString()],
+                database,
+                useLocal,
+            })
+            : 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 {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(),
+        };
+        if (additionalFields &&
+            Array.isArray(additionalFields) &&
+            additionalFields.length > 0) {
+            additionalFields.forEach((key) => {
+                userPayload[key] = foundUser[0][key];
+            });
+        }
+        return {
+            success: true,
+            msg: "Login Successful",
+            payload: userPayload,
+            csrf: csrfKey,
+        };
+    });
+}

dist/package-shared/functions/api/users/api-send-email-code.d.ts

@@ -0,0 +1,23 @@
+import http from "http";
+import { SendOneTimeCodeEmailResponse } from "../../../types";
+type Param = {
+    email: string;
+    database: string;
+    email_login_field?: string;
+    mail_domain?: string;
+    mail_port?: number;
+    sender?: string;
+    mail_username?: string;
+    mail_password?: string;
+    html: string;
+    useLocal?: boolean;
+    response?: http.ServerResponse & {
+        [s: string]: any;
+    };
+    extraCookies?: import("../../../../package-shared/types").CookieObject[];
+};
+/**
+ * # Send Email Login Code
+ */
+export default function apiSendEmailCode({ email, database, email_login_field, mail_domain, mail_port, sender, mail_username, mail_password, html, useLocal, response, extraCookies, }: Param): Promise<SendOneTimeCodeEmailResponse>;
+export {};

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

@@ -0,0 +1,134 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiSendEmailCode;
+const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+const nodemailer_1 = __importDefault(require("nodemailer"));
+const get_auth_cookie_names_1 = __importDefault(require("../../backend/cookies/get-auth-cookie-names"));
+const encrypt_1 = __importDefault(require("../../dsql/encrypt"));
+const serialize_cookies_1 = __importDefault(require("../../../utils/serialize-cookies"));
+/**
+ * # Send Email Login Code
+ */
+function apiSendEmailCode(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ email, database, email_login_field, mail_domain, mail_port, sender, mail_username, mail_password, html, useLocal, response, extraCookies, }) {
+        if (email === null || email === void 0 ? void 0 : email.match(/ /)) {
+            return {
+                success: false,
+                msg: "Invalid Email/Password format",
+            };
+        }
+        const createdAt = Date.now();
+        const foundUserQuery = `SELECT * FROM users WHERE email = ?`;
+        const foundUserValues = [email];
+        let foundUser = yield (0, varDatabaseDbHandler_1.default)({
+            queryString: foundUserQuery,
+            queryValuesArray: foundUserValues,
+            database,
+            useLocal,
+        });
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        ////////////////////////////////////////
+        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 === null || foundUser === void 0 ? void 0 : foundUser[0]) && email_login_field) {
+            const tempCode = generateCode();
+            let transporter = nodemailer_1.default.createTransport({
+                host: mail_domain || process.env.DSQL_MAIL_HOST,
+                port: mail_port
+                    ? mail_port
+                    : process.env.DSQL_MAIL_PORT
+                        ? Number(process.env.DSQL_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 = yield transporter.sendMail(mailObject);
+            if (!(info === null || info === void 0 ? void 0 : info.accepted))
+                throw new Error("Mail not Sent!");
+            const setTempCodeQuery = `UPDATE users SET ${email_login_field} = ? WHERE email = ?`;
+            const setTempCodeValues = [tempCode + `-${createdAt}`, email];
+            let setTempCode = yield (0, varDatabaseDbHandler_1.default)({
+                queryString: setTempCodeQuery,
+                queryValuesArray: setTempCodeValues,
+                database: database,
+                useLocal,
+            });
+            /** @type {import("../../../types").SendOneTimeCodeEmailResponse} */
+            const resObject = {
+                success: true,
+                code: tempCode,
+                email: email,
+                createdAt,
+                msg: "Success",
+            };
+            if (response) {
+                const cookieKeyNames = (0, get_auth_cookie_names_1.default)();
+                const oneTimeCodeCookieName = cookieKeyNames.oneTimeCodeName;
+                const encryptedPayload = (0, encrypt_1.default)({
+                    data: JSON.stringify(resObject),
+                });
+                if (!encryptedPayload) {
+                    throw new Error("apiSendEmailCode Error: Failed to encrypt payload");
+                }
+                /** @type {import("../../../../package-shared/types").CookieObject} */
+                const oneTimeCookieObject = {
+                    name: oneTimeCodeCookieName,
+                    value: encryptedPayload,
+                    sameSite: "Strict",
+                    path: "/",
+                    httpOnly: true,
+                    secure: true,
+                };
+                /** @type {import("../../../../package-shared/types").CookieObject[]} */
+                const cookiesObjectArray = extraCookies
+                    ? [...extraCookies, oneTimeCookieObject]
+                    : [oneTimeCookieObject];
+                const serializedCookies = (0, serialize_cookies_1.default)({
+                    cookies: cookiesObjectArray,
+                });
+                response.setHeader("Set-Cookie", serializedCookies);
+            }
+            return resObject;
+        }
+        else {
+            return {
+                success: false,
+                msg: "Invalid Email/Password format",
+            };
+        }
+    });
+}

dist/package-shared/functions/api/users/api-update-user.d.ts

@@ -0,0 +1,19 @@
+type Param = {
+    payload: {
+        [s: string]: any;
+    };
+    dbFullName: string;
+    updatedUserId: string | number;
+    useLocal?: boolean;
+    dbSchema?: import("../../../types").DSQL_DatabaseSchemaType;
+};
+type Return = {
+    success: boolean;
+    payload?: any;
+    msg?: string;
+};
+/**
+ * # Update API User Function
+ */
+export default function apiUpdateUser({ payload, dbFullName, updatedUserId, useLocal, dbSchema, }: Param): Promise<Return>;
+export {};

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

@@ -0,0 +1,85 @@
+"use strict";
+// @ts-check
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiUpdateUser;
+const updateDbEntry_1 = __importDefault(require("../../backend/db/updateDbEntry"));
+const encrypt_1 = __importDefault(require("../../dsql/encrypt"));
+const hashPassword_1 = __importDefault(require("../../dsql/hashPassword"));
+const varDatabaseDbHandler_1 = __importDefault(require("../../backend/varDatabaseDbHandler"));
+/**
+ * # Update API User Function
+ */
+function apiUpdateUser(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ payload, dbFullName, updatedUserId, useLocal, dbSchema, }) {
+        const existingUserQuery = `SELECT * FROM users WHERE id = ?`;
+        const existingUserValues = [updatedUserId];
+        const existingUser = yield (0, varDatabaseDbHandler_1.default)({
+            queryString: existingUserQuery,
+            queryValuesArray: existingUserValues,
+            database: dbFullName,
+            useLocal,
+        });
+        if (!(existingUser === null || existingUser === void 0 ? void 0 : existingUser[0])) {
+            return {
+                success: false,
+                msg: "User not found",
+            };
+        }
+        const data = (() => {
+            const reqBodyKeys = Object.keys(payload);
+            const targetTableSchema = (() => {
+                var _a;
+                try {
+                    const targetDatabaseSchema = (_a = dbSchema === null || dbSchema === void 0 ? void 0 : dbSchema.tables) === null || _a === void 0 ? void 0 : _a.find((tbl) => tbl.tableName == "users");
+                    return targetDatabaseSchema;
+                }
+                catch (error) {
+                    return undefined;
+                }
+            })();
+            /** @type {any} */
+            const finalData = {};
+            reqBodyKeys.forEach((key) => {
+                var _a;
+                const targetFieldSchema = (_a = targetTableSchema === null || targetTableSchema === void 0 ? void 0 : targetTableSchema.fields) === null || _a === void 0 ? void 0 : _a.find((field) => field.fieldName == key);
+                if (key === null || key === void 0 ? void 0 : key.match(/^date_|^id$|^uuid$/))
+                    return;
+                let value = payload[key];
+                if (targetFieldSchema === null || targetFieldSchema === void 0 ? void 0 : targetFieldSchema.encrypted) {
+                    value = (0, encrypt_1.default)({ data: value });
+                }
+                finalData[key] = value;
+            });
+            if (finalData.password && typeof finalData.password == "string") {
+                finalData.password = (0, hashPassword_1.default)({ password: finalData.password });
+            }
+            return finalData;
+        })();
+        const updateUser = yield (0, updateDbEntry_1.default)({
+            dbContext: "Dsql User",
+            paradigm: "Full Access",
+            dbFullName,
+            tableName: "users",
+            identifierColumnName: "id",
+            identifierValue: updatedUserId,
+            data: data,
+            useLocal,
+        });
+        return {
+            success: true,
+            payload: updateUser,
+        };
+    });
+}

dist/package-shared/functions/api/users/social/api-github-login.d.ts

@@ -0,0 +1,17 @@
+import { APILoginFunctionReturn } from "../../../../types";
+type Param = {
+    code?: string;
+    clientId?: string;
+    clientSecret?: string;
+    database?: string;
+    additionalFields?: string[];
+    additionalData?: {
+        [s: string]: string | number;
+    };
+    email?: string;
+};
+/**
+ * # API Login with Github
+ */
+export default function apiGithubLogin({ code, clientId, clientSecret, database, additionalFields, email, additionalData, }: Param): Promise<APILoginFunctionReturn>;
+export {};

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

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiGithubLogin;
+const handleSocialDb_1 = __importDefault(require("../../social-login/handleSocialDb"));
+const githubLogin_1 = __importDefault(require("../../social-login/githubLogin"));
+const camelJoinedtoCamelSpace_1 = __importDefault(require("../../../../utils/camelJoinedtoCamelSpace"));
+/**
+ * # API Login with Github
+ */
+function apiGithubLogin(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ code, clientId, clientSecret, database, additionalFields, email, additionalData, }) {
+        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 = yield (0, githubLogin_1.default)({
+            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 === null || targetName === void 0 ? void 0 : targetName.match(/ /))
+            ? targetName === null || targetName === void 0 ? void 0 : targetName.split(" ")
+            : (targetName === null || targetName === void 0 ? void 0 : targetName.match(/\-/))
+                ? targetName === null || targetName === void 0 ? void 0 : targetName.split("-")
+                : [targetName];
+        let payload = {
+            email: gitHubUser.email,
+            first_name: (0, camelJoinedtoCamelSpace_1.default)(nameArray[0]),
+            last_name: (0, camelJoinedtoCamelSpace_1.default)(nameArray[1]),
+            social_id: socialId,
+            social_platform: "github",
+            image: gitHubUser.avatar_url,
+            image_thumbnail: gitHubUser.avatar_url,
+            username: "github-user-" + socialId,
+        };
+        if (additionalData) {
+            payload = Object.assign(Object.assign({}, payload), additionalData);
+        }
+        const loggedInGithubUser = yield (0, handleSocialDb_1.default)({
+            database,
+            email: gitHubUser.email,
+            payload,
+            social_platform: "github",
+            social_id: socialId,
+            supEmail: email,
+            additionalFields,
+        });
+        ////////////////////////////////////////////////
+        ////////////////////////////////////////////////
+        ////////////////////////////////////////////////
+        return Object.assign({}, loggedInGithubUser);
+    });
+}

dist/package-shared/functions/api/users/social/api-google-login.d.ts

@@ -0,0 +1,5 @@
+import { APIGoogleLoginFunctionParams, APILoginFunctionReturn } from "../../../../types";
+/**
+ * # API google login
+ */
+export default function apiGoogleLogin({ token, database, additionalFields, additionalData, }: APIGoogleLoginFunctionParams): Promise<APILoginFunctionReturn>;

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

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = apiGoogleLogin;
+const https_1 = __importDefault(require("https"));
+const handleSocialDb_1 = __importDefault(require("../../social-login/handleSocialDb"));
+const ejson_1 = __importDefault(require("../../../../utils/ejson"));
+/**
+ * # API google login
+ */
+function apiGoogleLogin(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ token, database, additionalFields, additionalData, }) {
+        try {
+            const gUser = yield new Promise((resolve, reject) => {
+                https_1.default
+                    .request({
+                    method: "GET",
+                    hostname: "www.googleapis.com",
+                    path: "/oauth2/v3/userinfo",
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                    },
+                }, (res) => {
+                    let data = "";
+                    res.on("data", (chunk) => {
+                        data += chunk;
+                    });
+                    res.on("end", () => {
+                        resolve(ejson_1.default.parse(data));
+                    });
+                })
+                    .end();
+            });
+            if (!(gUser === null || gUser === void 0 ? void 0 : gUser.email_verified))
+                throw new Error("No Google User.");
+            ////////////////////////////////////////
+            ////////////////////////////////////////
+            ////////////////////////////////////////
+            if (!database || typeof database != "string" || (database === null || database === void 0 ? void 0 : database.match(/ /))) {
+                return {
+                    success: false,
+                    payload: 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 { given_name, family_name, email, sub, picture } = gUser;
+            /** @type {Object<string, any>} */
+            let 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 (additionalData) {
+                payloadObject = Object.assign(Object.assign({}, payloadObject), additionalData);
+            }
+            const loggedInGoogleUser = yield (0, handleSocialDb_1.default)({
+                database,
+                email: email || "",
+                payload: payloadObject,
+                social_platform: "google",
+                social_id: sub,
+                additionalFields,
+            });
+            ////////////////////////////////////////
+            ////////////////////////////////////////
+            ////////////////////////////////////////
+            return Object.assign({}, loggedInGoogleUser);
+        }
+        catch ( /** @type {any} */error) {
+            console.log(`apo-google-login.js ERROR: ${error.message}`);
+            return {
+                success: false,
+                payload: undefined,
+                msg: error.message,
+            };
+        }
+    });
+}