@taqueria/protocol 0.3.1 → 0.4.0-rc1

package/InstalledPlugin.ts

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

package/LoadedConfig.ts

@@ -0,0 +1,45 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as Config from '@taqueria/protocol/Config';
+import * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath';
+import * as SHA256 from '@taqueria/protocol/SHA256';
+import { z } from 'zod';
+
+export const rawSchema = Config.rawSchema
+	.omit({ plugins: true })
+	.extend({
+		plugins: Config.pluginsRawSchema,
+		projectDir: SanitizedAbsPath.rawSchema.describe('loadedConfig.projectDir'),
+		configFile: SanitizedAbsPath.rawSchema.describe('loadedConfig.configFile'),
+		hash: SHA256.rawSchema.describe('loadedConfig.hash'),
+	})
+	.describe('LoadedConfig');
+
+export const internalSchema = Config.internalSchema
+	.omit({ plugins: true })
+	.extend({
+		plugins: Config.pluginsInternalSchema,
+		projectDir: SanitizedAbsPath.schemas.schema.describe('loadedConfig.projectDir'),
+		configFile: SanitizedAbsPath.schemas.schema.describe('loadedConfig.configFile'),
+		hash: SHA256.schemas.schema.describe('loadedConfig.hash'),
+	})
+	.describe('LoadedConfig');
+
+type RawInput = z.infer<typeof rawSchema>;
+type Input = Flatten<z.infer<typeof internalSchema>>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) => `The following configuration is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the configuration to load',
+});
+
+export type LoadedConfig = z.infer<typeof generatedSchemas.schema>;
+export type t = LoadedConfig;
+export const { create, of, make } = factory;
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as LoadedConfig),
+};
+
+export const toConfig = (config: LoadedConfig) => Config.make(config);

package/NetworkConfig.ts

@@ -0,0 +1,39 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as EconomicalProtocolHash from '@taqueria/protocol/EconomicalProtocolHash';
+import * as Faucet from '@taqueria/protocol/Faucet';
+import * as HumanReadableIdentifier from '@taqueria/protocol/HumanReadableIdentifier';
+import * as Url from '@taqueria/protocol/Url';
+import { z } from 'zod';
+
+export const rawSchema = z.object({
+	label: HumanReadableIdentifier.rawSchema,
+	rpcUrl: Url.rawSchema,
+	protocol: EconomicalProtocolHash.rawSchema,
+	faucet: Faucet.rawSchema.describe('Network Faucet'),
+}).describe('Network Config');
+
+const internalSchema = z.object({
+	label: HumanReadableIdentifier.schemas.schema.describe('Network Label'),
+	rpcUrl: Url.schemas.schema.describe('Network RPC Url'),
+	protocol: EconomicalProtocolHash.schemas.schema.describe('Network Protocol Hash'),
+	faucet: Faucet.schemas.schema.describe('Network Faucet'),
+}).describe('Network 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 valid network configuration`,
+	unknownErrMsg: 'Something went wrong trying to parse the network configuration',
+});
+
+export type NetworkConfig = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type t = NetworkConfig;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as NetworkConfig),
+};

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

@@ -0,0 +1,56 @@
+import createType, { Flatten } from '@taqueria/protocol/Base';
+import * as SingleChar from '@taqueria/protocol/SingleChar';
+import * as Verb from '@taqueria/protocol/Verb';
+import { z } from 'zod';
+
+export const internalSchema = z.object({
+	shortFlag: SingleChar.schemas.schema.describe('Option Short Flag').optional(),
+	flag: Verb.schemas.schema.describe('Option Long Flag'),
+	description: z.string({ description: 'Option Description' }).min(1),
+	defaultValue: z.union(
+		[z.string(), z.number(), z.boolean()],
+		{ description: 'Option Default Value' },
+	).optional(),
+	choices: z.array(
+		z.string({ description: 'Option Choice' }),
+		{ description: 'Option Choices' },
+	).optional(),
+	required: z.boolean({ description: 'Option Is Required' }).default(false).optional(),
+	boolean: z.boolean({ description: 'Option Is Boolean' }).default(false).optional(),
+}).describe('Option');
+
+export const rawSchema = z.object({
+	shortFlag: SingleChar.rawSchema.describe('Option Short Flag').optional(),
+	flag: Verb.rawSchema.describe('Option Long Flag'),
+	description: z.string({ description: 'Option Description' }).min(1),
+	defaultValue: z.union(
+		[z.string(), z.number(), z.boolean()],
+		{ description: 'Option Default Value' },
+	).optional(),
+	choices: z.array(
+		z.string({ description: 'Option Choice' }),
+		{ description: 'Option Choices' },
+	).optional(),
+	required: z.boolean({ description: 'Option Is Required' }).default(false).optional(),
+	boolean: z.boolean({ description: 'Option Is Boolean' }).default(false).optional(),
+}).describe('Option');
+
+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) => `The following option is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the option',
+});
+
+export type Option = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type t = Option;
+
+export const { make, create, of } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as Option),
+};

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

@@ -0,0 +1,47 @@
+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({
+	operations: z.preprocess(
+		val => val ?? [],
+		z.array(
+			ParsedOperation.schemas.schema,
+			{ description: 'ParsedOperations' },
+		)
+			.optional(),
+	),
+}).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>;
+
+type RawInput = z.infer<typeof rawSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: (value: unknown) =>
+		`The following plugin info gave us trouble when parsing the following plugin information: ${value}`,
+	unknownErrMsg: 'Something went wrong trying to parse the plugin information',
+});
+
+export type ParsedPluginInfo = z.infer<typeof generatedSchemas.schema>;
+export type t = ParsedPluginInfo;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as ParsedPluginInfo),
+};

package/PersistentState.ts

@@ -0,0 +1,67 @@
+import createType from '@taqueria/protocol/Base';
+import * as SHA256 from '@taqueria/protocol/SHA256';
+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),
+	time: Timestamp.schemas.schema.describe('state.task.time'),
+	output: z.unknown().describe('state.op.output'),
+});
+
+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>,
+}));
+
+type RawInput = z.infer<typeof rawSchema>;
+
+type Input = z.infer<typeof internalSchema>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	parseErrMsg: `The persistent state is invalid`,
+	unknownErrMsg: `Something went wrong trying to parse the persistent state`,
+});
+
+export type PersistentState = z.infer<typeof generatedSchemas.schema>;
+export type t = PersistentState;
+export type State = PersistentState;
+
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as unknown as PersistentState),
+};

package/PluginInfo.ts

@@ -0,0 +1,67 @@
+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';
+
+export const internalSchema = z.object({
+	name: z.string({ description: 'Plugin Name' }).min(1),
+	version: VersionNumber.schemas.schema.describe('Plugin Version #'),
+	schema: VersionNumber.schemas.schema.describe('Plugin Schema Version #'),
+	alias: Alias.schemas.schema.describe('Plugin Alias'),
+	tasks: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Task.schemas.schema.describe('Plugin Task'),
+			{ 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({
+	name: z.string({ description: 'Plugin Name' }).min(1),
+	version: VersionNumber.rawSchema.describe('Plugin Version #'),
+	schema: VersionNumber.rawSchema.describe('Plugin Schema Version #'),
+	alias: Alias.rawSchema.describe('Plugin Alias'),
+	tasks: z.preprocess(
+		val => val ?? [],
+		z.array(
+			Task.rawSchema.describe('Plugin Task'),
+			{ 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>;
+type Input = Flatten<z.infer<typeof internalSchema>>;
+
+export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
+	rawSchema,
+	internalSchema,
+	parseErrMsg: 'The schema returned from the plugin is invalid',
+	unknownErrMsg: 'Something went wrong parsing the schema from a plugin',
+});
+
+export type PluginInfo = Flatten<z.infer<typeof generatedSchemas.schema>>;
+export type t = PluginInfo;
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as unknown as PluginInfo),
+};

package/PositionalArg.ts

@@ -0,0 +1,49 @@
+import createType from '@taqueria/protocol/Base';
+import * as HumanReadableIdentifier from '@taqueria/protocol/HumanReadableIdentifier';
+import { z } from 'zod';
+
+export const rawSchema = z.object({
+	placeholder: HumanReadableIdentifier.rawSchema.describe('Positional Arg Placeholder'),
+	description: z.string({ description: 'Positional Arg Description' }).min(1),
+	defaultValue: z.union(
+		[z.string(), z.number(), z.boolean()],
+		{ description: 'Positional Arg Default Value' },
+	).optional(),
+	type: z.union(
+		[z.literal('string'), z.literal('number'), z.literal('boolean')],
+		{ description: 'Positional Arg Datatype' },
+	).optional(),
+}).describe('Positional Arg');
+
+const internalSchema = z.object({
+	placeholder: HumanReadableIdentifier.schemas.schema.describe('Positional Arg Placeholder'),
+	description: z.string({ description: 'Positional Arg Description' }).min(1),
+	defaultValue: z.union(
+		[z.string(), z.number(), z.boolean()],
+		{ description: 'Positional Arg Default Value' },
+	).optional(),
+	type: z.union(
+		[z.literal('string'), z.literal('number'), z.literal('boolean')],
+		{ description: 'Positional Arg Datatype' },
+	).optional(),
+}).describe('Positional Arg');
+
+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) => `The following positional argument is invalid: ${value}`,
+	unknownErrMsg: 'Something went wrong parsing the positional argument',
+});
+
+export type PositionalArg = z.infer<typeof generatedSchemas.schema>;
+export type t = PositionalArg;
+
+export const { create, of, make } = factory;
+
+export const schemas = {
+	...generatedSchemas,
+	schema: generatedSchemas.schema.transform(val => val as unknown as PositionalArg),
+};

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),
+};