@taqueria/protocol 0.0.0-pr-659-7f58d15b → 0.0.0-pr-659-73dc044f

package/Alias.ts

@@ -3,7 +3,6 @@ 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,

package/Base.ts

@@ -1,4 +1,4 @@
-import {z, ZodError, ZodSchema, ZodEffects} from 'zod'
+import {z, ZodError, ZodSchema} from 'zod'
 import {toFutureParseErr, toFutureParseUnknownErr} from "@taqueria/protocol/TaqError"
 import {resolve, FutureInstance} from "fluture"
 
@@ -44,13 +44,21 @@ export const createSchema = <I>(params: CreateSchemaParams) => {
     }
 }
 
-export const createType = <R, I = R>(params: CreateTypeParams) => {
+
+// 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) => {
+//
+// 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 of = (input: I | unknown) => {
+    const of = (input: R | I | unknown) => {
         try {
             return resolve<T>(schemas.schema.parse(input))
         }
@@ -72,7 +80,7 @@ export const createType = <R, I = R>(params: CreateTypeParams) => {
 
     const make = (input: I) => of(input)
 
-    const create = (input: R | I | unknown) => schemas.schema.parse(input)
+    const create = (input: R | I | unknown) => schemas.schema.parse(input) as T
 
     const factory = {
         make,

package/Command.ts

@@ -3,11 +3,12 @@ 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")
 
 type RawInput = z.infer<typeof rawSchema>    
 
-const {schemas: generatedSchemas, factory} = createType<RawInput>({
+const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is an invalid command. Expected format is: taskName [optional] <required>`,

package/Config.ts

@@ -22,7 +22,7 @@ const sandboxMap = z
         z.union([
             SandboxConfig.schemas.schema,
             z.string({description: "config.sandbox"})
-            .nonempty("Default sandbox must reference the name of an existing sandbox configuration.")
+            .min(1, "Default sandbox must reference the name of an existing sandbox configuration.")
         ]),
         {description: "Sandbox configurations"}
     )
@@ -33,7 +33,7 @@ const environmentMap = z
         z.union([
             Environment.schemas.schema,
             z.string({description: "config.environment"})
-            .nonempty("Default environment must reference the name of an existing environment.")
+            .min(1, "Default environment must reference the name of an existing environment.")
         ]),
         {description: "Environment configurations"}
     )
@@ -64,26 +64,19 @@ const commonSchema = z.object({
         .preprocess(
             (val: unknown) => val ?? "tests",
             z.string({description: "config.testsDir"})
-            .nonempty("config.testsDir must have a value")
+            .min(1, "config.testsDir must have a value")
         ),
     contractsDir: z
         .preprocess(
             (val: unknown) => val ?? "contracts",
             z.string({description: "config.contractsDir"})
-            .nonempty("config.contractsDir must have a value")
+            .min(1, "config.contractsDir must have a value")
         ),
     artifactsDir: z
         .preprocess(
             (val: unknown) => val ?? "artifacts",
             z.string({description: "config.artifactsDir"})
-            .nonempty("config.artifactsDir must have a value")
-        ),
-    operationsDir: z
-        .preprocess(
-            (val: unknown) => val ?? "operations",
-            z.string({description: "config.operationsDir"})
-            .nonempty("config.operationsDir must have a value")
-            .optional()
+            .min(1, "config.artifactsDir must have a value")
         )
 }).describe("config")
 
@@ -100,7 +93,7 @@ export const rawSchema = commonSchema.extend({
             z.union([
                 NetworkConfig.rawSchema,
                 z.string({description: "config.network"})
-                .nonempty("Default network must reference the name of an  existing network configuration.")
+                .min(1, "Default network must reference the name of an  existing network configuration.")
             ])
         )
         .optional(),
@@ -109,7 +102,7 @@ export const rawSchema = commonSchema.extend({
             z.union([
                 SandboxConfig.rawSchema,
                 z.string({description: "config.sandbox"})
-                .nonempty("Default sandbox must reference the name of an existing sandbox configuration.")
+                .min(1, "Default sandbox must reference the name of an existing sandbox configuration.")
             ])
         )
         .optional(),
@@ -118,7 +111,7 @@ export const rawSchema = commonSchema.extend({
             z.union([
                 Environment.rawSchema,
                 z.string({description: "config.environment"})
-            .nonempty("Default environment must reference the name of an existing environment.")
+                .min(1, "Default environment must reference the name of an existing environment.")
             ])
         )
         .optional(),

package/EconomicalProtocolHash.ts

@@ -10,7 +10,7 @@ export const rawSchema = z
 
 type RawInput = z.infer<typeof rawSchema>    
 
-export const {schemas: generatedSchemas, factory} = createType<RawInput>({
+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"

package/Environment.ts

@@ -4,11 +4,11 @@ import createType, {Flatten} from "@taqueria/protocol/Base"
 export const rawSchema = z.object({
     networks: z.array(
         z.string({description: "Environment network"})
-        .nonempty("Must reference the name of an existing network configuration")
+        .min(1, "Must reference the name of an existing network configuration")
     ),
     sandboxes: z.array(
         z.string({description: "Environment sandbox"})
-        .nonempty("Must reference the name of an existing sandbox configuration")
+        .min(1, "Must reference the name of an existing sandbox configuration")
     ),
     storage: z.record(
         z.any({description: "Environment storage value"}),
@@ -19,7 +19,7 @@ export const rawSchema = z.object({
 
 type RawInput = z.infer<typeof rawSchema>
 
-export const {schemas, factory} = createType<RawInput>({
+export const {schemas, factory} = createType<RawInput, RawInput>({
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is not an valid environment configuration`,
     unknownErrMsg: "Something went wrong trying to parse the environment configuration"

package/EphemeralState.ts

@@ -41,7 +41,7 @@ const rawSchema = z.object({
 
 type RawInput = z.infer<typeof rawSchema>
 
-export const {schemas, factory} = createType<RawInput>({
+export const {schemas, factory} = createType<RawInput, RawInput>({
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is not a valid representation of ephemeral state`,
     unknownErrMsg: "Something went wrong when parsing the ephemeral state"

package/Faucet.ts

@@ -3,15 +3,15 @@ import * as PublicKeyHash from "@taqueria/protocol/PublicKeyHash"
 import createType, {Flatten} from "@taqueria/protocol/Base"
 
 export const rawSchema = z.object({
-    pkh: z.string({description: "Faucet Public Key Hash"}).nonempty(),
+    pkh: z.string({description: "Faucet Public Key Hash"}).min(1),
     mnemonic: z.array(
-        z.string({description: "Faucet Mnemonic Word"}).nonempty(),
+        z.string({description: "Faucet Mnemonic Word"}).min(1),
         {description: "Faucet Mnemonic"}
     ),
     email: z.string({description: "Faucet E-mail"}).regex(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/),
-    password: z.string({description: "Faucet Password"}).nonempty(),
-    amount: z.string({description: "Faucet Account"}).nonempty().regex(/^\d+$/),
-    activation_code: z.string({description: "Faucet Activation Code"}).nonempty()
+    password: z.string({description: "Faucet Password"}).min(1),
+    amount: z.string({description: "Faucet Account"}).min(1).regex(/^\d+$/),
+    activation_code: z.string({description: "Faucet Activation Code"}).min(1)
 }).describe("Faucet")
 
 const internalSchema = z.object({

package/HumanReadableIdentifier.ts

@@ -7,7 +7,7 @@ export const rawSchema = z
 
 type RawInput = z.infer<typeof rawSchema>    
 
-const {schemas: generatedSchemas, factory} = createType<RawInput>({
+const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is not a valid human-readable identifier`,

package/InstalledPlugin.ts

@@ -2,7 +2,7 @@ import {z} from 'zod'
 import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z.object({
-    name: z.string({description: "Plugin Name"}).nonempty(),
+    name: z.string({description: "Plugin Name"}).min(1),
     type: z.union(
         [z.literal('npm'), z.literal('binary'), z.literal('deno')],
         {description: "Plugin Type"}
@@ -11,7 +11,7 @@ export const rawSchema = z.object({
 
 type RawInput = z.infer<typeof rawSchema>
 
-export const {schemas, factory} = createType<RawInput>({
+export const {schemas, factory} = createType<RawInput, RawInput>({
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is not a valid installed plugin`,
     unknownErrMsg: "Something went wrong when parsing the installed plugin"

package/LoadedConfig.ts

@@ -17,7 +17,7 @@ export const internalSchema = Config.internalSchema.extend({
 }).describe("LoadedConfig")
 
 type RawInput = z.infer<typeof rawSchema>
-type Input = z.infer<typeof internalSchema>
+type Input = Flatten<z.infer<typeof internalSchema>>
 
 export const {schemas: generatedSchemas, factory} = createType<RawInput, Input>({
     rawSchema,

package/NetworkConfig.ts

@@ -9,7 +9,7 @@ export const rawSchema = z.object({
     label: HumanReadableIdentifier.rawSchema,
     rpcUrl: Url.rawSchema,
     protocol: EconomicalProtocolHash.rawSchema,
-    facuet: Faucet.rawSchema.describe("Network Faucet")
+    faucet: Faucet.rawSchema.describe("Network Faucet")
 }).describe("Network Config")
 
 const internalSchema = z.object({

package/Option.ts

@@ -6,7 +6,7 @@ import createType, {Flatten} from "@taqueria/protocol/Base"
 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"}).nonempty(),
+    description: z.string({description: "Option Description"}).min(1),
     defaultValue: z.union(
         [z.string(), z.number(), z.boolean()],
         {description: "Option Default Value"}
@@ -22,7 +22,7 @@ export const internalSchema = z.object({
 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"}).nonempty(),
+    description: z.string({description: "Option Description"}).min(1),
     defaultValue: z.union(
         [z.string(), z.number(), z.boolean()],
         {description: "Option Default Value"}

package/PluginInfo.ts

@@ -6,7 +6,7 @@ import * as Operation from '@taqueria/protocol/Operation'
 import createType, {Flatten} from "@taqueria/protocol/Base"
 
 export const internalSchema = z.object({
-    name: z.string({description: "Plugin Name"}).nonempty(),
+    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"),
@@ -27,7 +27,7 @@ export const internalSchema = z.object({
 }).describe("Plugin Schema")
 
 export const rawSchema = z.object({
-    name: z.string({description: "Plugin Name"}).nonempty(),
+    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"),

package/PositionalArg.ts

@@ -4,7 +4,7 @@ import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z.object({
     placeholder: HumanReadableIdentifier.rawSchema.describe("Positional Arg Placeholder"),
-    description: z.string({description: "Positional Arg Description"}).nonempty(),
+    description: z.string({description: "Positional Arg Description"}).min(1),
     defaultValue: z.union(
         [z.string(), z.number(), z.boolean()],
         {description: "Positional Arg Default Value"}
@@ -17,7 +17,7 @@ export const rawSchema = z.object({
 
 const internalSchema = z.object({
     placeholder: HumanReadableIdentifier.schemas.schema.describe("Positional Arg Placeholder"),
-    description: z.string({description: "Positional Arg Description"}).nonempty(),
+    description: z.string({description: "Positional Arg Description"}).min(1),
     defaultValue: z.union(
         [z.string(), z.number(), z.boolean()],
         {description: "Positional Arg Default Value"}

package/Provisioner.ts

@@ -7,12 +7,12 @@ export const rawSchema = z.object(
         id: ProvisionerID.rawSchema,
         plugin: z
             .string()
-            .nonempty()
+            .min(1)
             .describe("Provisioner Plugin")
             .optional(),
         operation: z
             .union([
-                z.string().nonempty(),
+                z.string().min(1),
                 z.literal('custom')
             ])
             .describe("Provisioner Operation"),

package/ProvisionerID.ts

@@ -3,13 +3,13 @@ import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z
     .string()
-    .nonempty()
+    .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, factory} = createType<RawInput>({
+export const {schemas, 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"

package/PublicKeyHash.ts

@@ -3,7 +3,7 @@ import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z
     .string({description: "Public Key Hash"})
-    .nonempty()
+    .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`}) 
@@ -11,7 +11,7 @@ export const rawSchema = z
 
 type RawInput = z.infer<typeof rawSchema>
 
-export const {schemas: generatedSchemas, factory} = createType<RawInput>({
+export const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is an invalid public key hash`,

package/SHA256.ts

@@ -14,7 +14,7 @@ export const rawSchema = z.string({description: "SHA256"}).length(64)
 
 type RawInput = z.infer<typeof rawSchema>
 
-const {schemas: generatedSchemas, factory} = createType<RawInput>({
+const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is an invalid SHA256 hash`,

package/SandboxAccountConfig.ts

@@ -3,15 +3,15 @@ import * as PublicKeyHash from "@taqueria/protocol/PublicKeyHash"
 import createType from "@taqueria/protocol/Base"
 
 const internalSchema = z.object({
-    encryptedKey: z.string({description: "Sandbox Account Encrypted Key"}).nonempty(),
+    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"}).nonempty()
+    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"}).nonempty(),
-    publicKeyHash: z.string({description: "Sandbox Account Public Key Hash"}).nonempty(),
-    secretKey: z.string({description: "Sandbox Account Secret Key"}).nonempty()
+    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>

package/SandboxConfig.ts

@@ -14,9 +14,9 @@ const accountMapSchema = z.record(
 )
 
 export const rawSchema = z.object({
-    label: z.string({description: "Sandbox Label"}).nonempty(),
-    rpcUrl: z.string({description: "Sandbox RPC Url"}).nonempty().url(),
-    protocol: z.string({description: "Sandbox Protocol Hash"}).nonempty(),
+    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()],
@@ -26,7 +26,7 @@ export const rawSchema = z.object({
     ).optional(),
     plugin: Verb.rawSchema.describe("Sandbox Plugin").optional(),
     accounts: z.union([
-        z.object({default: z.string().nonempty()}),
+        z.object({default: z.string().min(1)}),
         z.record(SandboxAccountConfig.rawSchema)
     ], {description: "Sandbox Accounts"}).optional()
 })

package/SanitizedAbsPath.ts

@@ -2,11 +2,11 @@ import {z} from "zod"
 import * as path from 'path'
 import createType from "@taqueria/protocol/Base"
 
-export const rawSchema = z.string({description: "SanitizedAbsPath"}).nonempty()
+export const rawSchema = z.string({description: "SanitizedAbsPath"}).min(1)
 
 type RawInput = z.infer<typeof rawSchema>
 
-export const {schemas: generatedSchemas, factory} = createType<RawInput>({
+export const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     transformer: (value: unknown) => path.resolve(value as string) as unknown,

package/SanitizedArgs.ts

@@ -4,7 +4,7 @@ import * as Url from "@taqueria/protocol/Url"
 import createType from "@taqueria/protocol/Base"
 
  export const rawSchema =  z.object({
-    _: z.array(z.union([z.string().nonempty(), z.number()])),
+    _: z.array(z.union([z.string().min(1), z.number()])),
     projectDir: SanitizedAbsPath.schemas.schema,
     maxConcurrency: z.preprocess(
         val => typeof val === 'string' ? parseInt(val) : Number(val),
@@ -42,29 +42,29 @@ import createType from "@taqueria/protocol/Base"
         val => Boolean(val),
         z.boolean().optional()
     ),
-    plugin: z.string().nonempty().optional(),
+    plugin: z.string().min(1).optional(),
     env: z.union([z.literal('production'), z.literal('testing'), z.literal('development'), z.string().nonempty()]).default("development"),
-    quickstart: z.string().nonempty().optional(),
-    setBuild: z.string().nonempty(),
-    setVersion: z.string().nonempty(),
-    template: z.string().nonempty().optional(),
-    pluginName: z.string().nonempty().optional()
+    quickstart: z.string().min(1).optional(),
+    setBuild: z.string().min(3),
+    setVersion: z.string().min(3),
+    template: z.string().min(1).optional(),
+    pluginName: z.string().min(1).optional()
 }, {description: "Sanitizied Args"}).passthrough()
 
 export const scaffoldRawSchema = rawSchema.extend({
-    scaffoldProjectDir: z.string().nonempty().transform((val: unknown) => val as SanitizedAbsPath.t),
-    scaffoldUrl: z.string().nonempty().url().transform((val: unknown) => val as Url.t),
+    scaffoldProjectDir: z.string().min(1).transform((val: unknown) => val as SanitizedAbsPath.t),
+    scaffoldUrl: z.string().min(1).url().transform((val: unknown) => val as Url.t),
 })
 
 export const provisionRawSchema = rawSchema
     .extend({
         operation: z
             .string()
-            .nonempty()
+            .min(1)
             .describe("Operation name"),
         name: z
             .string()
-            .nonempty()
+            .min(1)
             .regex(/^[a-z0-9]+[a-z0-9-_]$/, "Provisioner name must consist of one or more letters/numbers and may not start with an underscore or dash.")
             .describe("Provisioner name")
             .optional()
@@ -72,7 +72,7 @@ export const provisionRawSchema = rawSchema
     .passthrough()
 
 export const managePluginRawSchema = rawSchema.omit({pluginName: true}).extend({
-    pluginName: z.string().nonempty()
+    pluginName: z.string().min(1)
 })
 
 export const versionRawSchema = rawSchema.extend({
@@ -85,7 +85,7 @@ type RawProvisionInput = z.infer<typeof provisionRawSchema>
 type RawManagePluginInput = z.infer<typeof managePluginRawSchema>
 type RawVersionInput = z.infer<typeof versionRawSchema>
 
-export const {schemas, factory} = createType<RawInput>({
+export const {schemas, factory} = createType<RawInput, RawInput>({
     rawSchema,
     parseErrMsg: "The arguments provided are invalid",
     unknownErrMsg: "Something went wrong parsing the command-line arguments"
@@ -96,25 +96,25 @@ export const {create, of, make} = factory
 export type SanitizedArgs = z.infer<typeof schemas.schema>
 export type t = SanitizedArgs
 
-export const scaffoldTaskArgs = createType<RawScaffoldInput>({
+export const scaffoldTaskArgs = createType<RawScaffoldInput, RawScaffoldInput>({
     rawSchema: scaffoldRawSchema,
     parseErrMsg: "The arguments provided are invalid for the scaffold task",
     unknownErrMsg: "Something went wrong parsing the arguments for the scaffold task"
 })
 
-export const provisionTaskArgs = createType<RawProvisionInput>({
+export const provisionTaskArgs = createType<RawProvisionInput, RawProvisionInput>({
     rawSchema: provisionRawSchema,
     parseErrMsg: "The arguments provided are invalid for the provision task",
     unknownErrMsg: "Something went wrong parsing the arguments for the provision task"
 })
 
-export const installTaskArgs = createType<RawManagePluginInput>({
+export const installTaskArgs = createType<RawManagePluginInput, RawManagePluginInput>({
     rawSchema: managePluginRawSchema,
     parseErrMsg: "The arguments provided are invalid for the install task",
     unknownErrMsg: "Something went wrong parsing the arguments for the install task"
 })
 
-export const uninstallTaskArgs = createType<RawManagePluginInput>({
+export const uninstallTaskArgs = createType<RawManagePluginInput, RawManagePluginInput>({
     rawSchema: managePluginRawSchema,
     parseErrMsg: "The arguments provided are invalid for the uninstall task",
     unknownErrMsg: "Something went wrong parsing the arguments for the uninstall task"

package/SanitizedPath.ts

@@ -10,7 +10,7 @@ export const rawSchema = z
 
 type RawInput = z.infer<typeof rawSchema>
 
-const {schemas: generatedSchemas, factory} = createType<RawInput>({
+const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is an invalid filesystem path`,

package/SingleChar.ts

@@ -7,7 +7,7 @@ export const rawSchema = z
 
 type RawInput = z.infer<typeof rawSchema>
 
-export const {factory, schemas: generatedSchemas} = createType<RawInput>({
+export const {factory, schemas: generatedSchemas} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is not a single character`,

package/Task.ts

@@ -4,7 +4,7 @@ import * as Alias from "@taqueria/protocol/Alias"
 import * as Command from '@taqueria/protocol/Command'
 import * as Option from '@taqueria/protocol/Option'
 import * as PositionalArg from '@taqueria/protocol/PositionalArg'
-import createType from "@taqueria/protocol/Base"
+import createType, {Flatten} from "@taqueria/protocol/Base"
 
 const taskEncodingSchema = z.preprocess(
     (val: unknown) => val ?? 'none',
@@ -24,7 +24,7 @@ export const rawSchema = z.object({
     task: Verb.rawSchema.describe("Task Name"),
     command: Command.rawSchema.describe("Task Command"),
     aliases: z.array(Alias.rawSchema).default([]).describe("Task Aliases").optional(),
-    description: z.string({description: "Task Description"}).nonempty(),
+    description: z.string({description: "Task Description"}).min(3),
     example: z.string({description: "Task Example"}).optional(),
     hidden: z.boolean({description: "Task Is Hidden"}).default(false).optional(),
     encoding: taskEncodingSchema.describe("Task Encoding"),
@@ -37,12 +37,15 @@ const internalSchema = z.object({
     task: Verb.schemas.schema.describe("Task Name"),
     command: Command.schemas.schema.describe("Task Command"),
     aliases: z.array(Alias.rawSchema).default([]).describe("Task Aliases").optional(),
-    description: z.string({description: "Task Description"}).nonempty(),
+    description: z.string({description: "Task Description"}).min(3),
     example: z.string({description: "Task Example"}).optional(),
     hidden: z.boolean({description: "Task Is Hidden"}).default(false).optional(),
     encoding: taskEncodingSchema.describe("Task Encoding"),
     handler: taskHandlerSchema.describe("Task Handler"),
-    options: z.array(Option.schemas.schema).default([]).describe("Task Options").optional(),
+    options: z.preprocess(
+        val => val ?? [],
+        z.array(Option.schemas.schema).describe("Task Options").optional(),
+    ),
     positionals: z.array(PositionalArg.schemas.schema).default([]).describe("Task Positional Args").optional()
 }).describe("Task")
 
@@ -61,5 +64,5 @@ export type t = Task
 export const {create, make, of} = factory
 export const schemas = {
     ...generatedSchemas,
-    schema: generatedSchemas.schema.transform(val => val as unknown as Task)
+    // schema: generatedSchemas.schema.transform(val => val as unknown as Task)
 }

package/Tz.ts

@@ -1,11 +1,11 @@
 import {z} from 'zod'
 import createType from "@taqueria/protocol/Base"
 
-export const rawSchema = z.string({description: "Tz"}).nonempty().regex(/^\d([\d_]+\d)?$/)
+export const rawSchema = z.string({description: "Tz"}).min(1).regex(/^\d([\d_]+\d)?$/)
 
 type RawInput = z.infer<typeof rawSchema>
 
-export const {schemas, factory} = createType<RawInput>({
+export const {schemas, factory} = createType<RawInput, RawInput>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is an invalid Tz amount`,

package/Url.ts

@@ -7,7 +7,7 @@ export const rawSchema = z
 
 type RawInput = z.infer<typeof rawSchema>    
 
-export const {schemas: generatedSchemas, factory} = createType<RawInput>({
+export const {schemas: generatedSchemas, factory} = createType<RawInput, RawInput>({
     rawSchema,
     isStringLike: true,
     parseErrMsg: (value: unknown) => `${value} is an invalid url`,

package/Verb.ts

@@ -3,12 +3,12 @@ import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z
     .string({description: "Verb"})
-    .nonempty("Must be a valid verb")
+    .min(1, "Must be a valid verb")
     .regex(/^[A-Za-z\-\ ]+/, "Must be a valid verb")
 
 type Input = z.infer<typeof rawSchema>
 
-export const {factory, schemas: generatedSchemas} = createType<Input>({
+export const {factory, schemas: generatedSchemas} = createType<Input, Input>({
     isStringLike: true,
     rawSchema,
     parseErrMsg: (value: unknown) => `${value} is not an invalid verb`,

package/VersionNumber.ts

@@ -2,7 +2,7 @@ import {z} from 'zod'
 import createType from "@taqueria/protocol/Base"
 
 export const rawSchema = z.string({description: "Version Number"})
-    .nonempty()
+    .min(1)
     .regex(/^\d+\.\d+(\.\d+)*$/)
 
 

package/package.json

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