@taqueria/protocol 0.16.0 → 0.19.2

package/PluginSchema.ts

@@ -1,81 +0,0 @@
-import * as Alias from '@taqueria/protocol/Alias';
-import createType from '@taqueria/protocol/Base';
-import * as Operation from '@taqueria/protocol/Operation';
-import * as PluginDependenciesResponse from '@taqueria/protocol/PluginDependenciesResponse';
-import * as PluginInfo from '@taqueria/protocol/PluginInfo';
-import * as PluginProxyResponse from '@taqueria/protocol/PluginProxyResponse';
-import * as RequestArgs from '@taqueria/protocol/RequestArgs';
-import * as Template from '@taqueria/protocol/Template';
-import { z } from 'zod';
-
-const proxyFnSchema = z
-	.function()
-	.args(RequestArgs.proxySchemas.schema)
-	.returns(z.promise(PluginProxyResponse.schemas.schema));
-
-const runtimeDependenciesFn = z
-	.function()
-	.args(RequestArgs.schemas.schema)
-	.returns(z.promise(PluginDependenciesResponse.schemas.schema));
-
-const internalSchema = PluginInfo.internalSchema.extend({
-	operations: z.preprocess(
-		val => val ?? [],
-		z.array(
-			Operation.schemas.schema,
-			{ description: 'ParsedOperations' },
-		)
-			.optional(),
-	),
-	templates: z.preprocess(
-		val => val ?? [],
-		z.array(
-			Template.schemas.schema,
-		).optional(),
-	),
-	proxy: proxyFnSchema.optional(),
-	checkRuntimeDependencies: runtimeDependenciesFn.optional(),
-	installRuntimeDependencies: runtimeDependenciesFn.optional(),
-}).describe('ParsedPluginInfo');
-
-export const rawSchema = PluginInfo.rawSchema.extend({
-	name: Alias.rawSchema.optional(),
-	operations: z.preprocess(
-		val => val ?? [],
-		z.array(
-			Operation.rawSchema,
-			{ description: 'ParsedOperation' },
-		),
-	)
-		.optional(),
-	templates: z.preprocess(
-		val => val ?? [],
-		z.array(
-			Template.schemas.schema,
-		).optional(),
-	),
-	proxy: proxyFnSchema.optional(),
-	checkRuntimeDependencies: runtimeDependenciesFn.optional(),
-	installRuntimeDependencies: runtimeDependenciesFn.optional(),
-}).describe('ParsedPluginInfo');
-
-type Input = z.infer<typeof internalSchema>;
-
-export type RawPluginSchema = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawPluginSchema, 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/PositionalArg.ts

@@ -1,41 +0,0 @@
-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(),
-	required: z.boolean().optional(),
-}).describe('Positional Arg');
-
-const internalSchema = rawSchema.extend({
-	placeholder: HumanReadableIdentifier.schemas.schema.describe('Positional Arg Placeholder'),
-}).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

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

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

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

@@ -1,28 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
-
-export const rawSchema = z
-	.string({ description: 'Public Key Hash' })
-	.min(1) // TODO: what's the actual minimum length here?
-	.refine(
-		val => val.startsWith('tz1'),
-		val => ({ message: `${val} is not a valid public key hash` }),
-	);
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is an invalid public key hash`,
-	unknownErrMsg: 'Something went wrong parsing the public key hash',
-});
-
-export type PublicKeyHash = z.infer<typeof generatedSchemas.schema>;
-export type t = PublicKeyHash;
-export type PKH = PublicKeyHash;
-export const { create, of, make } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as PublicKeyHash),
-};

package/RequestArgs.ts

@@ -1,97 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as LoadedConfig from '@taqueria/protocol/LoadedConfig';
-import { rawSchema as sanitizedArgsSchema } from '@taqueria/protocol/SanitizedArgs';
-import { z } from 'zod';
-
-const taqRunSchema = z.union([
-	z.literal('pluginInfo'),
-	z.literal('proxy'),
-	z.literal('checkRuntimeDependencies'),
-	z.literal('installRuntimeDependencies'),
-	z.literal('proxyTemplate'),
-]);
-
-const rawSchema = sanitizedArgsSchema.extend({
-	taqRun: taqRunSchema,
-	config: z.preprocess(
-		val => typeof val === 'string' ? JSON.parse(val) : val,
-		LoadedConfig.rawSchema,
-	),
-}).describe('RequestArgs').passthrough();
-
-const internalSchema = sanitizedArgsSchema.extend({
-	taqRun: taqRunSchema,
-	config: z.preprocess(
-		val => typeof val === 'string' ? JSON.parse(val) : val,
-		LoadedConfig.schemas.schema,
-	),
-}).describe('RequestArgs').passthrough();
-
-type RawInput = z.infer<typeof rawSchema>;
-type Input = z.infer<typeof internalSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
-	rawSchema,
-	internalSchema,
-	parseErrMsg: 'The request is invalid',
-	unknownErrMsg: 'Something went wrong trying to parse the request',
-});
-
-export type RequestArgs = z.infer<typeof generatedSchemas.schema>;
-export type t = RequestArgs;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as RequestArgs),
-};
-
-const rawProxyTaskSchema = rawSchema.extend({
-	task: z.string().min(1),
-}).describe('ProxyRequestArgs').passthrough();
-
-const internalProxyTaskSchema = internalSchema.extend({
-	task: z.string().min(1),
-}).describe('ProxyRequestArgs').passthrough();
-
-const rawProxyTemplateSchema = rawSchema.extend({
-	template: z.string().min(1),
-});
-
-const internalProxyTemplateSchema = rawSchema.extend({
-	template: z.string().min(1),
-});
-
-type RawProxyInput = z.infer<typeof rawProxyTaskSchema>;
-type ProxyInput = z.infer<typeof internalProxyTaskSchema>;
-type RawProxyTemplateInput = z.infer<typeof rawProxyTemplateSchema>;
-type ProxyTemplateInput = z.infer<typeof internalProxyTemplateSchema>;
-
-export const proxy = createType<RawProxyInput, ProxyInput>({
-	rawSchema: rawProxyTaskSchema,
-	internalSchema: internalProxyTaskSchema,
-	parseErrMsg: 'The request is invalid',
-	unknownErrMsg: 'Something went wrong trying to parse the request',
-});
-
-export const proxyTemplate = createType<RawProxyTemplateInput, ProxyTemplateInput>({
-	rawSchema: rawProxyTemplateSchema,
-	internalSchema: internalProxyTemplateSchema,
-	parseErrMsg: 'The request is invalid',
-	unknownErrMsg: 'Something went wrong trying to parse the request',
-});
-
-export const proxySchemas = proxy.schemas;
-export const proxyFactory = proxy.factory;
-
-export type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>;
-export type ProxyTemplateRequestArgs = z.infer<typeof proxyTemplate.schemas.schema>;
-
-export const createProxyRequestArgs = proxyFactory.from;
-export const makeProxyRequestArgs = proxyFactory.make;
-export const ofProxyRequestArgs = proxyFactory.of;
-
-export const createProxyTemplateRequestArgs = proxyTemplate.factory.from;
-export const makeProxyTemplateRequestArgs = proxyTemplate.factory.make;
-export const ofProxyTemplateRequestArgs = proxyTemplate.factory.of;
-
-export const { create, make, of, from } = factory;

package/SHA256.ts

@@ -1,42 +0,0 @@
-import { Crypto } from '@peculiar/webcrypto';
-import createType from '@taqueria/protocol/Base';
-import { E_TaqError, TaqError } from '@taqueria/protocol/TaqError';
-import { FutureInstance as Future, mapRej, promise } from 'fluture';
-import { TextEncoder } from 'util';
-import { z } from 'zod';
-
-const eager = <T>(f: Future<TaqError, T>) =>
-	promise(
-		mapRej((err: TaqError) => new E_TaqError(err))(f),
-	);
-
-export const rawSchema = z.string({ description: 'SHA256' }).length(64);
-
-type RawInput = z.infer<typeof rawSchema>;
-
-const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,
-	unknownErrMsg: (value: unknown) => `Something went wrong trying to parse the following as a SHA256 value, ${value}`,
-});
-
-export const toSHA256 = async (value: string) => {
-	const encoder = new TextEncoder();
-	const data = encoder.encode(value);
-	const crypto = new Crypto();
-	const hash = await crypto.subtle.digest('SHA-256', data);
-	const hashArray = Array.from(new Uint8Array(hash)); // convert buffer to byte array
-	const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-	return eager(factory.make(hashHex));
-};
-
-export const internalSchema = generatedSchemas.schema;
-
-export type SHA256 = z.infer<typeof internalSchema>;
-export type t = SHA256;
-export const { create, of, make } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as SHA256),
-};

package/SandboxAccountConfig.ts

@@ -1,35 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as PublicKeyHash from '@taqueria/protocol/PublicKeyHash';
-import { z } from 'zod';
-
-const internalSchema = z.object({
-	encryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),
-	publicKeyHash: PublicKeyHash.schemas.schema.describe('Sandbox Account Public Key Hash'),
-	secretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),
-}, { description: 'Sandbox Account Configuration' });
-
-export const rawSchema = z.object({
-	encryptedKey: z.string({ description: 'Sandbox Account Encrypted Key' }).min(1),
-	publicKeyHash: z.string({ description: 'Sandbox Account Public Key Hash' }).min(1),
-	secretKey: z.string({ description: 'Sandbox Account Secret Key' }).min(1),
-}, { description: 'Sandbox Account Configuration' });
-
-type Input = z.infer<typeof internalSchema>;
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
-	rawSchema,
-	internalSchema,
-	parseErrMsg: 'The sandbox account configuration is invalid',
-	unknownErrMsg: 'Something went wrong trying to parse the sandbox account configuration',
-});
-
-export type SandboxAccountConfig = z.infer<typeof generatedSchemas.schema>;
-export type t = SandboxAccountConfig;
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as SandboxAccountConfig),
-};

package/SandboxConfig.ts

@@ -1,66 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as EconomicalProtocolHash from '@taqueria/protocol/EconomicalProtocolHash';
-import * as HumanReadableIdentifier from '@taqueria/protocol/HumanReadableIdentifier';
-import * as SandboxAccountConfig from '@taqueria/protocol/SandboxAccountConfig';
-import * as TzKt from '@taqueria/protocol/tzkt-config';
-import * as Url from '@taqueria/protocol/Url';
-import * as Verb from '@taqueria/protocol/Verb';
-import { z } from 'zod';
-
-const accountMapSchema = z.record(
-	z.union([
-		z.string().nonempty(),
-		SandboxAccountConfig.schemas.schema,
-	]),
-);
-
-export const rawSchema = z.object({
-	label: z.string({ description: 'Sandbox Label' }).min(1),
-	rpcUrl: z.string({ description: 'Sandbox RPC Url' }).min(5).url(),
-	protocol: z.string({ description: 'Sandbox Protocol Hash' }).min(8),
-	attributes: z.record(
-		z.union(
-			[z.string(), z.number(), z.boolean()],
-			{ description: 'Sandbox Attribute' },
-		),
-		{ description: 'Sandbox Attributes' },
-	).optional(),
-	plugin: Verb.rawSchema.describe('Sandbox Plugin').optional(),
-	accounts: z.union([
-		z.object({ default: z.string().min(1) }),
-		z.record(SandboxAccountConfig.rawSchema),
-	], { description: 'Sandbox Accounts' }).optional(),
-	tzkt: TzKt.rawSchema.describe('TzKt config').optional(),
-});
-
-const internalSchema = z.object({
-	label: HumanReadableIdentifier.schemas.schema.describe('Sandbox Label'),
-	rpcUrl: Url.schemas.schema.describe('Sandbox RPC Url'),
-	protocol: EconomicalProtocolHash.schemas.schema.describe('Sandbox Protocol Hash'),
-	attributes: z.record(
-		z.union([z.string(), z.number(), z.boolean()]),
-		{ description: 'Sandbox Attributes' },
-	).optional(),
-	plugin: Verb.schemas.schema.describe('Sandbox Plugin').optional(),
-	accounts: accountMapSchema.optional(),
-	tzkt: TzKt.rawSchema.describe('TzKt config').optional(),
-}, { description: 'Sandbox Configuration' });
-
-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 sandbox configuration `,
-	unknownErrMsg: 'Something went wrong trying to parse the sandbox configuration',
-});
-
-export type SandboxConfig = z.infer<typeof generatedSchemas.schema>;
-export type t = SandboxConfig;
-export const { create, of, make } = factory;
-
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as SandboxConfig),
-};

package/SanitizedAbsPath.ts

@@ -1,23 +0,0 @@
-import createType from '@taqueria/protocol/Base';
-import * as path from 'path';
-import { z } from 'zod';
-
-export const rawSchema = z.string({ description: 'SanitizedAbsPath' }).min(1);
-
-type RawInput = z.infer<typeof rawSchema>;
-
-export const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	transformer: (value: unknown) => path.resolve(value as string) as unknown,
-	parseErrMsg: (value: unknown) => `${value} is an invalid absolute path`,
-	unknownErrMsg: (value: unknown) => `Something went wrong trying to parse the absolute path, ${value}`,
-});
-
-export type SanitizedAbsPath = z.infer<typeof generatedSchemas.schema>;
-export type t = SanitizedAbsPath;
-export const { create, make, of } = factory;
-export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as SanitizedAbsPath),
-};