kozz-module-maker 0.1.0

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { ProxyRevokePayload, Source } from 'kozz-types';
+import { Socket } from 'socket.io-client';
+
+/**
+ * Request the revoking of a proxy
+ * @param socket
+ * @param source
+ */
+export const revokeProxy = (socket: Socket, source: Source) => {
+	const payload: ProxyRevokePayload = {
+		source: source,
+	};
+
+	socket.emit('revoke_proxy', payload);
+};

package/src/Socket/Events/Handle/AskResource.ts

@@ -0,0 +1,37 @@
+import { Socket } from 'socket.io-client';
+import { ResourceMap } from '../../../Instance/Common/ResourceMap';
+import { AskResourcePayload, ProvideResourcePayload } from 'kozz-types/dist';
+
+/**
+ * Provide the resource asked
+ * @param socket
+ * @param resourceMap
+ */
+export const onAskResource = (socket: Socket, resourceMap: ResourceMap) => {
+	socket.on('ask_resource', (payload: AskResourcePayload) => {
+		const resourceGetter = resourceMap[payload.request.resource];
+		if (!resourceGetter)
+			return socket.emit('reply_resource', {
+				...payload,
+			});
+
+		promisify(resourceGetter(payload.request.data)).then(resource => {
+			const responsePayload: ProvideResourcePayload = {
+				...payload,
+				response: resource,
+			};
+
+			socket.emit('reply_resource', responsePayload);
+		});
+	});
+};
+
+const promisify = (resource: unknown) => {
+	return new Promise(resolve => {
+		if (resource instanceof Promise) {
+			resource.then(resp => resolve(resp));
+		} else {
+			resolve(resource);
+		}
+	});
+};

package/src/Socket/Events/Handle/Command.ts

@@ -0,0 +1,68 @@
+import { Socket } from 'socket.io-client';
+import { Command } from 'kozz-types';
+import { Method } from '../../..';
+import { createMessageObject } from '../../../Message';
+import { isArgsObjectValid } from '../../../Validator';
+import { normalizeString, runUse } from '../../../util';
+import { UseFn } from 'src/Instance/Common';
+
+/**
+ * Handles the command received. It will check if the boundary should have it's command handled,
+ * find the correct method, parse, typecheck the args, run the middlewares and try to run the method
+ * @param socket
+ * @param methods
+ * @param moduleUseFns
+ * @param handlerName
+ * @param templatePath
+ * @param boundariesToHandle
+ */
+export const onCommand = <
+	T extends Record<string, Method<Record<string, any>>>
+>(
+	socket: Socket,
+	methods: T,
+	moduleUseFns: UseFn[],
+	handlerName: string,
+	templatePath: string,
+	boundariesToHandle: string[]
+) => {
+	socket.on('command', (command: Command) => {
+		// If the handler doesnt want to handle commands for the provided boundary
+		if (
+			!boundariesToHandle.includes(command.boundaryName) &&
+			!boundariesToHandle.includes('*')
+		) {
+			return;
+		}
+
+		const actualMethod =
+			methods[normalizeString(normalizeString(command.method))] ||
+			methods['fallback'];
+		if (!actualMethod) return;
+
+		if (isArgsObjectValid(command.namedArgs || {}, actualMethod.args)) {
+			const updatedCommand = runUse(moduleUseFns, command);
+
+			const message = createMessageObject(
+				socket,
+				command.message,
+				handlerName,
+				templatePath
+			);
+
+			socket.emit('react_message', {
+				messageId: command.message.id,
+				boundaryId: command.boundaryId,
+				emote: '✔',
+			});
+
+			actualMethod.func(message, updatedCommand.namedArgs || {});
+		} else {
+			socket.emit('react_message', {
+				messageId: command.message.id,
+				boundaryId: command.boundaryId,
+				emote: '❌',
+			});
+		}
+	});
+};

package/src/Socket/Events/Handle/ProxiedMessage.ts

@@ -0,0 +1,28 @@
+import { Source } from 'kozz-types';
+import { Socket } from 'socket.io-client';
+import {
+	ProxiedMessageObject,
+	createProxiedMessageOject,
+} from 'src/Message/ProxiedMessage';
+
+/**
+ * Handles the message proxied to the handler
+ * @param socket
+ * @param source
+ * @param cb
+ */
+export const onProxiedMessage = (
+	socket: Socket,
+	source: Source,
+	cb: (message: ProxiedMessageObject) => any
+) => {
+	socket.on('proxied_message', payload => {
+		const proxiedMessageObject = createProxiedMessageOject(
+			socket,
+			source,
+			payload,
+			source.split('/')[0]
+		);
+		cb(proxiedMessageObject);
+	});
+};

package/src/Socket/index.ts

@@ -0,0 +1,40 @@
+import { io } from 'socket.io-client';
+import { introduce } from './Events/Emit/Introduction';
+import { Method } from '../Schema';
+import { UseFn } from '../Instance/Common';
+import { onCommand } from './Events/Handle/Command';
+
+export const connect = <T extends Record<string, any>>(
+	address: string,
+	moduleUseFns: UseFn[],
+	templatePath: string,
+	handlerName: string,
+	methods: T,
+	boundariesToHandle: string[],
+	signature?: string
+) => {
+	const socket = io(address);
+
+	socket.on('connect', () => {
+		introduce(socket, handlerName, methods, signature);
+	});
+
+	const registerMethods = <
+		T extends Record<string, Method<Record<string, any>>>
+	>(
+		methods: T
+	) =>
+		onCommand(
+			socket,
+			methods,
+			moduleUseFns,
+			handlerName,
+			templatePath,
+			boundariesToHandle
+		);
+
+	return {
+		socket,
+		registerMethods,
+	};
+};

package/src/Validator/index.ts

@@ -0,0 +1,81 @@
+import {
+	ArrayTypeString,
+	OptionalTypeString,
+	PrimaryTypeString,
+	TypeString,
+} from '../Schema';
+
+type TypeDescriptor<T extends TypeString> = {
+	array: T extends ArrayTypeString ? true : false;
+	optional: T extends OptionalTypeString ? true : false;
+	type: T extends PrimaryTypeString
+		? T
+		: T extends `${infer Type}[]?`
+		? Type
+		: T extends `${infer Type}?`
+		? Type
+		: T extends `${infer Type}[]`
+		? Type
+		: never;
+};
+
+const typeIsArray = (type: TypeString): type is ArrayTypeString => {
+	return type.includes('[]');
+};
+
+const typeIsOptional = (type: TypeString): type is OptionalTypeString => {
+	return type.includes('?');
+};
+
+const toPrimitiveType = (type: TypeString): PrimaryTypeString => {
+	if (type.includes('boolean')) {
+		return 'boolean';
+	}
+	if (type.includes('number')) {
+		return 'number';
+	}
+	return 'string';
+};
+
+export const describeType = <Type extends TypeString>(type: Type) =>
+	({
+		array: typeIsArray(type),
+		optional: typeIsOptional(type),
+		type: toPrimitiveType(type),
+	} as TypeDescriptor<Type>);
+
+export const isArgValid = <Type extends TypeString>(
+	arg: unknown,
+	typeDescriptor: TypeDescriptor<Type>
+) => {
+	if (arg === undefined && typeDescriptor.optional) {
+		return true;
+	}
+	if (Array.isArray(arg) !== typeDescriptor.array) {
+		return false;
+	}
+	if (Array.isArray(arg) && typeDescriptor.array && arg.length === 0) {
+		return true;
+	}
+	if (Array.isArray(arg) && typeDescriptor.array && arg.length > 0) {
+		return arg.reduce((valid, arg) => {
+			return valid && typeof arg === typeDescriptor.type;
+		}, true);
+	}
+	return typeof arg === typeDescriptor.type;
+};
+
+/**
+ * Check ifm the arguments of a provided command are valid
+ * @param args
+ * @param descriptionMap
+ * @returns
+ */
+export const isArgsObjectValid = <Type extends TypeString>(
+	args: Record<string, unknown>,
+	descriptionMap: Record<string, Type> = {}
+) => {
+	return Object.entries(descriptionMap).reduce((valid, [argName, argType]) => {
+		return valid && isArgValid(args[argName], describeType(argType));
+	}, true);
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './Instance/GeneralModule';
+export * from './Schema';

package/src/messages.kozz.md

@@ -0,0 +1,52 @@
+> @foo
+
+# This is the foo message
+
+The foo message says "Hi" to {{name}}
+
+_Nice to meet you!_
+
+> ---
+
+> @bar
+
+# This is the bar message
+
+The foo message says "GoodBye" to {{name}}
+
+_See you soon!_
+
+> ---
+
+> @list
+
+# This is the header. It can't interpolate variables.
+
+# This is a list. The items can't interpolate variables or styles yet.
+
+- item 1
+- item 2
+- item 3
+  <br>
+
+# This is a table:
+
+`| Command       | Bot's Response                   |`
+`| ------------- | -------------------------------- |`
+`| !ping         | pong!                            |`
+`| !ping default | pong!                            |`
+`| !ping blah    | Ooops, this method doesn't exist |`
+<br>
+
+_Note:_ Be careful not to make wide tables, most chat's will automatically break lines that become too long.
+<br>
+
+Text _*bold*_ _italic_ and `monospace` can appear in the same line, but you can't mix and match them
+In order to skip a line, use a line with nothing but `"<br>"`
+<br>
+<br>
+<br>
+
+Messages start with `"> @messageName"` and end with `"> ---"`
+
+> ---