@taqueria/protocol 0.0.0-pr-777-5c993a93 → 0.0.0-pr-779-eaf2ca6a

package/Base.ts

@@ -58,7 +58,7 @@ export const createType = <R, I>(params: CreateTypeParams) => {
 
     type T = z.infer<typeof schemas.schema>
 
-    const internalOf = (input: unknown) => {
+    const of = (input: R | I | unknown) => {
         try {
             return resolve<T>(schemas.schema.parse(input))
         }
@@ -77,19 +77,15 @@ export const createType = <R, I>(params: CreateTypeParams) => {
             return toFutureParseUnknownErr<T>(previous, unknownMsg, input)
         }
     }
-    const of = internalOf
 
-    const make = (input: I) => internalOf(input)
+    const make = (input: I) => of(input)
 
-    const create = (input: R | I) => schemas.schema.parse(input) as T
-
-    const from = (input: unknown) => schemas.schema.parse(input) as T
+    const create = (input: R | I | unknown) => schemas.schema.parse(input) as T
 
     const factory = {
         make,
         of,
-        create,
-        from
+        create
     }
 
     return {

package/Config.ts

@@ -6,20 +6,6 @@ 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"}
-    )
-)
-
-export const pluginsInternalSchema = z.preprocess(
-    val => val ?? [],
-    z.array(
-        InstalledPlugin.schemas.schema, {description: "config.plugins"}
-    )
-)
-
 const networkMap = z
     .record(
         z.union([
@@ -46,7 +32,8 @@ const environmentMap = z
     .record(
         z.union([
             Environment.schemas.schema,
-            z.string().min(1, "Default environment must reference the name of an existing environment.")
+            z.string({description: "config.environment"})
+            .min(1, "Default environment must reference the name of an existing environment.")
         ]),
         {description: "Environment configurations"}
     )
@@ -65,15 +52,20 @@ const accountsMap = z.preprocess(
 )
 
 const commonSchema = z.object({
-    language: z.preprocess(
-        val => val ?? 'en',
-        z.union([
-            z.literal('en'),
-            z.literal('fr')
-        ], {description: "config.language"})
+    language: z
+        .union([z.literal('en'), z.literal('fr')], {description: "config.language"})
+        .optional()
+        .transform((val?: 'en' | 'fr' | string) => val ?? 'en'),
+    plugins: z
+        .array(InstalledPlugin.schemas.schema, {description: "config.plugins"})
         .optional()
-    ),
-    plugins: pluginsInternalSchema.optional(),
+        .transform((val: unknown) => (val ?? []) as InstalledPlugin.t[]),
+    testsDir: z
+        .preprocess(
+            (val: unknown) => val ?? "tests",
+            z.string({description: "config.testsDir"})
+            .min(1, "config.testsDir must have a value")
+        ),
     contractsDir: z
         .preprocess(
             (val: unknown) => val ?? "contracts",
@@ -96,7 +88,6 @@ export const internalSchema = commonSchema.extend({
 })
 
 export const rawSchema = commonSchema.extend({
-    plugins: pluginsRawSchema.optional(),
     network: z
         .record(
             z.union([
@@ -132,7 +123,7 @@ export const rawSchema = commonSchema.extend({
         .optional()
 }).describe("config")
 
-type RawInput = z.infer<typeof rawSchema>
+type RawInput = Flatten<z.infer<typeof rawSchema>>
 type Input = z.infer<typeof internalSchema>
 
 export const {schemas, factory} = createType<RawInput, Input>({

package/Environment.ts

@@ -28,6 +28,6 @@ export const {schemas, factory} = createType<RawInput, RawInput>({
 export type Environment = Flatten<z.infer<typeof schemas.schema>>
 export type t = Environment
 
-export const {create, make, of, from} = factory
+export const {create, make, of} = factory
 
 export const {internalSchema} = schemas

package/LoadedConfig.ts

@@ -4,25 +4,17 @@ import * as SanitizedAbsPath from '@taqueria/protocol/SanitizedAbsPath'
 import * as SHA256 from '@taqueria/protocol/SHA256'
 import createType, {Flatten} from "@taqueria/protocol/Base"
 
-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 rawSchema = Config.rawSchema.extend({
+    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")
+export const internalSchema = Config.internalSchema.extend({
+    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>>

package/PersistentState.ts

@@ -1,50 +1,22 @@
 import {z} from "zod"
-import * as Verb from "@taqueria/protocol/Verb"
 import * as SHA256 from "@taqueria/protocol/SHA256"
-import * as Timestamp from "@taqueria/protocol/Timestamp"
 import createType from "@taqueria/protocol/Base"
 
 const rawOpSchema = z.object({
     hash: SHA256.rawSchema.describe("state.op.hash"),
-    time: Timestamp.rawSchema.describe("state.op.time"),
+    time: z.number().min(1651846877).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')
-})
+}).describe("Persistent State Operation") 
 
 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"),
+    time: z.number().min(1651846877).describe("state.op.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 rawSchema = z.record(rawOpSchema)
 
-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>
-}))
+export const internalSchema = z.record(internalOpSchema)
 
 type RawInput = z.infer<typeof rawSchema>
 

package/RequestArgs.ts

@@ -43,11 +43,11 @@ export type RequestArgs = z.infer<typeof schemas.schema>
 export type t = RequestArgs
 
 const rawProxySchema = rawSchema.extend({
-    task: z.string().min(1)
+    task: z.string().nonempty()
 }).describe("ProxyRequestArgs").passthrough()
 
 const internalProxySchema = internalSchema.extend({
-    task: z.string().min(1)
+    task: z.string().nonempty()
 }).describe("ProxyRequestArgs").passthrough()
 
 type RawProxyInput = z.infer<typeof rawProxySchema>
@@ -65,7 +65,7 @@ export const proxyFactory = proxy.factory
 
 export type ProxyRequestArgs = z.infer<typeof proxySchemas.schema>
 
-export const createProxyRequestArgs = proxyFactory.from
+export const createProxyRequestArgs = proxyFactory.create
 export const makeProxyRequestArgs = proxyFactory.make
 export const ofProxyRequestArgs = proxyFactory.of
-export const {create, make, of, from} = factory
+export const {create, of, make} = factory

package/SanitizedArgs.ts

@@ -125,7 +125,7 @@ export type ProvisionTaskArgs = z.infer<typeof provisionTaskArgs.schemas.schema>
 export type InstallTaskArgs = z.infer<typeof installTaskArgs.schemas.schema>
 export type UninstallTaskArgs = z.infer<typeof uninstallTaskArgs.schemas.schema>
 
-export const createScaffoldTaskArgs = scaffoldTaskArgs.factory.from
+export const createScaffoldTaskArgs = scaffoldTaskArgs.factory.create
 export const makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make
 export const ofScaffoldTaskArgs = scaffoldTaskArgs.factory.of
 

package/Task.ts

@@ -18,10 +18,7 @@ const taskEncodingSchema = z.preprocess(
     .optional()
 )
 
-const taskHandlerSchema = z.union([
-    z.literal('proxy'),
-    z.string().min(1),
-])
+const taskHandlerSchema = z.union([z.literal('proxy'), z.string()])
 
 export const rawSchema = z.object({
     task: Verb.rawSchema.describe("Task Name"),
@@ -67,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/i18n.ts

@@ -19,7 +19,7 @@ export default async (): Promise<i18n> => {
                         "appName": "Taqueria",
                         "appDesc": "Taqueria is an integrated environment for compiling, testing, and deploying Tezos software.",
                         "versionDesc": "Display the verison number of the Taqueria program",
-                        "betaWarning": "Taqueria is currently in BETA. You've been warned. :)",
+                        "betaWarning": "🚧 Taqueria is currently in BETA. You've been warned! 🚧",
                         "configDirDesc": "Config directory (default ./.taq)",
                         "initDesc": "Initialize a new project",
                         "initPathDesc": "Path to your project directory",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taqueria/protocol",
-  "version": "0.0.0-pr-777-5c993a93",
+  "version": "0.0.0-pr-779-eaf2ca6a",
   "description": "A TypeScript package which contains types that are to be shared between @taqueria/node-sdk and @taqueria/taqueria.",
   "main": "index.js",
   "scripts": {

package/Timestamp.ts

@@ -1,25 +0,0 @@
-import {z} from 'zod'
-import createType from "@taqueria/protocol/Base"
-
-export const rawSchema = z
-    .number({description: "Timestamp"})
-    .min(1651846877)
-
-type Input = z.infer<typeof rawSchema>
-
-export const {factory, schemas: generatedSchemas} = createType<Input, Input>({
-    isStringLike: true,
-    rawSchema,
-    parseErrMsg: (value: unknown) => `${value} is an invalid timestamp`,
-    unknownErrMsg: `Something went wrong trying to parse a timestamp`
-})
-
-export type Timestamp = z.infer<typeof generatedSchemas.schema>
-export type t = Timestamp
-export const {create, make, of} = factory
-export const schemas = {
-    ...generatedSchemas,
-    schema: generatedSchemas.schema.transform(val => val as Timestamp)
-}
-
-export const now = () => Date.now() as Timestamp