@taqueria/protocol 0.16.0 → 0.19.2

package/Config.ts

@@ -1,163 +0,0 @@
-import createType, { Flatten } from '@taqueria/protocol/Base';
-import * as Contract from '@taqueria/protocol/Contract';
-import * as Environment from '@taqueria/protocol/Environment';
-import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
-import * as MetadataConfig from '@taqueria/protocol/MetadataConfig';
-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'),
-		),
-	contracts: z.record(
-		Contract.rawSchema,
-	).optional(),
-}).describe('config');
-
-export const internalSchema = commonSchema.extend({
-	network: networkMap,
-	sandbox: sandboxMap,
-	environment: environmentMap,
-	accounts: accountsMap,
-	contracts: z.record(Contract.schemas.schema).optional(),
-	metadata: MetadataConfig.schemas.schema.optional(),
-});
-
-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(),
-	metadata: MetadataConfig.rawSchema.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/Contract.ts

@@ -1,35 +0,0 @@
-import createType, { Flatten } from '@taqueria/protocol/Base';
-import * as SHA256 from '@taqueria/protocol/SHA256';
-import { z } from 'zod';
-
-export const rawSchema = z.object({
-	sourceFile: z.string().min(1),
-	hash: SHA256.rawSchema,
-	// TODO: Should plugin also be provided here?
-});
-
-export const internalSchema = z.object({
-	sourceFile: z.string().min(1),
-	hash: SHA256.schemas.schema,
-});
-
-type RawInput = z.infer<typeof rawSchema>;
-type Input = z.infer<typeof internalSchema>;
-
-const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
-	rawSchema,
-	internalSchema,
-	parseErrMsg: (value: unknown) => `${value} is not a valid contract`,
-	unknownErrMsg: 'Something went wrong trying to parse a contract',
-});
-
-export type Contract = z.infer<typeof internalSchema>;
-
-export type t = Contract;
-
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Contract),
-};

package/Crypto.ts

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

package/EconomicalProtocolHash.ts

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

@@ -1,40 +0,0 @@
-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(),
-	aliases: z.record(
-		z.any({ description: 'Environment address alias' }),
-		{ description: 'Environment alias' },
-	).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

@@ -1,282 +0,0 @@
-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 ParsedTemplate from '@taqueria/protocol/ParsedTemplate';
-import * as PluginInfo from '@taqueria/protocol/PluginInfo';
-import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
-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 templateToPluginMap = z.record(
-	z.union([
-		InstalledPlugin.schemas.schema,
-		ParsedTemplate.schemas.schema,
-	]),
-);
-
-const rawSchema = z.object({
-	build: z.string({ description: 'cache.build' }),
-	configHash: z.string({ description: 'cache.configHash' }),
-	tasks: taskToPluginMap,
-	operations: operationToPluginMap,
-	templates: templateToPluginMap,
-	plugins: z.array(PluginInfo.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 type TemplateToPluginMap = z.infer<typeof templateToPluginMap>;
-
-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, PluginInfo.t[]>;
-const getTaskCounts = (pluginInfo: PluginInfo.t[]): Counts => {
-	return pluginInfo.reduce(
-		(retval, pluginInfo) =>
-			pluginInfo.tasks === undefined
-				? {}
-				: pluginInfo.tasks.reduce(
-					(retval: Counts, task: Task.t) => {
-						const taskName = task.task;
-						const providers: PluginInfo.t[] = retval[taskName]
-							? [...retval[taskName], pluginInfo]
-							: [pluginInfo];
-						const mapping: Counts = {};
-						mapping[taskName] = providers.filter(provider => provider !== undefined);
-						return { ...retval, ...mapping };
-					},
-					retval,
-				),
-		{} as Counts,
-	);
-};
-
-const getTemplateCounts = (pluginInfo: PluginInfo.t[]): Counts => {
-	return pluginInfo.reduce(
-		(retval, pluginInfo) =>
-			!pluginInfo.templates
-				? retval
-				: pluginInfo.templates.reduce(
-					(retval: Counts, template: ParsedTemplate.t) => {
-						const templateName = template.template;
-						const providers = retval[templateName]
-							? [...retval[templateName], pluginInfo]
-							: [pluginInfo];
-						const mapping: Counts = {};
-						mapping[templateName] = providers.filter(provider => provider !== undefined);
-						return { ...retval, ...mapping };
-					},
-					retval,
-				),
-		{} as Counts,
-	);
-};
-
-const getOperationCounts = (pluginInfo: PluginInfo.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: PluginInfo.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] && 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: PluginInfo.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: PluginInfo.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 mapTemplatesToPlugins = (config: Config.t, pluginInfo: PluginInfo.t[], i18n: i18n) => {
-	const tmplCounts = getTemplateCounts(pluginInfo);
-	return attemptP<TaqError, TemplateToPluginMap>(async () =>
-		await pluginInfo.reduce(
-			async (retval, pluginInfo) =>
-				!pluginInfo.templates
-					? Promise.resolve({} as TemplateToPluginMap)
-					: await pluginInfo.templates!.reduce(
-						async (retval, { template }) => {
-							if (isComposite(template, tmplCounts)) {
-								const command = await eager(Command.make(template));
-								const compositeTmpl = await eager(ParsedTemplate.make({
-									template,
-									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 task',
-											choices: toChoices(tmplCounts[template]),
-											required: true,
-										})),
-									],
-									handler: 'proxy',
-									encoding: PluginResponseEncoding.create('none'),
-								}));
-								return { ...await retval, [template]: compositeTmpl };
-							}
-
-							// Template is provided by just a single plugin
-							const installedPlugin = getInstalledPlugin(config, pluginInfo.name);
-							return installedPlugin
-								? { ...await retval, [template]: installedPlugin }
-								: retval;
-						},
-						retval,
-					),
-			Promise.resolve({} as TemplateToPluginMap),
-		)
-	).pipe(mapRej(rej => rej as TaqError));
-};
-
-export const getTasks = (pluginInfo: PluginInfo.t[]) =>
-	pluginInfo.reduce(
-		(retval: Task.t[], pluginInfo) => [...retval, ...(pluginInfo.tasks ?? [])],
-		[],
-	);

package/Faucet.ts

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

@@ -1,26 +0,0 @@
-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 const internalSchema = generatedSchemas.schema;
-
-export type HumanReadableIdentifier = z.infer<typeof internalSchema>;
-export type t = HumanReadableIdentifier;
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as HumanReadableIdentifier),
-};

package/InstalledPlugin.ts

@@ -1,28 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z.object({
-	name: z.string({ description: 'Plugin Name' }).min(1),
-	type: z.union(
-		[z.literal('npm'), z.literal('binary'), z.literal('deno')],
-		{ description: 'Plugin Type' },
-	),
-}).describe('InstalledPlugin');
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is not a valid installed plugin`,
-	unknownErrMsg: 'Something went wrong when parsing the installed plugin',
-});
-
-export type InstalledPlugin = z.infer<typeof generatedSchemas.schema>;
-export type t = InstalledPlugin;
-
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as InstalledPlugin),
-};