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

import { findDbNameInSchemaDir } from "../../../shell/createDbFromSchema/grab-required-database-schemas";
import addUsersTableToDb from "../../backend/addUsersTableToDb";
import addDbEntry from "../../backend/db/addDbEntry";
import updateUsersTableSchema from "../../backend/updateUsersTableSchema";
import varDatabaseDbHandler from "../../backend/varDatabaseDbHandler";
import hashPassword from "../../dsql/hashPassword";
import validateEmail from "../../email/fns/validate-email";
/**
 * # API Create User
 */
export default async function apiCreateUser({ encryptionKey, payload, database, userId, }) {
    var _a;
    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 targetDbSchema = findDbNameInSchemaDir({
        dbName: dbFullName,
        userId,
    });
    if (!(targetDbSchema === null || targetDbSchema === void 0 ? void 0 : targetDbSchema.id)) {
        return {
            success: false,
            msg: "targetDbSchema not found",
            payload: null,
        };
    }
    const hashedPassword = hashPassword({
        encryptionKey: finalEncryptionKey,
        password: String(payload.password),
    });
    payload.password = hashedPassword;
    const fieldsQuery = `SHOW COLUMNS FROM ${dbFullName}.users`;
    let fields = await varDatabaseDbHandler({
        queryString: fieldsQuery,
        database: dbFullName,
    });
    if (!(fields === null || fields === void 0 ? void 0 : fields[0])) {
        const newTable = await addUsersTableToDb({
            userId: Number(API_USER_ID),
            database: dbFullName,
            payload: payload,
            dbId: targetDbSchema.id,
        });
        fields = await varDatabaseDbHandler({
            queryString: fieldsQuery,
            database: dbFullName,
        });
    }
    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)) {
            await updateUsersTableSchema({
                userId: Number(API_USER_ID),
                database: dbFullName,
                newPayload: {
                    [key]: payload[key],
                },
                dbId: targetDbSchema.id,
            });
        }
    }
    if (invalidField) {
        return {
            success: false,
            msg: `${invalidField} is not a valid field!`,
        };
    }
    const existingUserQuery = `SELECT * FROM ${dbFullName}.users WHERE email = ?${payload.username ? " OR username = ?" : ""}`;
    const existingUserValues = payload.username
        ? [payload.email, payload.username]
        : [payload.email];
    const existingUser = await varDatabaseDbHandler({
        queryString: existingUserQuery,
        queryValuesArray: existingUserValues,
        database: dbFullName,
    });
    if (existingUser === null || existingUser === void 0 ? void 0 : existingUser[0]) {
        return {
            success: false,
            msg: "User Already Exists",
            payload: null,
        };
    }
    const isEmailValid = await validateEmail({ email: payload.email });
    if (!isEmailValid.isValid) {
        return {
            success: false,
            msg: isEmailValid.message,
            payload: null,
        };
    }
    const addUser = await addDbEntry({
        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" }),
    });
    if ((_a = addUser === null || addUser === void 0 ? void 0 : addUser.payload) === null || _a === void 0 ? void 0 : _a.insertId) {
        const newlyAddedUserQuery = `SELECT id,uuid,first_name,last_name,email,username,image,image_thumbnail,verification_status FROM ${dbFullName}.users WHERE id='${addUser.payload.insertId}'`;
        const newlyAddedUser = await varDatabaseDbHandler({
            queryString: newlyAddedUserQuery,
            database: dbFullName,
        });
        return {
            success: true,
            payload: newlyAddedUser[0],
        };
    }
    else {
        return {
            success: false,
            msg: "Could not create user",
            sqlResult: addUser,
            payload: null,
        };
    }
}