@taqueria/protocol 0.16.0 → 0.19.2

package/LoadedConfig.ts

@@ -1,45 +0,0 @@
-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/MetadataConfig.ts

@@ -1,37 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z.object({
-	name: z.string({ description: 'Project Name' }).optional(),
-	projectDescription: z.string({ description: 'Project Description' }).optional(),
-	authors: z.array(z.string({ description: 'Project Author' })).default([]).describe('Project Authors').optional(),
-	license: z.string({ description: 'Project License' }).optional(),
-	homepage: z.string({ description: 'Project Web Url' }).optional(),
-});
-
-const internalSchema = z.object({
-	name: z.string({ description: 'Project Name' }).optional(),
-	projectDescription: z.string({ description: 'Project Description' }).optional(),
-	authors: z.array(z.string({ description: 'Project Author' })).default([]).describe('Project Authors').optional(),
-	license: z.string({ description: 'Project License' }).optional(),
-	homepage: z.string({ description: 'Project Web Url' }).optional(),
-}, { description: 'Project Metadata' });
-
-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 metadata configuration `,
-	unknownErrMsg: 'Something went wrong trying to parse the metadata configuration',
-});
-
-export type MetadataConfig = z.infer<typeof generatedSchemas.schema>;
-export type t = MetadataConfig;
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as MetadataConfig),
-};

package/NetworkConfig.ts

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

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

@@ -1,64 +0,0 @@
-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(),
-	type: z.union(
-		[z.literal('string'), z.literal('number'), z.literal('boolean')],
-		{ description: 'Positional Arg Datatype' },
-	).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(),
-	type: z.union(
-		[z.literal('string'), z.literal('number'), z.literal('boolean')],
-		{ description: 'Positional Arg Datatype' },
-	).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

@@ -1,33 +0,0 @@
-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/ParsedTemplate.ts

@@ -1,40 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as PluginResponseEncoding from '@taqueria/protocol/PluginResponseEncoding';
-import * as Template from '@taqueria/protocol/Template';
-import { z } from 'zod';
-
-const internalSchema = Template
-	.internalSchema
-	.extend({
-		handler: z.string(),
-		encoding: PluginResponseEncoding.schemas.schema,
-	})
-	.describe('ParsedTemplate');
-
-export const rawSchema = Template
-	.rawSchema
-	.extend({
-		handler: z.string(),
-		encoding: PluginResponseEncoding.schemas.schema,
-	})
-	.describe('ParsedTemplate');
-
-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 template: ${value}`,
-	unknownErrMsg: 'Something went wrong trying to parse an template',
-});
-
-export type ParsedTemplate = z.infer<typeof generatedSchemas.schema>;
-export type t = ParsedTemplate;
-
-export const { create, make, of } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as ParsedTemplate),
-};

package/PersistentState.ts

@@ -1,69 +0,0 @@
-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({
-	task: Verb.schemas.rawSchema,
-	plugin: z.string().min(1),
-	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/PluginActionName.ts

@@ -1,28 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-const rawSchema = z.union([
-	z.literal('checkRuntimeDependencies'),
-	z.literal('installRuntimeDependencies'),
-	z.literal('proxy'),
-	z.literal('proxyTemplate'),
-	z.literal('pluginInfo'),
-]);
-
-const internalSchema = rawSchema;
-
-export type PluginActionName = z.infer<typeof rawSchema>;
-export type t = PluginActionName;
-
-const pluginActionNotSupportedSchema = z.object({
-	status: z.literal('notSupported'),
-	msg: z.string(),
-});
-
-export type PluginActionNotSupportedResponse = z.infer<typeof pluginActionNotSupportedSchema>;
-
-export const schemas = {
-	schema: internalSchema,
-	internalSchema,
-	rawSchema,
-};

package/PluginDependenciesResponse.ts

@@ -1,33 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-const rawRuntimeDependency = z.object({
-	name: z.string(),
-	path: z.string(),
-	version: z.string(),
-	kind: z.union([z.literal('required'), z.literal('optional')]),
-});
-
-type RawRuntimeDependencyInput = z.infer<typeof rawRuntimeDependency>;
-
-export const { schemas, factory } = createType<RawRuntimeDependencyInput, RawRuntimeDependencyInput>({
-	rawSchema: rawRuntimeDependency,
-	internalSchema: rawRuntimeDependency,
-	parseErrMsg: (value: unknown) => `The following runtime dependency is invalid: ${value}`,
-	unknownErrMsg: 'Something went wrong trying to parse the template',
-});
-
-export type RuntimeDependency = z.infer<typeof schemas.schema>;
-
-const runtimeDependencyReport = rawRuntimeDependency.extend({ met: z.boolean() });
-
-export type RuntimeDependencyReport = z.infer<typeof runtimeDependencyReport>;
-
-const dependenciesResponseSchema = z.object({
-	report: z.array(runtimeDependencyReport),
-});
-
-export type PluginDependenciesResponse = z.infer<typeof dependenciesResponseSchema>;
-export type t = PluginDependenciesResponse;
-
-export const { of, make, create } = factory;

package/PluginInfo.ts

@@ -1,76 +0,0 @@
-import * as Alias from '@taqueria/protocol/Alias';
-import createType, { Flatten } from '@taqueria/protocol/Base';
-import * as ParsedOperation from '@taqueria/protocol/ParsedOperation';
-import * as ParsedTemplate from '@taqueria/protocol/ParsedTemplate';
-import * as Task from '@taqueria/protocol/Task';
-import * as VersionNumber from '@taqueria/protocol/VersionNumber';
-import { z } from 'zod';
-
-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.schemas.schema.describe('Plugin Task'),
-			{ description: 'Plugin Tasks' },
-		),
-	).optional(),
-	operations: z.preprocess(
-		val => val ?? [],
-		z.array(
-			ParsedOperation.schemas.schema.describe('Plugin Operation'),
-			{ description: 'Plugin Operations' },
-		),
-	).optional(),
-	templates: z.preprocess(
-		val => val ?? [],
-		z.array(
-			ParsedTemplate.schemas.schema.describe('Plugin Template'),
-		),
-	).optional(),
-});
-
-export const internalSchema = rawSchema.extend({
-	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(
-			ParsedOperation.schemas.schema.describe('Plugin Operation'),
-			{ description: 'Plugin Operations' },
-		),
-	).optional(),
-	templates: z.preprocess(
-		val => val ?? [],
-		z.array(
-			ParsedTemplate.schemas.schema.describe('Plugin Template'),
-		),
-	).optional(),
-}).describe('Plugin Schema');
-
-// export const rawSchema = internalSchema;
-
-type RawInput = z.infer<typeof rawSchema>;
-type Input = Flatten<z.infer<typeof internalSchema>>;
-
-export const { schemas, 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 schemas.schema>>;
-export type t = PluginInfo;
-export const { create, of, make } = factory;

package/PluginJsonResponse.ts

@@ -1,26 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z.object({
-	data: z.unknown().optional(),
-	render: z.union([
-		z.literal('none'),
-		z.literal('table'),
-		z.literal('string'),
-	]).optional(),
-});
-
-type RawPluginJsonResponseInput = z.infer<typeof rawSchema>;
-
-export const pluginJsonResponse = createType<RawPluginJsonResponseInput, RawPluginJsonResponseInput>({
-	rawSchema: rawSchema,
-	internalSchema: rawSchema,
-	parseErrMsg: (value: unknown) => `The following JSON response is invalid: ${value}`,
-	unknownErrMsg: 'Something went wrong trying to parse the template',
-});
-
-export type PluginJsonResponse = z.infer<typeof pluginJsonResponse.schemas.schema>;
-
-export type t = PluginJsonResponse;
-
-export const { schemas, factory } = pluginJsonResponse;

package/PluginProxyResponse.ts

@@ -1,24 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as PluginJsonResponse from '@taqueria/protocol/PluginJsonResponse';
-import { z } from 'zod';
-
-const internalSchema = z.union([
-	PluginJsonResponse.schemas.internalSchema,
-	z.void(),
-]);
-
-export const rawSchema = internalSchema;
-
-type Input = z.infer<typeof internalSchema>;
-
-export const { schemas, factory } = createType<Input, Input>({
-	rawSchema,
-	internalSchema,
-	parseErrMsg: 'The response from the proxy request is invalid',
-	unknownErrMsg: 'Something went wrong parsing the proxy response from the plugin',
-});
-
-export type PluginProxyResponse = z.infer<typeof schemas.schema>;
-export type t = PluginProxyResponse;
-
-export const { of, make, create } = factory;

package/PluginResponseEncoding.ts

@@ -1,27 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z.preprocess(
-	(val: unknown) => val ?? 'none',
-	z.union([
-		z.literal('json'),
-		z.literal('application/json'),
-		z.literal('none'),
-	])
-		.default('none')
-		.optional(),
-);
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas, factory } = createType<RawInput, RawInput>({
-	rawSchema,
-	internalSchema: rawSchema,
-	parseErrMsg: (value: unknown) => `The following encoding is invalid: ${value}`,
-	unknownErrMsg: 'Something went wrong trying to parse the encoding',
-});
-
-export type PluginResponseEncoding = z.infer<typeof schemas.schema>;
-export type t = PluginResponseEncoding;
-
-export const { create, of, make } = factory;