hopefully correct error handling for real

src/commands.js

@@ -0,0 +1,40 @@
+import {messageHelper} from "./helpers/messageHelper.js";
+import {enums} from "./enums.js";
+import {memberHelper} from "./helpers/memberHelper.js";
+import {EmbedBuilder} from "@fluxerjs/core";
+
+const cmds = new Map();
+
+cmds.set('member', {
+    description: enums.help.SHORT_DESC_MEMBER,
+    async execute(message, client, args) {
+        const authorFull = `${message.author.username}#${message.author.discriminator}`
+        const reply = await memberHelper.parseMemberCommand(message.author.id, authorFull, args, message.attachments[0] = null).catch(e => throw e);
+        if (typeof reply === 'string') {
+            return await message.reply(reply);
+        }
+        await message.reply({embeds: [reply.toJSON()]})
+    }
+})
+
+cmds.set('help', {
+    description: enums.help.SHORT_DESC_HELP,
+    async execute(message) {
+        const fields = [...cmds.entries()].map(([name, cmd]) => ({
+            name: `${messageHelper.prefix}${name}`,
+            value: cmd.description,
+            inline: true,
+        }));
+
+        const embed = new EmbedBuilder()
+            .setTitle('Commands')
+            .setDescription(enums.help.PLURALFLUX)
+            .addFields(...fields)
+            .setFooter({ text: `Prefix: ${messageHelper.prefix}` })
+            .setTimestamp();
+
+        await message.reply({ embeds: [embed.toJSON()] });
+    },
+})
+
+export const commands = cmds;

src/helpers/memberHelper.js

@@ -0,0 +1,422 @@
+import { db } from '../sequelize.js';
+import {enums} from "../enums.js";
+import { loadImage } from "canvas";
+import {EmptyResultError} from "sequelize";
+import {EmbedBuilder, User} from "@fluxerjs/core";
+
+const mh = {};
+
+// Has an empty "command" to parse the help message properly
+const commandList = ['--help', 'add', 'remove', 'name', 'listall', 'displayName', 'proxy', 'propic', ''];
+
+/**
+ * Parses through the subcommands that come after "pf;member" and calls functions accordingly.
+ *
+ * @param {User} author - The id of the message author
+ * @param {string[]} args - The message arguments
+ * @param {string | null} attachmentUrl - The message attachment url.
+ * @returns {Promise<string> | Promise <EmbedBuilder>} A message, or an informational embed.
+ */
+mh.parseMemberCommand = async function(author, args, attachmentUrl){
+    const authorId = author.id;
+    const authorFull = `${author.username}${author.discriminator}`;
+    let member;
+    // checks whether command is in list, otherwise assumes it's a name
+    if(!commandList.includes(args[0])) {
+        member = await getMemberInfo(authorId, args[0]);
+    }
+    switch(args[0]) {
+        case '--help':
+            return enums.help.MEMBER;
+        case 'add':
+            return await mh.addNewMember(authorId, args).catch((e) => throw e);
+        case 'remove':
+            return await mh.removeMember(authorId, args).catch((e) => throw e);
+        case 'name':
+            return enums.help.NAME;
+        case 'displayname':
+            return enums.help.DISPLAY_NAME;
+        case 'proxy':
+            return enums.help.PROXY;
+        case 'propic':
+            return enums.help.PROPIC;
+        case 'list':
+            return await mh.getAllMembersInfo(authorId, authorFull).catch((e) => throw e);
+        case '':
+            return enums.help.MEMBER;
+    }
+    switch(args[1]) {
+        case 'name':
+            return await mh.updateName(authorId, args).catch((e) => throw e);
+        case 'displayname':
+            return await mh.updateDisplayName(authorId, args).catch((e) => throw e);
+        case 'proxy':
+            return await mh.updateProxy(authorId, args).catch((e) => throw e);
+        case 'propic':
+            return await mh.updatePropic(authorId, args, attachmentUrl).catch((e) => throw e);
+        default:
+            return member;
+    }
+}
+
+/**
+ * Adds a member.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string[]} args - The message arguments
+ * @returns {Promise<string>} A successful addition.
+ * @throws {Error}  When the member exists, or creating a member doesn't work.
+ */
+mh.addNewMember = async function(authorId, args) {
+    if (args[1] && args[1] === "--help" || !args[1]) {
+        return enums.help.ADD;
+    }
+    const memberName = args[1];
+    const displayName = args[2];
+
+    return await mh.addFullMember(authorId, memberName, displayName).then((member) => {
+        let success = `Member was successfully added.\nName: ${member.dataValues.name}`
+        success += displayName ? `\nDisplay name: ${member.dataValues.displayname}` : "";
+        return success;
+    }).catch(e => {
+        throw new Error(`${enums.err.ADD_ERROR}: ${e.message}`)
+    })
+}
+
+/**
+ * Updates the name for a member.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string[]} args - The message arguments
+ * @returns {Promise<string>} A successful update.
+ * @throws {RangeError} When the name doesn't exist.
+ */
+mh.updateName = async function (authorId, args) {
+    if (args[1] && args[1] === "--help" || !args[1]) {
+        return enums.help.DISPLAY_NAME;
+    }
+
+    const name = args[2];
+    const trimmedName = name ? name.trim() : null;
+    if (!name || trimmedName === null) {
+        throw new RangeError(`Display name ${enums.err.NO_VALUE}`);
+    }
+    return await mh.updateMemberField(authorId, args).catch((e) => throw e);
+}
+
+/**
+ * Updates the display name for a member.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string[]} args - The message arguments
+ * @returns {Promise<string>} A successful update.
+ * @throws {RangeError} When the display name is too long or doesn't exist.
+ */
+mh.updateDisplayName = async function(authorId, args) {
+    if (args[1] && args[1] === "--help" || !args[1]) {
+        return enums.help.DISPLAY_NAME;
+    }
+
+    const memberName = args[0];
+    const displayName = args[2];
+    const trimmedName = displayName ? displayName.trim() : null;
+
+    if (!displayName || trimmedName === null ) {
+        return await mh.getMemberByName(authorId, memberName).then((member) => {
+            if (member.displayname) {
+                return `Display name for ${memberName} is: \"${member.displayname}\".`;
+            }
+            throw new RangeError(`Display name ${enums.err.NO_VALUE}`);
+        }).catch((e) => throw e);
+
+    }
+    else if (displayName.length > 32) {
+        throw new RangeError(enums.err.DISPLAY_NAME_TOO_LONG);
+    }
+    return await mh.updateMemberField(authorId, args).catch((e) => throw e);
+}
+
+/**
+ * Updates the proxy for a member, first checking that no other members attached to the author have the tag.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string[]} args - The message arguments
+ * @returns {Promise<string> } A successful update.
+ * @throws {RangeError | Error} When an empty proxy was provided, or no proxy exists.
+ */
+mh.updateProxy = async function(authorId, args) {
+    if (args[1] && args[1] === "--help" || !args[1]) {
+        return enums.help.PROXY;
+    }
+    const proxyExists = await mh.checkIfProxyExists(authorId, args[2]).then((proxyExists) => {
+        return proxyExists;
+    }).catch((e) => throw e);
+    if (!proxyExists) {
+        return await mh.updateMemberField(authorId, args).catch((e) => throw e);
+    }
+}
+
+/**
+ * Updates the proxy for a member, first checking that no other members attached to the author have the tag.
+ *
+ * @param {string} authorId - The author of the message
+ * @param {string} proxy - The proxy tag.
+ * @returns {Promise<boolean> } Whether the proxy exists.
+ * @throws {Error} When an empty proxy was provided, or no proxy exists.
+ */
+mh.checkIfProxyExists = async function(authorId, proxy) {
+    const trimmedProxy = proxy ? proxy.trim() : null;
+
+    if (trimmedProxy == null) throw new RangeError(`Proxy ${enums.err.NO_VALUE}`);
+    const splitProxy = proxy.trim().split("text");
+    if(splitProxy.length < 2) throw new Error(enums.err.NO_TEXT_FOR_PROXY);
+    if(!splitProxy[0] && !splitProxy[1]) throw new Error(enums.err.NO_PROXY_WRAPPER);
+
+    const members = await mh.getMembersByAuthor(authorId).then(() => {
+        const proxyExists = members.some(member => member.proxy === proxy);
+        if (proxyExists) {
+            throw new Error(enums.err.PROXY_EXISTS);
+        }
+        return false;
+    }).catch(e => throw e);
+
+}
+/**
+ * Updates the profile pic for a member, based on either the attachment or the args provided.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string[]} args - The message arguments
+ * @param {string} attachment - The url of the first attachment in the message
+ * @returns {Promise<string>} A successful update.
+ * @throws {Error} When loading the profile picture from a URL doesn't work.
+ */
+mh.updatePropic = async function(authorId, args, attachment) {
+    if (args[1] && args[1] === "--help") {
+        return enums.help.PROPIC;
+    }
+    let img;
+    const updatedArgs = args;
+    if (!updatedArgs[1] && !attachment) {
+        return enums.help.PROPIC;
+    } else if (attachment) {
+        updatedArgs[2] = attachment.url;
+        updatedArgs[3] = attachment.expires_at;
+    }
+    if (updatedArgs[2]) {
+        img = updatedArgs[2];
+    }
+
+    const loadedImage = await loadImage(img).then((li) => {
+        return li;
+    }).catch((err) => {
+        throw new Error(`${enums.err.PROPIC_CANNOT_LOAD}: ${err.message}`);
+    });
+    if (loadedImage) {
+        return await mh.updateMemberField(authorId, updatedArgs).catch((e) => throw e);
+    }
+}
+
+/**
+ * Removes a member.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string[]} args - The message arguments
+ * @returns {Promise<string>} A successful removal.
+ * @throws {EmptyResultError} When there is no member to remove.
+ */
+mh.removeMember = async function(authorId, args) {
+    if (args[1] && args[1] === "--help" || !args[1]) {
+        return enums.help.REMOVE;
+    }
+
+    const memberName = args[1];
+    return await db.members.destroy({ where: { name: memberName, userid: authorId } }).then(() => {
+        return `Member "${memberName}" has been deleted.`;
+    }).catch(e => {
+        throw new EmptyResultError(`${enums.err.NO_MEMBER}: ${e.message}`);
+    });
+}
+
+/*======Non-Subcommands======*/
+
+/**
+ * Adds a member with full details, first checking that there is no member of that name associated with the author.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string} memberName - The name of the member.
+ * @param {string} displayName - The display name of the member.
+ * @param {string | null} proxy - The proxy tag of the member.
+ * @param {string | null} propic - The profile picture URL of the member.
+ * @returns {Promise<string>} A successful addition.
+ * @throws {Error | RangeError}  When the member already exists, there are validation errors, or adding a member doesn't work.
+ */
+mh.addFullMember = async function(authorId, memberName, displayName, proxy = null, propic= null) {
+    const member = await mh.getMemberByName(authorId, memberName);
+    if (member) {
+        throw new Error(`Can't add ${memberName}. ${enums.err.MEMBER_EXISTS}`);
+    }
+
+    const trimmedName = displayName ? displayName.trim() : null;
+    if (trimmedName && trimmedName.length > 32) {
+        throw new RangeError(`Can't add ${memberName}. ${enums.err.DISPLAY_NAME_TOO_LONG}`);
+    }
+
+    if (propic) {
+        await loadImage(propic).catch((err) => {
+            throw new Error(`Can't add ${memberName}. ${enums.err.PROPIC_CANNOT_LOAD}: ${err.message}`);
+        });
+    }
+
+    return await db.members.create({
+        name: memberName,
+        userid: authorId,
+        displayname: displayName,
+        proxy: proxy,
+        propic: propic,
+    }).catch(e => {
+        throw new Error(`Can't add ${memberName}. ${enums.err.ADD_ERROR}: ${e.message}`)
+    })
+}
+
+/**
+ * Updates one fields for a member in the database.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string[]} args - The message arguments
+ * @returns {Promise<string>} A successful update.
+ * @throws {EmptyResultError | Error} When the member is not found, or catchall error.
+ */
+mh.updateMemberField = async function(authorId, args) {
+    const memberName = args[0];
+    const columnName = args[1];
+    const value = args[2];
+    let fluxerPropicWarning;
+
+    // indicates that an attachment was uploaded on Fluxer directly
+    if (columnName === "propic" && args[3]) {
+        console.log(args);
+        fluxerPropicWarning = mh.setExpirationWarning(args[3]);
+    }
+    return await db.members.update({[columnName]: value}, { where: { name: memberName, userid: authorId } }).then(() => {
+        return `Updated ${columnName} for ${memberName} to "${value}"${fluxerPropicWarning ?? ''}.`;
+    }).catch(e => {
+        if (e === EmptyResultError) {
+            throw new EmptyResultError(`Can't update ${memberName}. ${enums.err.NO_MEMBER}: ${e.message}`);
+        }
+        else {
+            throw new Error(`Can't update ${memberName}. ${e.message}`);
+        }
+    });
+}
+
+/**
+ * Sets the warning for an expiration date.
+ *
+ * @param {string} expirationString - An expiration date string.
+ * @returns {string} A description of the expiration, interpolating the expiration string.
+ */
+mh.setExpirationWarning = async function(expirationString) {
+    let expirationDate = new Date(expirationString);
+    if (!isNaN(expirationDate.valueOf())) {
+        expirationDate = expirationDate.toDateString();
+        return `\n**NOTE:** Because this profile picture was uploaded via Fluxer, it will currently expire on *${expirationDate}*. To avoid this, upload the picture to another website like <https://imgbb.com/> and link to it directly.`
+    }
+}
+
+/**
+ * Gets the details for a member.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string} memberName - The message arguments
+ * @returns {Promise<EmbedBuilder>} The member's info.
+ * @throws {Error}
+ */
+mh.getMemberInfo = async function(authorId, memberName) {
+    return await mh.getMemberByName(authorId, memberName).then((member) => {
+        return new EmbedBuilder()
+            .setTitle(memberName)
+            .setDescription(`Details for ${memberName}`)
+            .addFields(
+                {name: 'Display name: ', value: member.displayname ?? 'unset', inline: true},
+                {name: 'Proxy tag: ', value: member.proxy ?? 'unset', inline: true},
+            )
+            .setImage(member.propic);
+    }).catch((e) => throw e)
+}
+
+/**
+ * Gets all members for an author.
+ *
+ * @async
+ * @param {string} authorId - The id of the message author
+ * @param {string} authorName - The id name the message author
+ * @returns {Promise<EmbedBuilder>} The info for all members.
+ * @throws {Error}
+ */
+mh.getAllMembersInfo = async function(authorId, authorName) {
+    const members = await mh.getMembersByAuthor(authorId).catch(e => throw e);
+    const fields = [...members.entries()].map(([member]) => ({
+        name: member.name,
+        value: `(Proxy: \`${member.proxy}\`)`,
+        inline: true,
+    }));
+    return new EmbedBuilder()
+        .setTitle(`Members for ${authorName}`)
+        .addFields(...fields);
+}
+
+/**
+ * Gets a member based on the author and proxy tag.
+ *
+ * @async
+ * @param {string} authorId - The author of the message.
+ * @param {string} memberName - The member's name.
+ * @returns {Promise<model>} The member object.
+ * @throws { EmptyResultError } When the member is not found.
+ */
+mh.getMemberByName = async function(authorId, memberName) {
+    return await db.members.findOne({ where: { userid: authorId, name: memberName } }).catch(e => {
+        throw new EmptyResultError(`Can't get ${memberName}. ${enums.err.NO_MEMBER}: ${e.message}`);
+    });
+}
+
+/**
+ * Gets a member based on the author and proxy tag.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @param {string} proxy - The proxy tag
+ * @returns {Promise<model>} The member object.
+ * @throws { EmptyResultError } When the member is not found.
+ */
+mh.getMemberByProxy = async function(authorId, proxy) {
+    return await db.members.findOne({ where: { userid: authorId, proxy: proxy } }).catch(e => {
+        throw new EmptyResultError(`Can't find member with that proxy. ${enums.err.NO_MEMBER}: ${e.message}`);
+    });
+}
+
+/**
+ * Gets all members belonging to the author.
+ *
+ * @async
+ * @param {string} authorId - The author of the message
+ * @returns {Promise<model[]>} The member object array.
+ * @throws { EmptyResultError } When no members are found.
+ */
+mh.getMembersByAuthor = async function(authorId) {
+    return await db.members.findAll({ where: { userid: authorId } }).catch(e => {
+        throw new EmptyResultError(`${enums.err.USER_NO_MEMBERS}: ${e.message}`);
+    });
+}
+
+
+export const memberHelper = mh;

src/helpers/messageHelper.js

@@ -0,0 +1,56 @@
+import {memberHelper} from "./memberHelper.js";
+import {enums} from "../enums.js";
+
+const msgh = {};
+
+msgh.prefix = "pf;"
+
+/**
+ * Parses and slices up message arguments, retaining quoted strings.
+ *
+ * @param {string} content - The full message content.
+ * @param {string} commandName - The command name.
+ * @returns {string[]} An array of arguments.
+ */
+msgh.parseCommandArgs = function(content, commandName) {
+    const message = content.slice(msgh.prefix.length + commandName.length).trim();
+
+    return message.match(/\\?.|^$/g).reduce((accumulator, chara) => {
+        if (chara === '"') {
+            // checks whether string is within quotes or not
+            accumulator.quote ^= 1;
+        } else if (!accumulator.quote && chara === ' '){
+            // if not currently in quoted string, push empty string to start word
+            accumulator.array.push('');
+        } else {
+            // accumulates characters to the last string in the array and removes escape characters
+            accumulator.array[accumulator.array.length-1] += chara.replace(/\\(.)/,"$1");
+        }
+        return accumulator;
+    }, {array: ['']}).array // initial array with empty string for the reducer
+}
+
+/**
+ * Parses proxy tags and sees if they match the tags of any member belonging to an author.
+ *
+ * @param {string} authorId - The author of the message.
+ * @param {Object} attachment - An attachment for the message, if any exists.
+ * @param {string} content - The full message content.
+ * @returns {Object} The proxy message object.
+ */
+msgh.parseProxyTags = async function (authorId, attachment, content){
+    const members = await memberHelper.getMembersByAuthor(authorId).catch(e => throw e);
+
+    const proxyMessage = {}
+    members.filter(member => member.proxy).forEach(member => {
+        const splitProxy = member.proxy.split("text");
+        if(content.startsWith(splitProxy[0]) && content.endsWith(splitProxy[1])) {
+            if (content.length <= member.proxy.length && !attachment) throw new Error(enums.err.NO_MESSAGE_SENT_WITH_PROXY);
+            proxyMessage.proxy = member.proxy;
+            proxyMessage.message = content.slice(member.proxy.length).trim();
+        }
+    })
+    return proxyMessage;
+}
+
+export const messageHelper = msgh;

src/helpers/webhookHelper.js

@@ -0,0 +1,105 @@
+import {messageHelper} from "./messageHelper.js";
+import {memberHelper} from "./memberHelper.js";
+import { Webhook, Channel, Message } from '@fluxerjs/core';
+import {enums} from "../enums.js";
+
+const wh = {};
+
+const name = 'PluralFlux Proxy Webhook';
+
+/**
+ * Replaces a proxied message with a webhook using the member information.
+ * @param {Client} client - The fluxer.js client.
+ * @param {Message} message - The full message object.
+ * @param {string} content - The full content of the message.
+ * @throws {Error} When the proxy message is not in a server.
+ */
+wh.sendMessageAsMember = async function(client, message, content) {
+    const proxyMatch = await messageHelper.parseProxyTags(message.author.id, message.attachments[0] ?? null, content).catch(e => throw e);
+    // If the message doesn't match a proxy, just return.
+    if (!proxyMatch.proxy) {
+        return;
+    }
+    // If the message does match a proxy but is in a guild server
+    if (!message.guildId) {
+        throw new Error(enums.err.NOT_IN_SERVER);
+    }
+    const member = await memberHelper.getMemberByProxy(message.author.id, proxyMatch.proxy).catch(e => throw e);
+    await replaceMessage(client, message, message.channelId, proxyMatch.message, member).catch(e => throw e);
+}
+
+/**
+ * Replaces a proxied message with a webhook using the member information.
+ * @param {Client} client - The fluxer.js client.
+ * @param {Message} message - The message to be deleted.
+ * @param {string} channelId - The channel id to send the webhook message in.
+ * @param {string} text - The text to send via the webhook.
+ * @param {model} member - A member object from the database.
+ * @throws {Error} When there's no message to send.
+ */
+async function replaceMessage(client, message, channelId, text, member) {
+    if (text.length > 0) {
+        const channel = client.channels.get(channelId);
+        const webhook = await getOrCreateWebhook(client, channel).catch((e) => throw e);
+        const username = member.displayname ?? member.name;
+        await webhook.send({content: text, username: username, avatar_url: member.propic});
+        await message.delete();
+    }
+    else {
+        throw new Error(enums.err.NO_MESSAGE_SENT_WITH_PROXY);
+    }
+}
+
+// /**
+//  * Fluxer collapses same-name messages, so if two would be sent by different users, break them up with a tiny space. (Inspired by Tupperbox)
+//  * @param {string} channelId - The channel id to send the webhook message in.
+//  * @param {string} username - The text to send via the webhook.
+//  */
+//
+// function preventSameNameCollapse(channelId, username) {
+//
+//     if(bot.recent[msg.channel.id] && msg.author.id !== bot.recent[msg.channel.id][0].user_id && un === bot.recent[msg.channel.id][0].name) {
+//         username = un.substring(0,1) + "\u200a" + un.substring(1);
+//     }
+// }
+
+/**
+ * Gets or creates a webhook.
+ *
+ * @param {Client} client - The fluxer.js client.
+ * @param {Channel} channel - The channel the message was sent in.
+ * @returns {Webhook} A webhook object.
+ * @throws {Error} When no webhooks are allowed in the channel.
+ */
+async function getOrCreateWebhook(client, channel) {
+    // If channel doesn't allow webhooks
+    if (!channel?.createWebhook) throw new Error(enums.err.NO_WEBHOOKS_ALLOWED);
+    let webhook = await getWebhook(client, channel).catch((e) => throw e);
+    if (!webhook) {
+        webhook = await channel.createWebhook({name: name});
+    }
+    return webhook;
+}
+
+/**
+ * Gets an existing webhook.
+ *
+ * @param {Client} client - The fluxer.js client.
+ * @param {Channel} channel - The channel the message was sent in.
+ * @returns {Webhook} A webhook object.
+ */
+async function getWebhook(client, channel) {
+    const channelWebhooks = await channel?.fetchWebhooks() ?? [];
+    if (channelWebhooks.length === 0) {
+        return;
+    }
+    let pf_webhook;
+    channelWebhooks.forEach((webhook) => {
+        if (webhook.name === name) {
+            pf_webhook = webhook;
+        }
+    })
+    return pf_webhook;
+}
+
+export const webhookHelper = wh;