@taqueria/protocol 0.3.1 → 0.4.0-rc1

package/Alias.ts

@@ -0,0 +1,38 @@
+import createType from '@taqueria/protocol/Base';
+import * as SingleChar from '@taqueria/protocol/SingleChar';
+import * as Verb from '@taqueria/protocol/Verb';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.union([
+		Verb.rawSchema,
+		SingleChar.rawSchema,
+	], { description: 'Alias' });
+
+export const internalSchema = z
+	.union([
+		Verb.schemas.schema,
+		SingleChar.schemas.schema,
+	], { description: 'Alias' });
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = z.infer<typeof internalSchema>;
+
+const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	isStringLike: true,
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a valid alias`,
+	unknownErrMsg: 'Something went wrong trying to parse an alias',
+});
+
+export type Alias = z.infer<typeof generatedSchemas.schema>;
+
+export type t = Alias;
+
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Alias),
+};

package/Base.ts

@@ -0,0 +1,105 @@
+import { toFutureParseErr, toFutureParseUnknownErr } from '@taqueria/protocol/TaqError';
+import { FutureInstance, resolve } from 'fluture';
+import { z, ZodError, ZodSchema } from 'zod';
+
+type Future<L, R> = FutureInstance<L, R>;
+
+type ErrMsg = string | ((value: unknown) => string);
+
+interface CreateSchemaParams {
+	rawSchema: ZodSchema;
+	internalSchema?: ZodSchema;
+	transformer?: (value: unknown) => unknown;
+	isStringLike?: boolean;
+}
+
+interface CreateTypeParams extends CreateSchemaParams {
+	parseErrMsg: ErrMsg;
+	unknownErrMsg: ErrMsg;
+}
+export type Flatten<T> = { [k in keyof T]: T[k] };
+
+export const createSchema = <I>(params: CreateSchemaParams) => {
+	const { rawSchema, isStringLike } = params;
+	const internalSchema = params.internalSchema ?? params.rawSchema;
+	const noop = (val: unknown) => val;
+	const transformer = params.transformer ?? noop;
+
+	const schema = isStringLike
+		? internalSchema
+			.transform((val: unknown) =>
+				transformer(val) as I & {
+					readonly __kind: 'generated' & z.infer<typeof internalSchema>;
+				}
+			)
+		: internalSchema
+			.transform((val: unknown) =>
+				transformer(val) as Flatten<
+					I & {
+						readonly __kind: 'generated' & z.infer<typeof internalSchema>;
+					}
+				>
+			);
+
+	type GeneratedSchema = typeof schema;
+
+	return {
+		rawSchema,
+		internalSchema,
+		schema,
+	};
+};
+
+// TODO:
+// TypeScript appears to have a bug with default generic values
+// For instance, I'd like to use this:
+// export const createType = <R, I = R>(params: CreateTypeParams) => {
+//
+// However, I == unknown when having I default to R if no I was given.
+// So, we need to require R and I explicitly
+export const createType = <R, I>(params: CreateTypeParams) => {
+	const schemas = createSchema<I>(params);
+	const { parseErrMsg, unknownErrMsg } = params;
+
+	type T = z.infer<typeof schemas.schema>;
+
+	const internalOf = (input: unknown) => {
+		try {
+			return resolve<T>(schemas.schema.parse(input));
+		} catch (previous) {
+			const parseMsg = typeof parseErrMsg === 'string'
+				? parseErrMsg
+				: parseErrMsg(input);
+
+			const unknownMsg = typeof unknownErrMsg === 'string'
+				? unknownErrMsg
+				: unknownErrMsg(input);
+
+			if (previous instanceof ZodError) {
+				return toFutureParseErr<T>(previous, parseMsg, input);
+			}
+			return toFutureParseUnknownErr<T>(previous, unknownMsg, input);
+		}
+	};
+	const of = internalOf;
+
+	const make = (input: I) => internalOf(input);
+
+	const create = (input: R | I) => schemas.schema.parse(input) as T;
+
+	const from = (input: unknown) => schemas.schema.parse(input) as T;
+
+	const factory = {
+		make,
+		of,
+		create,
+		from,
+	};
+
+	return {
+		schemas,
+		factory,
+	};
+};
+
+export default createType;

package/Command.ts

@@ -0,0 +1,24 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.string({ description: 'Command' })
+	.min(1)
+	.regex(/^([A-Za-z-_ ]+ ?)((\[.+\] ?)|(\<.+\>) ?)*$/, 'Must be a command that can be interpreted using yargs');
+
+type RawInput = z.infer<typeof rawSchema>;
+
+const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	isStringLike: true,
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is an invalid command. Expected format is: taskName [optional] <required>`,
+	unknownErrMsg: 'Something went wrong when parsing the command',
+});
+
+export type Command = z.infer<typeof generatedSchemas.schema>;
+export type t = Command;
+export const { create, make, of } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Command),
+};

package/Config.ts

@@ -0,0 +1,155 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as Environment from '@taqueria/protocol/Environment';
+import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
+import * as NetworkConfig from '@taqueria/protocol/NetworkConfig';
+import * as SandboxConfig from '@taqueria/protocol/SandboxConfig';
+import * as Tz from '@taqueria/protocol/Tz';
+import { z } from 'zod';
+
+export const pluginsRawSchema = z.preprocess(
+	val => val ?? [],
+	z.array(
+		InstalledPlugin.rawSchema,
+		{ description: 'config.plugins' },
+	),
+);
+
+export const pluginsInternalSchema = z.preprocess(
+	val => val ?? [],
+	z.array(
+		InstalledPlugin.schemas.schema,
+		{ description: 'config.plugins' },
+	),
+);
+
+const networkMap = z
+	.record(
+		z.union([
+			NetworkConfig.schemas.schema,
+			z.string({ description: 'config.network' })
+				.nonempty('Default network must reference the name of an  existing network configuration.'),
+		]),
+		{ description: 'Network configurations' },
+	)
+	.optional();
+
+const sandboxMap = z
+	.record(
+		z.union([
+			SandboxConfig.schemas.schema,
+			z.string({ description: 'config.sandbox' })
+				.min(1, 'Default sandbox must reference the name of an existing sandbox configuration.'),
+		]),
+		{ description: 'Sandbox configurations' },
+	)
+	.optional();
+
+const environmentMap = z
+	.record(
+		z.union([
+			Environment.schemas.schema,
+			z.string().min(1, 'Default environment must reference the name of an existing environment.'),
+		]),
+		{ description: 'Environment configurations' },
+	)
+	.optional();
+
+const accountsMap = z.preprocess(
+	(val: unknown) =>
+		val ?? {
+			'bob': '5_000_000_000',
+			'alice': '5_000_000_000',
+			'john': '5_000_000_000',
+		},
+	z.record(
+		z.union([Tz.rawSchema, z.number()]),
+		{ description: 'config.accounts' },
+	),
+);
+
+const commonSchema = z.object({
+	language: z.preprocess(
+		val => val ?? 'en',
+		z.union([
+			z.literal('en'),
+			z.literal('fr'),
+		], { description: 'config.language' })
+			.optional(),
+	),
+	plugins: pluginsInternalSchema.optional(),
+	contractsDir: z
+		.preprocess(
+			(val: unknown) => val ?? 'contracts',
+			z.string({ description: 'config.contractsDir' })
+				.min(1, 'config.contractsDir must have a value'),
+		),
+	artifactsDir: z
+		.preprocess(
+			(val: unknown) => val ?? 'artifacts',
+			z.string({ description: 'config.artifactsDir' })
+				.min(1, 'config.artifactsDir must have a value'),
+		),
+}).describe('config');
+
+export const internalSchema = commonSchema.extend({
+	network: networkMap,
+	sandbox: sandboxMap,
+	environment: environmentMap,
+	accounts: accountsMap,
+});
+
+export const rawSchema = commonSchema.extend({
+	plugins: pluginsRawSchema.optional(),
+	network: z
+		.record(
+			z.union([
+				NetworkConfig.rawSchema,
+				z.string({ description: 'config.network' })
+					.min(1, 'Default network must reference the name of an  existing network configuration.'),
+			]),
+		)
+		.optional(),
+	sandbox: z
+		.record(
+			z.union([
+				SandboxConfig.rawSchema,
+				z.string({ description: 'config.sandbox' })
+					.min(1, 'Default sandbox must reference the name of an existing sandbox configuration.'),
+			]),
+		)
+		.optional(),
+	environment: z
+		.record(
+			z.union([
+				Environment.rawSchema,
+				z.string({ description: 'config.environment' })
+					.min(1, 'Default environment must reference the name of an existing environment.'),
+			]),
+		)
+		.optional(),
+	accounts: z
+		.record(
+			z.union([Tz.rawSchema, z.number()]),
+			{ description: 'config.accounts' },
+		)
+		.optional(),
+}).describe('config');
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a configuration`,
+	unknownErrMsg: 'Something went wrong trying to parse your configuration',
+});
+
+export const { create, of, make } = factory;
+export type Config = z.infer<typeof generatedSchemas.schema>;
+export type t = Config;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Config),
+};

package/Crypto.ts

@@ -0,0 +1,3 @@
+export class Crypto {
+	subtle: SubtleCrypto = crypto.subtle;
+}

package/EconomicalProtocolHash.ts

@@ -0,0 +1,26 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.string({ description: 'Protocol hash' })
+	.refine(
+		value => (value.length === 51 && value[0] === 'P' && /[A-Za-z0-9]+/.test(value)),
+		value => ({ message: `${value} is an invalid hash for an economical protocol` }),
+	);
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is an invalid economical protocol hash`,
+	unknownErrMsg: 'Somethign went wrong trying to parse the economical protocol hash',
+});
+
+export type EconomicalPrototypeHash = z.infer<typeof generatedSchemas.schema>;
+export type t = EconomicalPrototypeHash;
+
+export const { create, of, make } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as EconomicalPrototypeHash),
+};

package/Environment.ts

@@ -0,0 +1,36 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z.object({
+	networks: z.array(
+		z.string({ description: 'Environment network' })
+			.min(1, 'Must reference the name of an existing network configuration'),
+	),
+	sandboxes: z.array(
+		z.string({ description: 'Environment sandbox' })
+			.min(1, 'Must reference the name of an existing sandbox configuration'),
+	),
+	storage: z.record(
+		z.any({ description: 'Environment storage value' }),
+		{ description: 'Environment storage' },
+	)
+		.optional(),
+}).describe('Environment Config');
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is not an valid environment configuration`,
+	unknownErrMsg: 'Something went wrong trying to parse the environment configuration',
+});
+
+export type Environment = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type t = Environment;
+
+export const { create, make, of, from } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Environment),
+};

package/EphemeralState.ts

@@ -0,0 +1,208 @@
+import createType from '@taqueria/protocol/Base';
+import * as Command from '@taqueria/protocol/Command';
+import * as Config from '@taqueria/protocol/Config';
+import type { i18n } from '@taqueria/protocol/i18n';
+import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
+import * as Option from '@taqueria/protocol/Option';
+import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
+import * as ParsedPluginInfo from '@taqueria/protocol/ParsedPluginInfo';
+import { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';
+import * as Task from '@taqueria/protocol/Task';
+import * as Verb from '@taqueria/protocol/Verb';
+import { attemptP, FutureInstance as Future, mapRej, promise } from 'fluture';
+import { z } from 'zod';
+
+const eager = <T>(f: Future<TaqError, T>) =>
+	promise(
+		mapRej((err: TaqError) => new E_TaqError(err))(f),
+	);
+
+const taskToPluginMap = z.record(
+	z.union([
+		InstalledPlugin.schemas.schema,
+		Task.schemas.schema,
+	], { description: 'Task/Plugin Mapping' }),
+);
+const operationToPluginMap = z.record(
+	z.union([
+		InstalledPlugin.schemas.schema,
+		ParsedOperation.schemas.schema,
+	], { description: 'Operation/Plugin Mapping' }),
+);
+
+const rawSchema = z.object({
+	build: z.string({ description: 'cache.build' }),
+	configHash: z.string({ description: 'cache.configHash' }),
+	tasks: taskToPluginMap,
+	operations: operationToPluginMap,
+	plugins: z.array(ParsedPluginInfo.schemas.schema, { description: 'cache.plugins' }),
+}).describe('Ephemeral State');
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a valid representation of ephemeral state`,
+	unknownErrMsg: 'Something went wrong when parsing the ephemeral state',
+});
+
+export type EphemeralState = z.infer<typeof generatedSchemas.schema>;
+export type t = EphemeralState;
+export type TaskToPluginMap = z.infer<typeof taskToPluginMap>;
+export type OpToPluginMap = z.infer<typeof operationToPluginMap>;
+
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as EphemeralState),
+};
+
+/**
+ * Private functions
+ */
+type Counts = Record<Verb.t, ParsedPluginInfo.t[]>;
+const getTaskCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
+	return pluginInfo.reduce(
+		(retval, pluginInfo) =>
+			pluginInfo.tasks === undefined
+				? {}
+				: pluginInfo.tasks.reduce(
+					(retval: Counts, task: Task.t) => {
+						const taskName = task.task;
+						const providers: ParsedPluginInfo.t[] = retval[taskName]
+							? [...retval[taskName], pluginInfo]
+							: [pluginInfo];
+						const mapping: Counts = {};
+						mapping[taskName] = providers.filter(provider => provider !== undefined);
+						return { ...retval, ...mapping };
+					},
+					retval,
+				),
+		{} as Counts,
+	);
+};
+
+const getOperationCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
+	return pluginInfo.reduce(
+		(retval, pluginInfo) =>
+			pluginInfo.operations === undefined
+				? retval
+				: pluginInfo.operations.reduce(
+					(retval: Counts, operation: ParsedOperation.t) => {
+						const operationName = operation.operation;
+						const providers = retval[operationName]
+							? [...retval[operationName], pluginInfo]
+							: [pluginInfo];
+						const mapping: Counts = {};
+						mapping[operationName] = providers.filter(provider => provider !== undefined);
+						return { ...retval, ...mapping };
+					},
+					retval,
+				),
+		{} as Counts,
+	);
+};
+
+const toChoices = (plugins: ParsedPluginInfo.t[]) =>
+	plugins.reduce(
+		(retval, pluginInfo) => {
+			return [...retval, pluginInfo.name as string, pluginInfo.alias as string];
+		},
+		[] as string[],
+	);
+
+const isComposite = (name: Verb.t, counts: Counts) => counts[name].length > 1;
+
+const getInstalledPlugin = (config: Config.t, name: string) =>
+	config.plugins?.find(
+		(plugin: InstalledPlugin.t) => [`taqueria-plugin-${name}`, name].includes(plugin.name),
+	);
+
+export const mapTasksToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo.t[], i18n: i18n) => {
+	const taskCounts = getTaskCounts(pluginInfo);
+	return attemptP<TaqError, TaskToPluginMap>(async () =>
+		await pluginInfo.reduce(
+			async (retval, pluginInfo) =>
+				!pluginInfo.tasks
+					? Promise.resolve({} as TaskToPluginMap)
+					: await pluginInfo.tasks.reduce(
+						async (retval, { task }) => {
+							if (isComposite(task, taskCounts)) {
+								const command = await eager(Command.make(task));
+								const compositeTask = await eager(Task.make({
+									task,
+									command,
+									description: i18n.__('providedByMany'),
+									hidden: false,
+									options: [
+										await eager(Option.make({
+											flag: await eager(Verb.make('plugin')),
+											description: 'Specify which plugin should be used to execute this task',
+											choices: toChoices(taskCounts[task]),
+											required: true,
+										})),
+									],
+									handler: 'proxy',
+								}));
+								return { ...await retval, [task]: compositeTask };
+							}
+
+							// Task is provided by just a single plugin
+							const installedPlugin = getInstalledPlugin(config, pluginInfo.name);
+							return installedPlugin
+								? { ...await retval, [task]: installedPlugin }
+								: retval;
+						},
+						retval,
+					),
+			Promise.resolve({} as TaskToPluginMap),
+		)
+	).pipe(mapRej(rej => rej as TaqError));
+};
+
+export const mapOperationsToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo.t[], i18n: i18n) => {
+	const opCounts = getOperationCounts(pluginInfo);
+	return attemptP(async () =>
+		await pluginInfo.reduce(
+			async (retval, pluginInfo) =>
+				!pluginInfo.operations
+					? Promise.resolve({} as OpToPluginMap)
+					: await pluginInfo.operations.reduce(
+						async (retval, { operation }) => {
+							if (isComposite(operation, opCounts)) {
+								const command = await eager(Command.make(operation));
+								const compositeOp = await eager(ParsedOperation.make({
+									operation,
+									command,
+									description: i18n.__('providedByMany'),
+									options: [
+										await eager(Option.make({
+											flag: await eager(Verb.make('plugin')),
+											description: 'Specify which plugin should be used to execute this operation',
+											choices: toChoices(opCounts[operation]),
+											required: true,
+										})),
+									],
+								}));
+								return { ...await retval, [operation]: compositeOp };
+							}
+
+							// Operation is provided by just a single plugin
+							const installedPlugin = getInstalledPlugin(config, pluginInfo.name);
+							return installedPlugin
+								? { ...await retval, [operation]: installedPlugin }
+								: retval;
+						},
+						retval,
+					),
+			Promise.resolve({} as OpToPluginMap),
+		)
+	).pipe(mapRej(rej => rej as TaqError));
+};
+
+export const getTasks = (pluginInfo: ParsedPluginInfo.t[]) =>
+	pluginInfo.reduce(
+		(retval: Task.t[], pluginInfo) => [...retval, ...(pluginInfo.tasks ?? [])],
+		[],
+	);

package/Faucet.ts

@@ -0,0 +1,46 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';
+import { z } from 'zod';
+
+export const rawSchema = z.object({
+	pkh: z.string({ description: 'Faucet Public Key Hash' }).min(1),
+	mnemonic: z.array(
+		z.string({ description: 'Faucet Mnemonic Word' }).min(1),
+		{ description: 'Faucet Mnemonic' },
+	),
+	email: z.string({ description: 'Faucet E-mail' }).regex(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/),
+	password: z.string({ description: 'Faucet Password' }).min(1),
+	amount: z.string({ description: 'Faucet Account' }).min(1).regex(/^\d+$/),
+	activation_code: z.string({ description: 'Faucet Activation Code' }).min(1),
+}).describe('Faucet');
+
+const internalSchema = z.object({
+	pkh: PublicKeyHash.schemas.schema,
+	mnemonic: z.array(
+		z.string({ description: 'Faucet Mnemonic Word' }).nonempty().regex(/^[a-z]{2,}$/),
+		{ description: 'Faucet Mnemonic' },
+	),
+	email: z.string({ description: 'Faucet E-mail' }).regex(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/),
+	password: z.string({ description: 'Faucet Password' }).nonempty(),
+	amount: z.string({ description: 'Faucet Account' }).nonempty().regex(/^\d+$/),
+	activation_code: z.string({ description: 'Faucet Activation Code' }).nonempty(),
+}).describe('Faucet');
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a valid faucet configuration`,
+	unknownErrMsg: 'Something went wrong trying to parse the faucet',
+});
+
+export type Faucet = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type t = Faucet;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Faucet),
+};

package/HumanReadableIdentifier.ts

@@ -0,0 +1,24 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.string({ description: 'Human Readable Identifier' })
+	.regex(/^[A-Za-z]+[A-Za-z0-9-_ ]*$/, 'Must be a valid human-readable identifier');
+
+type RawInput = z.infer<typeof rawSchema>;
+
+const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	isStringLike: true,
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a valid human-readable identifier`,
+	unknownErrMsg: 'Something went wrong trying to parse the human readable identifier',
+});
+
+export type HumanReadableIdentifier = z.infer<typeof generatedSchemas.schema>;
+export type t = HumanReadableIdentifier;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as HumanReadableIdentifier),
+};