@taqueria/protocol 0.0.0-pr-902-45108945 → 0.0.0-pr-899-ca79db85

package/EphemeralState.ts

@@ -4,6 +4,7 @@ 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';
@@ -22,11 +23,18 @@ const taskToPluginMap = z.record(
 		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');
 
@@ -41,6 +49,7 @@ export const { schemas: generatedSchemas, factory } = createType<RawInput, RawIn
 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;
 
@@ -74,6 +83,27 @@ const getTaskCounts = (pluginInfo: ParsedPluginInfo.t[]): 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) => {
@@ -111,7 +141,6 @@ export const mapTasksToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo
 											description: 'Specify which plugin should be used to execute this task',
 											choices: toChoices(taskCounts[task]),
 											required: true,
-											type: 'string',
 										})),
 									],
 									handler: 'proxy',
@@ -132,6 +161,46 @@ export const mapTasksToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo
 	).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/Operation.ts

@@ -0,0 +1,70 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as Command from '@taqueria/protocol/Command';
+import * as Option from '@taqueria/protocol/Option';
+import * as PersistentState from '@taqueria/protocol/PersistentState';
+import * as PositionalArg from '@taqueria/protocol/PositionalArg';
+import * as RequestArgs from '@taqueria/protocol/RequestArgs';
+import * as Verb from '@taqueria/protocol/Verb';
+import { z } from 'zod';
+
+type Handler = (state: PersistentState.t) => <T extends RequestArgs.t>(opts: T) => unknown;
+
+export const rawSchema = z.object({
+	operation: Verb.rawSchema.describe('Operation Name'),
+	command: Command.rawSchema.describe('Operation Command'),
+	description: z.string({ description: 'Operation Description' }).optional(),
+	positionals: z.array(PositionalArg.rawSchema).default([]).describe('Operation Positional Args').optional(),
+	options: z.preprocess(
+		(val: unknown) => val ?? [],
+		z.array(
+			Option.rawSchema.describe('Operation Option'),
+			{ description: 'Operation Options' },
+		).optional(),
+	),
+	handler: z.function()
+		.args(PersistentState.rawSchema)
+		.returns(
+			z.function()
+				.args(RequestArgs.schemas.internalSchema),
+		)
+		.describe('Operation Handler')
+		.transform((val: unknown) => val as Handler),
+}).describe('Operation');
+
+export const internalSchema = z.object({
+	operation: Verb.schemas.schema.describe('Operation Name'),
+	command: Command.schemas.schema.describe('Operation Command'),
+	description: z.string({ description: 'Optionation Description' }).optional(),
+	positionals: z.array(PositionalArg.schemas.schema).default([]).describe('Operation Positional Args').optional(),
+	options: z.preprocess(
+		(val: unknown) => val ?? [] as Option.t[],
+		z.array(Option.schemas.schema.describe('Operation Option'), { description: 'Operation Options' }).optional(),
+	),
+	handler: z.function()
+		.args(PersistentState.rawSchema)
+		.returns(
+			z.function()
+				.args(RequestArgs.schemas.schema),
+		)
+		.describe('Operation Handler')
+		.transform((val: unknown) => val as Handler),
+}).describe('Operation');
+
+type Input = Flatten<z.infer<typeof internalSchema>>;
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `The following operation is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the operation',
+});
+
+export type Operation = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type t = Operation;
+export const { make, of, create } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Operation),
+};

package/Option.ts

@@ -16,10 +16,7 @@ export const internalSchema = z.object({
 		{ description: 'Option Choices' },
 	).optional(),
 	required: z.boolean({ description: 'Option Is Required' }).default(false).optional(),
-	type: z.union(
-		[z.literal('string'), z.literal('number'), z.literal('boolean')],
-		{ description: 'Positional Arg Datatype' },
-	),
+	boolean: z.boolean({ description: 'Option Is Boolean' }).default(false).optional(),
 }).describe('Option');
 
 export const rawSchema = z.object({
@@ -35,10 +32,7 @@ export const rawSchema = z.object({
 		{ description: 'Option Choices' },
 	).optional(),
 	required: z.boolean({ description: 'Option Is Required' }).default(false).optional(),
-	type: z.union(
-		[z.literal('string'), z.literal('number'), z.literal('boolean')],
-		{ description: 'Positional Arg Datatype' },
-	),
+	boolean: z.boolean({ description: 'Option Is Boolean' }).default(false).optional(),
 }).describe('Option');
 
 type RawInput = z.infer<typeof rawSchema>;

package/ParsedOperation.ts

@@ -0,0 +1,33 @@
+import createType from '@taqueria/protocol/Base';
+import * as Operation from '@taqueria/protocol/Operation';
+import { z } from 'zod';
+
+const internalSchema = Operation
+	.internalSchema
+	.describe('ParsedOperation')
+	.omit({ handler: true });
+
+export const rawSchema = Operation
+	.rawSchema
+	.omit({ handler: true })
+	.describe('ParsedOperation');
+
+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) => `Could not parse the following operation: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse an operation',
+});
+
+export type ParsedOperation = z.infer<typeof generatedSchemas.schema>;
+export type t = ParsedOperation;
+
+export const { create, make, of } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as ParsedOperation),
+};

package/ParsedPluginInfo.ts

@@ -1,10 +1,29 @@
 import createType from '@taqueria/protocol/Base';
+import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
 import * as PluginInfo from '@taqueria/protocol/PluginInfo';
 import { z } from 'zod';
 
-const internalSchema = PluginInfo.internalSchema.extend({}).describe('ParsedPluginInfo');
+const internalSchema = PluginInfo.internalSchema.extend({
+	operations: z.preprocess(
+		val => val ?? [],
+		z.array(
+			ParsedOperation.schemas.schema,
+			{ description: 'ParsedOperations' },
+		)
+			.optional(),
+	),
+}).describe('ParsedPluginInfo');
 
-export const rawSchema = PluginInfo.internalSchema.extend({}).describe('ParsedPluginInfo');
+export const rawSchema = PluginInfo.internalSchema.extend({
+	operations: z.preprocess(
+		val => val ?? [],
+		z.array(
+			ParsedOperation.rawSchema,
+			{ description: 'ParsedOperation' },
+		),
+	)
+		.optional(),
+}).describe('ParsedPluginInfo');
 
 type Input = z.infer<typeof internalSchema>;
 

package/PersistentState.ts

@@ -4,11 +4,23 @@ import * as Timestamp from '@taqueria/protocol/Timestamp';
 import * as Verb from '@taqueria/protocol/Verb';
 import { z } from 'zod';
 
+const rawOpSchema = z.object({
+	hash: SHA256.rawSchema.describe('state.op.hash'),
+	time: Timestamp.rawSchema.describe('state.op.time'),
+	output: z.unknown().describe('state.op.output'),
+}).describe('Persistent State Operation');
+
 const rawTaskSchema = z.object({
 	time: Timestamp.rawSchema.describe('state.task.time'),
 	output: z.unknown().describe('state.task.output'),
 });
 
+const internalOpSchema = z.object({
+	hash: SHA256.schemas.schema.describe('state.op.hash'),
+	time: Timestamp.schemas.schema.describe('state.op.time'),
+	output: z.unknown().describe('state.op.output'),
+});
+
 const internalTaskSchema = z.object({
 	task: Verb.schemas.schema,
 	plugin: z.string().min(1),
@@ -18,13 +30,18 @@ const internalTaskSchema = z.object({
 
 export type PersistedTask = z.infer<typeof internalTaskSchema>;
 
+export type PersistedOperation = z.infer<typeof internalOpSchema>;
+
 export const rawSchema = z.object({
+	operations: z.record(rawOpSchema),
 	tasks: z.record(rawTaskSchema),
 });
 
 export const internalSchema = z.object({
+	operations: z.record(internalOpSchema),
 	tasks: z.record(internalTaskSchema),
 }).transform(val => ({
+	operations: val.operations as unknown as Record<string, PersistedOperation>,
 	tasks: val.tasks as unknown as Record<string, PersistedTask>,
 }));
 

package/PluginInfo.ts

@@ -1,5 +1,6 @@
 import * as Alias from '@taqueria/protocol/Alias';
 import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as Operation from '@taqueria/protocol/Operation';
 import * as Task from '@taqueria/protocol/Task';
 import * as VersionNumber from '@taqueria/protocol/VersionNumber';
 import { z } from 'zod';
@@ -16,6 +17,13 @@ export const internalSchema = z.object({
 			{ description: 'Plugin Tasks' },
 		).optional(),
 	),
+	operations: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Operation.schemas.schema.describe('Plugin Operation'),
+			{ description: 'Plugin Operations' },
+		).optional(),
+	),
 }).describe('Plugin Schema');
 
 export const rawSchema = z.object({
@@ -30,6 +38,13 @@ export const rawSchema = z.object({
 			{ description: 'Plugin Tasks' },
 		).optional(),
 	),
+	operations: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Operation.rawSchema.describe('Plugin Operation'),
+			{ description: 'Plugin Operations' },
+		).optional(),
+	),
 }).describe('Plugin Schema');
 
 type RawInput = z.infer<typeof rawSchema>;

package/PositionalArg.ts

@@ -12,8 +12,7 @@ export const rawSchema = z.object({
 	type: z.union(
 		[z.literal('string'), z.literal('number'), z.literal('boolean')],
 		{ description: 'Positional Arg Datatype' },
-	),
-	required: z.boolean().optional(),
+	).optional(),
 }).describe('Positional Arg');
 
 const internalSchema = z.object({
@@ -26,8 +25,7 @@ const internalSchema = z.object({
 	type: z.union(
 		[z.literal('string'), z.literal('number'), z.literal('boolean')],
 		{ description: 'Positional Arg Datatype' },
-	),
-	required: z.boolean().optional(),
+	).optional(),
 }).describe('Positional Arg');
 
 type RawInput = z.infer<typeof rawSchema>;

package/Provisioner.ts

@@ -0,0 +1,61 @@
+import createType from '@taqueria/protocol/Base';
+import * as ProvisionerID from '@taqueria/protocol/ProvisionerID';
+import { z } from 'zod';
+
+export const rawSchema = z.object(
+	{
+		id: ProvisionerID.rawSchema,
+		plugin: z
+			.string()
+			.min(1)
+			.describe('Provisioner Plugin')
+			.optional(),
+		operation: z
+			.union([
+				z.string().min(1),
+				z.literal('custom'),
+			])
+			.describe('Provisioner Operation'),
+		command: z
+			.string()
+			.describe('Provisioner Custom Command')
+			.optional(),
+		label: z
+			.string()
+			.describe('Provisioner Label')
+			.optional(),
+		depends_on: z
+			.array(
+				ProvisionerID.rawSchema,
+			)
+			.optional(),
+	},
+	{
+		description: 'Provisioner',
+	},
+)
+	.passthrough();
+
+export const internalSchema = rawSchema.extend({
+	id: ProvisionerID.schemas.schema,
+	depends_on: z.array(ProvisionerID.schemas.schema).optional(),
+});
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: 'There was a problem trying to parse the provisioner',
+	unknownErrMsg: 'Something went wrong trying to parse the provisioner',
+});
+
+export type Provisioner = z.infer<typeof generatedSchemas.schema>;
+export type t = Provisioner;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as unknown as Provisioner),
+};

package/ProvisionerID.ts

@@ -0,0 +1,25 @@
+import createType from '@taqueria/protocol/Base';
+import { z } from 'zod';
+
+export const rawSchema = z
+	.string()
+	.min(1)
+	.regex(/^[A-Za-z0-9]+[A-Za-z0-9-_]+\.[A-Za-z0-9]+[A-Za-z0-9-_]+\.[A-Za-z0-9]+[A-Za-z0-9-_]+$/)
+	.describe('Provisioner ID');
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
+	rawSchema,
+	parseErrMsg: (value: unknown) => `${value} is not a valid provisioner ID`,
+	unknownErrMsg: 'Something went wrong trying to parse the provision ID',
+});
+
+export type ProvisionerID = z.infer<typeof generatedSchemas.schema>;
+export type t = ProvisionerID;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as ProvisionerID),
+};

package/Provisions.ts

@@ -0,0 +1,70 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as Provisioner from '@taqueria/protocol/Provisioner';
+import * as ProvisionerID from '@taqueria/protocol/ProvisionerID';
+import { memoizy } from 'memoizy';
+import { partitionArray, uniq } from 'rambda';
+import { z } from 'zod';
+
+const getInvalidIds = memoizy((provisions: Provisioner.t[]) => {
+	const ids = provisions.map(p => p.id);
+	return provisions.reduce(
+		(retval, provision) => {
+			const depends_on = provision.depends_on ?? [];
+			const invalid = partitionArray(
+				(id: ProvisionerID.t) => ids.includes(id),
+				depends_on,
+			).pop() as ProvisionerID.t[];
+
+			return uniq([...retval, ...invalid]);
+		},
+		[] as ProvisionerID.t[],
+	);
+});
+
+const rawSchema = z
+	.array(
+		Provisioner.rawSchema,
+	)
+	.refine(
+		provisions => getInvalidIds(provisions).length === 0,
+		provisions => ({
+			message:
+				`One or more of your provisioners depends on an invalid provisioner. The following provisioner ids were referenced that do not exist: ${
+					getInvalidIds(provisions).join(', ')
+				}`,
+		}),
+	)
+	.describe('Provisions');
+
+type RawInput = z.infer<typeof rawSchema>;
+
+const internalSchema = z
+	.array(Provisioner.schemas.schema)
+	.refine(
+		provisions => getInvalidIds(provisions).length === 0,
+		provisions => ({
+			message:
+				`One or more of your provisioners depends on an invalid provisioner. The following provisioner ids were referenced that do not exist: ${
+					getInvalidIds(provisions).join(', ')
+				}`,
+		}),
+	)
+	.describe('Provisions');
+
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `The following provision is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong parsing the list of provisioners',
+});
+
+export type Provisions = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type t = Provisions;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Provisions),
+};

package/SanitizedArgs.ts

@@ -62,10 +62,10 @@ export const scaffoldRawSchema = rawSchema.extend({
 
 export const provisionRawSchema = rawSchema
 	.extend({
-		task: z
+		operation: z
 			.string()
 			.min(1)
-			.describe('Task name'),
+			.describe('Operation name'),
 		name: z
 			.string()
 			.min(1)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@taqueria/protocol",
-	"version": "0.0.0-pr-902-45108945",
+	"version": "0.0.0-pr-899-ca79db85",
 	"description": "A TypeScript package which contains types that are to be shared between @taqueria/node-sdk and @taqueria/taqueria.",
 	"main": "index.js",
 	"scripts": {

package/taqueria-protocol-types.ts

@@ -8,7 +8,9 @@ import * as i18n from '@taqueria/protocol/i18n';
 import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
 import * as LoadedConfig from '@taqueria/protocol/LoadedConfig';
 import * as NetworkConfig from '@taqueria/protocol/NetworkConfig';
+import * as Operation from '@taqueria/protocol/Operation';
 import * as Option from '@taqueria/protocol/Option';
+import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
 import * as ParsedPluginInfo from '@taqueria/protocol/ParsedPluginInfo';
 import * as PersistentState from '@taqueria/protocol/PersistentState';
 import * as PluginInfo from '@taqueria/protocol/PluginInfo';
@@ -84,7 +86,9 @@ export {
 	InstalledPlugin,
 	LoadedConfig,
 	NetworkConfig,
+	Operation,
 	Option,
+	ParsedOperation,
 	ParsedPluginInfo,
 	PersistentState,
 	PluginInfo,