kozz-module-maker 0.1.1 → 0.1.3

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;

package/src/Schema/index.ts

@@ -1,102 +0,0 @@
-import { MessageObj } from '../Message';
-
-export type PrimaryTypeString = 'string' | 'number' | 'boolean';
-export type ArrayTypeString =
-	| `${PrimaryTypeString}[]`
-	| `${PrimaryTypeString}[]?`;
-
-export type OptionalTypeString =
-	| `${ArrayTypeString}?`
-	| `${PrimaryTypeString}?`;
-
-export type TypeString =
-	| PrimaryTypeString
-	| ArrayTypeString
-	| OptionalTypeString;
-
-export type StringTypeVariants =
-	| 'string'
-	| 'string[]'
-	| 'string[]?'
-	| 'string?';
-
-export type NumberTypeVariants =
-	| 'number'
-	| 'number[]'
-	| 'number[]?'
-	| 'number?';
-
-export type BooleanTypeVariants =
-	| 'boolean'
-	| 'boolean[]'
-	| 'boolean[]?'
-	| 'boolean?';
-
-type ToPrimary<T extends TypeString> = T extends StringTypeVariants
-	? string
-	: T extends NumberTypeVariants
-	? number
-	: T extends BooleanTypeVariants
-	? boolean
-	: never;
-
-type ToArray<T extends ArrayTypeString> = T extends ArrayTypeString
-	? ToPrimary<T>[]
-	: ToPrimary<T>;
-
-type ToOptional<T extends OptionalTypeString> = T extends ArrayTypeString
-	? ToArray<T> | undefined
-	: T extends OptionalTypeString
-	? ToPrimary<T> | undefined
-	: T extends PrimaryTypeString
-	? ToPrimary<T>
-	: never;
-
-type TypeFromString<T extends TypeString> = T extends OptionalTypeString
-	? ToOptional<T>
-	: T extends ArrayTypeString
-	? ToArray<T>
-	: T extends PrimaryTypeString
-	? ToPrimary<T>
-	: never;
-
-export type MethodCreator = <
-	const T extends { [key: string]: TypeString },
-	const Name extends string
->(
-	name: Name,
-	callback: (
-		requester: MessageObj,
-		args: { [key in keyof T]: TypeFromString<T[key]> }
-	) => any,
-	args?: T
-) => MethodMap<Name, T>;
-
-/**
- * Creates a command that can be inserted in any command Handler
- * @param name
- * @param callback
- * @param args
- * @returns
- */
-//@ts-ignore
-export const createMethod: MethodCreator = (name, callback, args = {}) => {
-	return {
-		[name]: {
-			args,
-			func: callback,
-		} as const,
-	};
-};
-
-export type Method<T extends { [key: string]: TypeString }> = {
-	readonly args: T;
-	readonly func: (message: MessageObj, args: any) => any;
-};
-
-export type MethodMap<
-	Name extends string,
-	T extends { [key: string]: TypeString }
-> = {
-	[key in `${Name}`]: Method<T>;
-};

package/src/Socket/Events/Emit/ForwardEvent.ts

@@ -1,22 +0,0 @@
-import { ForwardEventPayload } from 'kozz-types';
-import { Socket } from 'socket.io-client';
-
-type EventCallback = (payload: any) => any;
-
-export const listenBoundary =
-	(gatewaySocket: Socket, instanceName: string) => (boundaryId: string) => {
-		return {
-			when: (eventName: string, callback: EventCallback) => {
-				const payload: ForwardEventPayload = {
-					destination: {
-						id: instanceName,
-						type: 'Handler',
-					},
-					eventName,
-					sourceId: boundaryId,
-				};
-				gatewaySocket.emit('event_forward_request', payload);
-				gatewaySocket.on(eventName, callback);
-			},
-		};
-	};

package/src/Socket/Events/Emit/Introduction.ts

@@ -1,28 +0,0 @@
-import { HandlerIntroduction, SignaturelessPayload } from 'kozz-types/dist';
-import { Socket } from 'socket.io-client';
-import { Method, TypeString } from '../../../Schema';
-import { signPayload } from 'src/util';
-
-/**
- * Emits the introduction payload to the gateway
- * @param socket
- * @param handlerName
- * @param methods
- * @param signature
- */
-export const introduce = <
-	T extends Record<string, Method<Record<string, TypeString>>>
->(
-	socket: Socket,
-	handlerName: string,
-	methods: T,
-	signature?: string
-) => {
-	const payload: SignaturelessPayload<HandlerIntroduction> = {
-		methods: Object.keys(methods),
-		name: handlerName,
-		role: 'handler',
-	};
-
-	socket.emit('introduction', signPayload(payload, signature));
-};

package/src/Socket/Events/Emit/RequestProxy.ts

@@ -1,38 +0,0 @@
-import { ProxyRequestPayload, Source } from 'kozz-types';
-import { Socket } from 'socket.io-client';
-import { onProxiedMessage } from '../Handle/ProxiedMessage';
-import { ProxiedMessageObject } from 'src/Message/ProxiedMessage';
-
-export type ProxyInitParams = {
-	address: string;
-	source: Source;
-	name: string;
-	destinationOverride?: string;
-	signature?: string;
-	onMessage: (message: ProxiedMessageObject) => any;
-	keepProxyAlive?: boolean;
-};
-
-const createProxyRequestPayload = (
-	proxyInitParams: ProxyInitParams
-): ProxyRequestPayload => {
-	return {
-		source: proxyInitParams.source,
-		keepAlive: proxyInitParams.keepProxyAlive,
-		destination: proxyInitParams.destinationOverride || proxyInitParams.name,
-	};
-};
-
-/**
- * Request proxy for a given
- * @param socket
- * @param proxyInitParams
- */
-export const requestProxy = (
-	socket: Socket,
-	proxyInitParams: ProxyInitParams
-) => {
-	onProxiedMessage(socket, proxyInitParams.source, proxyInitParams.onMessage);
-
-	socket.emit('request_proxy', createProxyRequestPayload(proxyInitParams));
-};