@taqueria/protocol 0.0.0-pr-730-90eda834 → 0.0.0-pr-820-800fa10d

package/Alias.ts

@@ -1,38 +1,40 @@
-import createType from '@taqueria/protocol/Base';
-import * as SingleChar from '@taqueria/protocol/SingleChar';
-import * as Verb from '@taqueria/protocol/Verb';
-import { z } from 'zod';
+import {z} from "zod"
+import * as Verb from '@taqueria/protocol/Verb'
+import * as SingleChar from '@taqueria/protocol/SingleChar'
+import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z
-	.union([
-		Verb.rawSchema,
-		SingleChar.rawSchema,
-	], { description: 'Alias' });
+    .union([
+        Verb.rawSchema,
+        SingleChar.rawSchema], 
+        {description: "Alias"}
+    )
 
 export const internalSchema = z
-	.union([
-		Verb.schemas.schema,
-		SingleChar.schemas.schema,
-	], { description: 'Alias' });
+    .union([
+        Verb.schemas.schema,
+        SingleChar.schemas.schema],
+        {description: "Alias"}
+    )
 
-type RawInput = z.infer<typeof rawSchema>;
-type Input = z.infer<typeof internalSchema>;
+type RawInput = z.infer<typeof rawSchema>
+type Input = z.infer<typeof internalSchema>    
 
-const { schemas: generatedSchemas, factory } = createType<RawInput, Input>({
-	isStringLike: true,
-	rawSchema,
-	internalSchema,
-	parseErrMsg: (value: unknown) => `${value} is not a valid alias`,
-	unknownErrMsg: 'Something went wrong trying to parse an alias',
-});
+const {schemas: generatedSchemas, factory} = createType<RawInput, Input>({
+    isStringLike: true,
+    rawSchema,
+    internalSchema,
+    parseErrMsg: (value: unknown) => `${value} is not a valid alias`,
+    unknownErrMsg: 'Something went wrong trying to parse an alias'
+})
 
-export type Alias = z.infer<typeof generatedSchemas.schema>;
+export type Alias = z.infer<typeof generatedSchemas.schema>
 
-export type t = Alias;
+export type t = Alias
 
-export const { create, of, make } = factory;
+export const {create, of, make} = factory
 
 export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Alias),
-};
+    ...generatedSchemas,
+    schema: generatedSchemas.schema.transform(val => val as Alias)
+}

package/Base.ts

@@ -1,56 +1,51 @@
-import { toFutureParseErr, toFutureParseUnknownErr } from '@taqueria/protocol/TaqError';
-import { FutureInstance, resolve } from 'fluture';
-import { z, ZodError, ZodSchema } from 'zod';
+import {z, ZodError, ZodSchema} from 'zod'
+import {toFutureParseErr, toFutureParseUnknownErr} from "@taqueria/protocol/TaqError"
+import {resolve, FutureInstance} from "fluture"
 
-type Future<L, R> = FutureInstance<L, R>;
+type Future<L, R> = FutureInstance<L, R>
 
-type ErrMsg = string | ((value: unknown) => string);
+type ErrMsg = string | ((value: unknown) => string)
 
 interface CreateSchemaParams {
-	rawSchema: ZodSchema;
-	internalSchema?: ZodSchema;
-	transformer?: (value: unknown) => unknown;
-	isStringLike?: boolean;
+    rawSchema: ZodSchema
+    internalSchema?: ZodSchema
+    transformer?: (value: unknown) => unknown,
+    isStringLike?: boolean
 }
 
 interface CreateTypeParams extends CreateSchemaParams {
-	parseErrMsg: ErrMsg;
-	unknownErrMsg: ErrMsg;
+    parseErrMsg: ErrMsg,
+    unknownErrMsg: ErrMsg    
 }
-export type Flatten<T> = { [k in keyof T]: T[k] };
+export type Flatten<T> = { [k in keyof T]: T[k] }
 
 export const createSchema = <I>(params: CreateSchemaParams) => {
-	const { rawSchema, isStringLike } = params;
-	const internalSchema = params.internalSchema ?? params.rawSchema;
-	const noop = (val: unknown) => val;
-	const transformer = params.transformer ?? noop;
-
-	const schema = isStringLike
-		? internalSchema
-			.transform((val: unknown) =>
-				transformer(val) as I & {
-					readonly __kind: 'generated' & z.infer<typeof internalSchema>;
-				}
-			)
-		: internalSchema
-			.transform((val: unknown) =>
-				transformer(val) as Flatten<
-					I & {
-						readonly __kind: 'generated' & z.infer<typeof internalSchema>;
-					}
-				>
-			);
-
-	type GeneratedSchema = typeof schema;
-
-	return {
-		rawSchema,
-		internalSchema,
-		schema,
-	};
-};
-
-// TODO:
+    const {rawSchema, isStringLike} = params
+    const internalSchema = params.internalSchema ?? params.rawSchema
+    const noop = (val: unknown) => val
+    const transformer = params.transformer ?? noop
+        
+    const schema = isStringLike
+        ? internalSchema
+            .transform((val: unknown) => transformer(val) as I & {
+                readonly __kind: "generated" & z.infer<typeof internalSchema>
+            })
+        : internalSchema
+            .transform((val: unknown) => transformer(val) as Flatten<I & {
+                readonly __kind: "generated" & z.infer<typeof internalSchema>
+            }>)
+
+    type GeneratedSchema = typeof schema         
+
+    return {
+        rawSchema,
+        internalSchema,
+        schema
+    }
+}
+
+
+// TODO: 
 // TypeScript appears to have a bug with default generic values
 // For instance, I'd like to use this:
 // export const createType = <R, I = R>(params: CreateTypeParams) => {
@@ -58,48 +53,49 @@ export const createSchema = <I>(params: CreateSchemaParams) => {
 // However, I == unknown when having I default to R if no I was given.
 // So, we need to require R and I explicitly
 export const createType = <R, I>(params: CreateTypeParams) => {
-	const schemas = createSchema<I>(params);
-	const { parseErrMsg, unknownErrMsg } = params;
-
-	type T = z.infer<typeof schemas.schema>;
-
-	const internalOf = (input: unknown) => {
-		try {
-			return resolve<T>(schemas.schema.parse(input));
-		} catch (previous) {
-			const parseMsg = typeof parseErrMsg === 'string'
-				? parseErrMsg
-				: parseErrMsg(input);
-
-			const unknownMsg = typeof unknownErrMsg === 'string'
-				? unknownErrMsg
-				: unknownErrMsg(input);
-
-			if (previous instanceof ZodError) {
-				return toFutureParseErr<T>(previous, parseMsg, input);
-			}
-			return toFutureParseUnknownErr<T>(previous, unknownMsg, input);
-		}
-	};
-	const of = internalOf;
-
-	const make = (input: I) => internalOf(input);
-
-	const create = (input: R | I) => schemas.schema.parse(input) as T;
-
-	const from = (input: unknown) => schemas.schema.parse(input) as T;
-
-	const factory = {
-		make,
-		of,
-		create,
-		from,
-	};
-
-	return {
-		schemas,
-		factory,
-	};
-};
-
-export default createType;
+    const schemas = createSchema<I>(params)
+    const {parseErrMsg, unknownErrMsg} = params
+
+    type T = z.infer<typeof schemas.schema>
+
+    const internalOf = (input: unknown) => {
+        try {
+            return resolve<T>(schemas.schema.parse(input))
+        }
+        catch (previous) {
+            const parseMsg = typeof parseErrMsg === 'string'
+                ? parseErrMsg
+                : parseErrMsg(input)
+
+            const unknownMsg = typeof unknownErrMsg === 'string'
+                ? unknownErrMsg
+                : unknownErrMsg(input)
+
+            if (previous instanceof ZodError) {
+                return toFutureParseErr<T>(previous, parseMsg, input)
+            }
+            return toFutureParseUnknownErr<T>(previous, unknownMsg, input)
+        }
+    }
+    const of = internalOf
+
+    const make = (input: I) => internalOf(input)
+
+    const create = (input: R | I) => schemas.schema.parse(input) as T
+
+    const from = (input: unknown) => schemas.schema.parse(input) as T
+
+    const factory = {
+        make,
+        of,
+        create,
+        from
+    }
+
+    return {
+        schemas,
+        factory
+    }
+}
+
+export default createType

package/Command.ts

@@ -1,24 +1,24 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
+import {z} from 'zod'
+import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z
-	.string({ description: 'Command' })
-	.min(1)
-	.regex(/^([A-Za-z-_ ]+ ?)((\[.+\] ?)|(\<.+\>) ?)*$/, 'Must be a command that can be interpreted using yargs');
+    .string({description: "Command"})
+    .min(1)
+    .regex(/^([A-Za-z-_ ]+ ?)((\[.+\] ?)|(\<.+\>) ?)*$/, "Must be a command that can be interpreted using yargs")
 
-type RawInput = z.infer<typeof rawSchema>;
+type RawInput = z.infer<typeof rawSchema>    
 
-const { schemas: generatedSchemas, factory } = createType<RawInput, RawInput>({
-	isStringLike: true,
-	rawSchema,
-	parseErrMsg: (value: unknown) => `${value} is an invalid command. Expected format is: taskName [optional] <required>`,
-	unknownErrMsg: 'Something went wrong when parsing the command',
-});
+const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
+    isStringLike: true,
+    rawSchema,
+    parseErrMsg: (value: unknown) => `${value} is an invalid command. Expected format is: taskName [optional] <required>`,
+    unknownErrMsg: "Something went wrong when parsing the command"
+})
 
-export type Command = z.infer<typeof generatedSchemas.schema>;
-export type t = Command;
-export const { create, make, of } = factory;
+export type Command = z.infer<typeof generatedSchemas.schema>
+export type t = Command
+export const {create, make, of} = factory
 export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as Command),
-};
+    ...generatedSchemas,
+    schema: generatedSchemas.schema.transform(val => val as Command)
+}

package/Config.ts

@@ -1,155 +1,152 @@
-import createType, { Flatten } from '@taqueria/protocol/Base';
-import * as Environment from '@taqueria/protocol/Environment';
-import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin';
-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';
+import {z} from 'zod'
+import * as InstalledPlugin from '@taqueria/protocol/InstalledPlugin'
+import * as NetworkConfig from '@taqueria/protocol/NetworkConfig'
+import * as SandboxConfig from "@taqueria/protocol/SandboxConfig"
+import * as Environment from "@taqueria/protocol/Environment"
+import * as Tz from "@taqueria/protocol/Tz"
+import createType, {Flatten} from "@taqueria/protocol/Base"
 
 export const pluginsRawSchema = z.preprocess(
-	val => val ?? [],
-	z.array(
-		InstalledPlugin.rawSchema,
-		{ description: 'config.plugins' },
-	),
-);
+    val => val ?? [],
+    z.array(
+        InstalledPlugin.rawSchema, {description: "config.plugins"}
+    )
+)
 
 export const pluginsInternalSchema = z.preprocess(
-	val => val ?? [],
-	z.array(
-		InstalledPlugin.schemas.schema,
-		{ description: 'config.plugins' },
-	),
-);
+    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();
+    .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();
+    .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();
+    .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' },
-	),
-);
+    (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'),
-		),
-}).describe('config');
+    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")
+        )
+}).describe("config")
 
 export const internalSchema = commonSchema.extend({
-	network: networkMap,
-	sandbox: sandboxMap,
-	environment: environmentMap,
-	accounts: accountsMap,
-});
+    network: networkMap,
+    sandbox: sandboxMap,
+    environment: environmentMap,
+    accounts: accountsMap
+})
 
 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(),
-}).describe('config');
+    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()
+}).describe("config")
 
-type RawInput = z.infer<typeof rawSchema>;
-type Input = z.infer<typeof internalSchema>;
+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 {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 {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),
-};
+    ...generatedSchemas,
+    schema: generatedSchemas.schema.transform(val => val as Config)
+}

package/Crypto.ts

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

package/EconomicalProtocolHash.ts

@@ -1,26 +1,26 @@
-import createType from '@taqueria/protocol/Base';
-import { z } from 'zod';
+import {z} from 'zod'
+import createType from "@taqueria/protocol/Base"
 
 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` }),
-	);
+    .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>;
+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 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 type EconomicalPrototypeHash = z.infer<typeof generatedSchemas.schema>
+export type t = EconomicalPrototypeHash
 
-export const { create, of, make } = factory;
+export const {create, of, make} = factory
 export const schemas = {
-	...generatedSchemas,
-	schema: generatedSchemas.schema.transform(val => val as EconomicalPrototypeHash),
-};
+    ...generatedSchemas,
+    schema: generatedSchemas.schema.transform(val => val as EconomicalPrototypeHash)
+}