kozz-module-maker 0.1.0

package/src/Message/FromTemplate/index.ts

@@ -0,0 +1,74 @@
+import fs from 'fs/promises';
+import parseDocument from '../kozz-md.parser';
+
+export type Line = {
+	line: Text[];
+};
+
+export type Text = {
+	style: keyof typeof styleMap;
+	text: string;
+};
+
+export const bold = (s: string) => `*${s}*`;
+export const italic = (s: string) => `_${s}_`;
+export const stroke = (s: string) => `~${s}~`;
+export const monospace = (s: string) => `\`\`\`${s}\`\`\``;
+
+const styleMap = {
+	bold: bold,
+	stroke: stroke,
+	italic: italic,
+	code: monospace,
+	boldAndItalic: (s: string) => bold(italic(s)),
+	normal: (s: string) => s,
+	template: (s: string) => s,
+	paragraph: (s: string) => `${bold(s)}\n`,
+	listItem: (s: string) => `  - ${s}`,
+	lineBreak: (s: string) => '',
+};
+
+export const getTemplates = (path: string) =>
+	fs.readFile(path, { encoding: 'utf-8' });
+
+const textMessageFromTemplate = (
+	templateName: string,
+	documentAsString: string,
+	templateData: Record<string, any> = {}
+) => {
+	const { result } = parseDocument(documentAsString, templateData);
+
+	const myMessage = result.filter(msg => msg.messageName === templateName)[0];
+
+	if (!myMessage) {
+		return console.error('No message found for the provided name');
+	}
+
+	return myMessage.messageBody.reduce((msg, { line }) => {
+		line.forEach(styledText => {
+			// I know this type asting is ugly
+			const stylingFn = styleMap[styledText.style as keyof typeof styleMap];
+			return (msg += stylingFn(styledText.text));
+		});
+		return (msg += '\n');
+	}, '');
+};
+
+/**
+ * Creates the ability to send messages from a message template
+ * @param path
+ * @returns
+ */
+export const loadTemplates = (path: string) => {
+	const getTextFromTemplate = (
+		templateName: string,
+		templateData: Record<string, any> = {}
+	) => {
+		return getTemplates(path).then(templates => {
+			return textMessageFromTemplate(templateName, templates, templateData);
+		});
+	};
+	return {
+		getTextFromTemplate,
+	};
+};

package/src/Message/PayloadCreation/Media.ts

@@ -0,0 +1,62 @@
+import fs from 'fs/promises';
+import { Media } from 'kozz-types';
+
+export type MimeType =
+	| 'video/mp4'
+	| 'image/gif'
+	| 'image'
+	| 'video'
+	| 'video/mpeg'
+	| 'audio/webm';
+
+export const loadMediaFromPath = async (
+	filePath: string,
+	mimeType: MimeType
+): Promise<Media> => {
+	const b64 = await fs.readFile(filePath, 'base64');
+	const fileName = null;
+
+	return {
+		data: b64,
+		fileName,
+		mimeType,
+		sizeInBytes: Buffer.from(b64, 'base64').length,
+		transportType: 'b64',
+	};
+};
+
+export const createMediaFromBuffer = (
+	buffer: Buffer,
+	mimeType: MimeType,
+	fileName?: string
+): Media => ({
+	data: buffer.toString('base64'),
+	fileName: fileName || null,
+	mimeType: mimeType,
+	sizeInBytes: buffer.length,
+	transportType: 'b64',
+});
+
+export const createMediaFromB64 = (
+	b64: string,
+	mimeType: MimeType,
+	fileName?: string
+): Media => ({
+	data: b64,
+	fileName: fileName || mimeType,
+	mimeType: mimeType,
+	sizeInBytes: Buffer.from(b64, 'base64').length,
+	transportType: 'b64',
+});
+
+export const createMediaFromUrl = (
+	url: string,
+	mimeType: MimeType,
+	fileName?: string
+): Media => ({
+	data: url,
+	fileName: fileName || mimeType,
+	mimeType: mimeType,
+	sizeInBytes: null,
+	transportType: 'url',
+});

package/src/Message/PayloadCreation/React.ts

@@ -0,0 +1,16 @@
+import { Command, MessageReceivedByGateway } from 'kozz-types';
+import { Socket } from 'socket.io-client';
+
+export const createReact = (
+	socket: Socket,
+	messagePayload: MessageReceivedByGateway
+) => {
+	const react = (emote: string) =>
+		socket.emit('react_message', {
+			messageId: messagePayload.id,
+			boundaryId: messagePayload.boundaryId,
+			emote,
+		});
+
+	return react;
+};

package/src/Message/PayloadCreation/Reply.ts

@@ -0,0 +1,63 @@
+import {
+	Command,
+	Media,
+	MessageReceivedByGateway,
+	SendMessagePayload,
+} from 'kozz-types';
+
+export const replyWithText = (
+	messagePayload: MessageReceivedByGateway,
+	string: string
+): SendMessagePayload => ({
+	body: string,
+	boundaryId: messagePayload.boundaryId,
+	chatId: messagePayload.to,
+	contact: messagePayload.contact,
+	platform: messagePayload.platform,
+	timestamp: new Date().getTime(),
+	quoteId: messagePayload.id,
+});
+
+export const replyWithSticker = (
+	messagePayload: MessageReceivedByGateway,
+	media: Media
+): SendMessagePayload => ({
+	body: '',
+	media: media,
+	chatId: messagePayload.to,
+	platform: 'WA',
+	timestamp: new Date().getTime(),
+	quoteId: messagePayload.id,
+	boundaryId: messagePayload.boundaryId,
+	contact: messagePayload.contact,
+});
+
+export const replyWithMedia = (
+	messagePayload: MessageReceivedByGateway,
+	media: Media,
+	caption?: string
+): SendMessagePayload => ({
+	body: caption || '',
+	media: media,
+	chatId: messagePayload.to,
+	platform: 'WA',
+	timestamp: new Date().getTime(),
+	quoteId: messagePayload.id,
+	boundaryId: messagePayload.boundaryId,
+	contact: messagePayload.contact,
+});
+
+export const replyWithMediaFromUrl = (
+	messagePayload: MessageReceivedByGateway,
+	media: Media,
+	caption?: string
+): SendMessagePayload => ({
+	body: caption || '',
+	media: media,
+	chatId: messagePayload.to,
+	platform: 'WA',
+	timestamp: new Date().getTime(),
+	quoteId: messagePayload.id,
+	boundaryId: messagePayload.boundaryId,
+	contact: messagePayload.contact,
+});

package/src/Message/PayloadCreation/index.ts

@@ -0,0 +1 @@
+export * from './Reply';

package/src/Message/PayloadCreation/sendMessage.ts

@@ -0,0 +1,27 @@
+import { Media, SendMessagePayload } from 'kozz-types';
+
+export const createSendMessagePayload = (
+	handlerName: string,
+	contactId: string,
+	boundaryId: string,
+	body: string,
+	media?: Media
+): SendMessagePayload => {
+	return {
+		body,
+		boundaryId: boundaryId,
+		chatId: contactId,
+		contact: {
+			publicName: handlerName,
+			privateName: handlerName,
+			id: handlerName,
+			isBlocked: false,
+			hostAdded: true,
+			isGroup: false,
+		},
+		platform: 'WA',
+		timestamp: new Date().getTime(),
+		quoteId: undefined,
+		media,
+	};
+};

package/src/Message/ProxiedMessage/index.ts

@@ -0,0 +1,27 @@
+import {
+	Command,
+	MessageReceived,
+	MessageReceivedByGateway,
+	Source,
+} from 'kozz-types';
+import { Socket } from 'socket.io-client';
+import { createMessageObject } from '..';
+import { revokeProxy } from '../../Socket/Events/Emit/RevokeProxy';
+
+export type ProxiedMessageObject = ReturnType<typeof createProxiedMessageOject>;
+
+export const createProxiedMessageOject = (
+	socket: Socket,
+	source: Source,
+	message: MessageReceivedByGateway,
+	handlerName: string
+) => {
+	const messageObject = createMessageObject(socket, message, handlerName);
+
+	const revoke = () => revokeProxy(socket, source);
+
+	return {
+		...messageObject,
+		revoke,
+	};
+};

package/src/Message/RoutineCreation/AskResource/AskResourceApi/index.ts

@@ -0,0 +1,43 @@
+import { Socket } from 'socket.io-client';
+import { AskResourcePayload, ProvideResourcePayload } from 'kozz-types';
+
+type RequestData = {
+	[key in keyof AskResourcePayload]: key extends 'request'
+		? Omit<AskResourcePayload[key], 'id'>
+		: AskResourcePayload[key];
+};
+
+/**
+ * Promisified interface for askin resource to other entities connected to the
+ * gateway
+ * @param socket
+ * @param requestData
+ * @returns {Promise<ProvideResourcePayload>}
+ */
+export const ask = async (
+	socket: Socket,
+	requestData: RequestData
+): Promise<ProvideResourcePayload> => {
+	const requestId: `${string}/${number}` = `${requestData.responder.id}/${
+		requestData.timestamp * 100 + Math.random() * 100
+	}`;
+
+	const requestPayload: AskResourcePayload = {
+		...requestData,
+		request: {
+			...requestData.request,
+			id: requestId,
+		},
+	};
+
+	socket.emit('ask_resource', requestPayload);
+
+	return new Promise(resolve => {
+		socket.once(
+			`reply_resource/${requestId}`,
+			(payload: ProvideResourcePayload) => {
+				resolve(payload);
+			}
+		);
+	});
+};

package/src/Message/RoutineCreation/AskResource/index.ts

@@ -0,0 +1,85 @@
+import { AskResourcePayload } from 'kozz-types/dist';
+import { Socket } from 'socket.io-client';
+import { ask as askResourceFn } from './AskResourceApi';
+
+type RequestResourceArgs = {
+	requester: AskResourcePayload['requester'];
+};
+
+type AskResourceArgs = {
+	resource: Omit<AskResourcePayload['request'], 'id'>;
+	responder: AskResourcePayload['responder'];
+};
+
+export const createAskResource = (
+	socket: Socket,
+	args: RequestResourceArgs
+) => {
+	const ask = async (askArgs: AskResourceArgs) => {
+		const response = await askResourceFn(socket, {
+			request: askArgs.resource,
+			responder: askArgs.responder,
+			requester: args.requester,
+			timestamp: new Date().getTime(),
+		});
+		return response;
+	};
+
+	ask.boundary = (
+		boundaryId: string,
+		resourceName: string,
+		requestArgs: AskResourceArgs['resource']['data'] = {}
+	) => {
+		return askResourceFn(socket, {
+			request: {
+				resource: resourceName,
+				data: requestArgs,
+			},
+			requester: args.requester,
+			timestamp: new Date().getTime(),
+			responder: {
+				id: boundaryId,
+				type: 'Boundary',
+			},
+		});
+	};
+
+	ask.handler = (
+		handlerId: string,
+		resourceName: string,
+		requestArgs: AskResourceArgs['resource']['data'] = {}
+	) => {
+		return askResourceFn(socket, {
+			request: {
+				resource: resourceName,
+				data: requestArgs,
+			},
+			requester: args.requester,
+			timestamp: new Date().getTime(),
+			responder: {
+				id: handlerId,
+				type: 'Handler',
+			},
+		});
+	};
+
+	ask.gateway = (
+		resourceName: string,
+		requestArgs: AskResourceArgs['resource']['data'] = {}
+	) => {
+		return askResourceFn(socket, {
+			request: {
+				resource: resourceName,
+				data: requestArgs,
+			},
+			requester: args.requester,
+			timestamp: new Date().getTime(),
+			responder: {
+				id: 'Gateway',
+				type: 'Gateway',
+			},
+		});
+	};
+
+	return ask;
+};

package/src/Message/RoutineCreation/Reply/WithMedia.ts

@@ -0,0 +1,63 @@
+import { Command, Media, MessageReceivedByGateway } from 'kozz-types/dist';
+import { Socket } from 'socket.io-client';
+import { replyWithMedia } from '../../../Message/PayloadCreation';
+import {
+	MimeType,
+	loadMediaFromPath,
+	createMediaFromBuffer,
+	createMediaFromB64,
+	createMediaFromUrl,
+} from '../../../Message/PayloadCreation/Media';
+
+export const withMedia = (
+	socket: Socket,
+	messagePayload: MessageReceivedByGateway
+) => {
+	/**
+	 * Replies with a media
+	 * @param {Media} media
+	 * @param {string} caption
+	 */
+	const replyMedia = (media: Media, caption?: string) => {
+		socket.emit(
+			'reply_with_media',
+			replyWithMedia(messagePayload, media, caption)
+		);
+	};
+
+	replyMedia.fromPath = async (
+		path: string,
+		mimeType: MimeType,
+		caption?: string
+	) => {
+		const media = await loadMediaFromPath(path, mimeType);
+		replyMedia(media, caption);
+	};
+
+	replyMedia.fromBuffer = (
+		buffer: Buffer,
+		mimeType: MimeType,
+		caption?: string,
+		fileName?: string
+	) => {
+		const media = createMediaFromBuffer(buffer, mimeType, fileName);
+		replyMedia(media, caption);
+	};
+
+	replyMedia.fromB64 = (
+		b64: string,
+		mimeType: MimeType,
+		caption?: string,
+		fileName?: string
+	) => {
+		const media = createMediaFromB64(b64, mimeType, fileName);
+		replyMedia(media, caption);
+	};
+
+	replyMedia.fromUrl = (url: string, mimeType: MimeType, caption?: string) => {
+		const media = createMediaFromUrl(url, mimeType);
+		replyMedia(media, caption);
+	};
+
+	return replyMedia;
+};

package/src/Message/RoutineCreation/Reply/WithSticker.ts

@@ -0,0 +1,9 @@
+import { Media, Command, MessageReceivedByGateway } from 'kozz-types/dist';
+import { Socket } from 'socket.io-client';
+import { replyWithSticker } from '../../PayloadCreation';
+
+export const withSticker =
+	(socket: Socket, messagePayload: MessageReceivedByGateway) =>
+	(media: Media) => {
+		socket.emit('reply_with_sticker', replyWithSticker(messagePayload, media));
+	};

package/src/Message/RoutineCreation/Reply/WithTemplate.ts

@@ -0,0 +1,28 @@
+import { Command, MessageReceivedByGateway } from 'kozz-types/dist';
+import { Socket } from 'socket.io-client';
+import { loadTemplates } from '../../../Message/FromTemplate';
+import { replyWithText } from '../../../Message/PayloadCreation';
+
+export const withTemplate =
+	(
+		socket: Socket,
+		messagePayload: MessageReceivedByGateway,
+		templatePath?: string
+	) =>
+	(templateName: string, templateData: Record<string, any> = {}) => {
+		if (!templatePath) {
+			throw 'Trying to reply with template but no template path was provided';
+		}
+
+		loadTemplates(templatePath)
+			.getTextFromTemplate(templateName, templateData)
+			.then(textResponse => {
+				if (!textResponse) {
+					throw `Error while trying to reply from template ${templateName}, could not find it's template in ${templatePath}`;
+				}
+				socket.emit(
+					'reply_with_text',
+					replyWithText(messagePayload, textResponse)
+				);
+			});
+	};

package/src/Message/RoutineCreation/Reply/index.ts

@@ -0,0 +1,3 @@
+export { withTemplate } from './WithTemplate';
+export { withSticker } from './WithSticker';
+export { withMedia } from './WithMedia';

package/src/Message/RoutineCreation/SendMessage/index.ts

@@ -0,0 +1,64 @@
+import { Command, Media, MessageReceivedByGateway } from 'kozz-types';
+import { Socket } from 'socket.io-client';
+import { createSendMessagePayload } from '../../../Message/PayloadCreation/sendMessage';
+
+export const sendMessageToContactOnRequesterObject = (
+	socket: Socket,
+	handlerName: string,
+	boundaryId: string
+) => {
+	const sendMessage = (contactId: string, body: string) => {
+		socket.emit(
+			'send_message',
+			createSendMessagePayload(handlerName, contactId, boundaryId, body)
+		);
+	};
+
+	sendMessage.withMedia = (
+		contactId: string,
+		caption: string,
+		media: Media
+	) => {
+		socket.emit(
+			'send_message',
+			createSendMessagePayload(
+				handlerName,
+				contactId,
+				boundaryId,
+				caption,
+				media
+			)
+		);
+	};
+
+	return sendMessage;
+};
+
+export const sendMessageToContact = (socket: Socket, handlerName: string) => {
+	const sendMessage = (contactId: string, boundaryId: string, body: string) => {
+		socket.emit(
+			'send_message',
+			createSendMessagePayload(handlerName, contactId, boundaryId, body)
+		);
+	};
+
+	sendMessage.withMedia = (
+		contactId: string,
+		boundaryId: string,
+		caption: string,
+		media: Media
+	) => {
+		socket.emit(
+			'send_message',
+			createSendMessagePayload(
+				handlerName,
+				contactId,
+				boundaryId,
+				caption,
+				media
+			)
+		);
+	};
+
+	return sendMessage;
+};

package/src/Message/RoutineCreation/reply.ts

@@ -0,0 +1,23 @@
+import { Command, MessageReceivedByGateway } from 'kozz-types';
+import { Socket } from 'socket.io-client';
+import { replyWithText } from '../PayloadCreation';
+
+import { withMedia } from './Reply/WithMedia';
+import { withSticker } from './Reply/WithSticker';
+import { withTemplate } from './Reply/WithTemplate';
+
+export const createReply = (
+	socket: Socket,
+	messagePayload: MessageReceivedByGateway,
+	templatePath?: string
+) => {
+	const reply = (text: string) => {
+		socket.emit('reply_with_text', replyWithText(messagePayload, text));
+	};
+
+	reply.withSticker = withSticker(socket, messagePayload);
+	reply.withTemplate = withTemplate(socket, messagePayload, templatePath);
+	reply.withMedia = withMedia(socket, messagePayload);
+
+	return reply;
+};

package/src/Message/index.ts

@@ -0,0 +1,44 @@
+import { Command, MessageReceivedByGateway } from 'kozz-types';
+import { Socket } from 'socket.io-client';
+import { createReply } from './RoutineCreation/reply';
+import { createAskResource } from './RoutineCreation/AskResource';
+import { sendMessageToContactOnRequesterObject } from './RoutineCreation/SendMessage';
+import { createReact } from './PayloadCreation/React';
+export * from './FromTemplate';
+
+export type MessageObj = ReturnType<typeof createMessageObject>;
+
+export const createMessageObject = (
+	socket: Socket,
+	messagePayload: MessageReceivedByGateway,
+	handlerId: string,
+	templatePath?: string,
+	command?: Command
+) => {
+	/**
+	 * Replies the requester of the command.
+	 */
+	const reply = createReply(socket, messagePayload, templatePath);
+	const sendMessage = sendMessageToContactOnRequesterObject(
+		socket,
+		handlerId,
+		messagePayload.from
+	);
+
+	const ask = createAskResource(socket, {
+		requester: {
+			id: handlerId,
+			type: 'Handler',
+		},
+	});
+	const react = createReact(socket, messagePayload);
+
+	return {
+		ask,
+		sendMessage,
+		react,
+		rawCommand: command,
+		message: messagePayload,
+		reply,
+	};
+};