kozz-module-maker 0.1.0 → 0.1.2

package/src/Message/PayloadCreation/Reply.ts

@@ -1,63 +0,0 @@
-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/sendMessage.ts

@@ -1,27 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/SendMessage/index.ts

@@ -1,64 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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,
-	};
-};

package/src/Message/kozz-md.parser/index.ts

@@ -1,138 +0,0 @@
-import * as A from 'arcsecond';
-
-// _________________
-// Utility functions
-// -----------------
-
-const anything = A.regex(/^.*/);
-
-const exceptChars = (chars: string) => new RegExp(`^[^${chars}\n]+`);
-
-const betweenStrings = <Ident extends string>(
-	stringLeft: string,
-	stringRight: string,
-	identifier: Ident
-) =>
-	A.sequenceOf([
-		A.str(stringLeft),
-		A.regex(exceptChars(stringRight)),
-		A.str(stringRight),
-	]).map(
-		x =>
-			({
-				style: identifier,
-				text: x[1],
-			} as const)
-	);
-
-type TemplateData = {
-	[key: string]: unknown;
-};
-
-let injectableData: TemplateData = {};
-
-// _________________
-// Parser itself ...
-// -----------------
-const paragraph = A.sequenceOf([A.str('#'), A.whitespace, anything]).map(
-	x =>
-		({
-			style: 'paragraph',
-			text: x[2],
-		} as const)
-);
-
-const italic = betweenStrings('_', '_', 'italic');
-const stroke = betweenStrings('~', '~', 'stroke');
-const bold = betweenStrings('**', '**', 'bold');
-const boldAndItalic = betweenStrings('**_', '_**', 'boldAndItalic');
-const code = betweenStrings('`', '`', 'code');
-const template = betweenStrings('{{', '}}', 'template').map(x => ({
-	...x,
-	text: `${injectableData[x.text]}`,
-}));
-
-const normalText = A.regex(exceptChars('`~_*{>')).map(
-	x =>
-		({
-			style: 'normal',
-			text: x,
-		} as const)
-);
-
-const listItem = A.sequenceOf([A.str('-'), A.whitespace, anything]).map(
-	x =>
-		({
-			style: 'listItem',
-			text: x[2],
-		} as const)
-);
-
-const lineBreak = A.str('<br>').map(
-	() =>
-		({
-			style: 'lineBreak',
-			text: '',
-		} as const)
-);
-
-const textLine = A.sequenceOf([
-	A.many(A.whitespace),
-	A.many1(
-		A.choice([
-			paragraph,
-			stroke,
-			listItem,
-			boldAndItalic,
-			bold,
-			italic,
-			code,
-			template,
-			lineBreak,
-			normalText,
-		])
-	),
-	A.many(A.str('\n')),
-]).map(x => ({
-	line: x[1],
-}));
-
-const messageDeclaration = A.sequenceOf([
-	A.str('>'),
-	A.whitespace,
-	A.str('@'),
-	anything,
-]).map(x => x[3]);
-
-const messageEnd = A.sequenceOf([
-	A.str('>'),
-	A.whitespace,
-	A.str('---'),
-	A.many(A.str('-')),
-	A.many(A.str('\n')),
-]);
-
-const message = A.sequenceOf([
-	A.many(A.str('\n')),
-	messageDeclaration,
-	A.many1(textLine),
-	A.many(A.str('\n')),
-	messageEnd,
-]).map(x => ({
-	messageName: x[1],
-	messageBody: x[2],
-}));
-
-const document = A.many(message);
-
-const parseDocument = (documentInString: string, data: TemplateData) => {
-	injectableData = data;
-	const result = document.run(documentInString);
-	if (result.isError) {
-		throw result.error;
-	} else {
-		return result;
-	}
-};
-
-export default parseDocument;