@taqueria/protocol 0.0.0-pr-783-7fc9978a → 0.0.0-pr-776-b4c3aaa5

package/Base.ts

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

package/Config.ts

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

package/LoadedConfig.ts

@@ -4,17 +4,25 @@ 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.extend({
-    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
+    .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.extend({
-    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
+    .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>>

package/PersistentState.ts

@@ -1,22 +1,50 @@
 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: z.number().min(1651846877).describe("state.op.time"),
+    time: Timestamp.rawSchema.describe("state.op.time"),
     output: z.unknown().describe("state.op.output")
-}).describe("Persistent State Operation") 
+}).describe("Persistent State Operation")
+
+const rawTaskSchema = z.object({
+    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: z.number().min(1651846877).describe("state.op.time"),
+    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 const rawSchema = z.record(rawOpSchema)
+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.record(internalOpSchema)
+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>
 

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().nonempty()
+    task: z.string().min(1)
 }).describe("ProxyRequestArgs").passthrough()
 
 const internalProxySchema = internalSchema.extend({
-    task: z.string().nonempty()
+    task: z.string().min(1)
 }).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.create
+export const createProxyRequestArgs = proxyFactory.from
 export const makeProxyRequestArgs = proxyFactory.make
 export const ofProxyRequestArgs = proxyFactory.of
-export const {create, of, make} = factory
+export const {create, make, of, from} = factory

package/SanitizedArgs.ts

@@ -45,7 +45,10 @@ import createType from "@taqueria/protocol/Base"
     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().min(1).optional(),
-    setBuild: z.string().min(3),
+    setBuild: z.preprocess(
+        val => String(val),
+        z.string().min(3)
+    ),
     setVersion: z.string().min(3),
     template: z.string().min(1).optional(),
     pluginName: z.string().min(1).optional()
@@ -125,7 +128,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.create
+export const createScaffoldTaskArgs = scaffoldTaskArgs.factory.from
 export const makeScaffoldTaskArgs = scaffoldTaskArgs.factory.make
 export const ofScaffoldTaskArgs = scaffoldTaskArgs.factory.of
 

package/Task.ts

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

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

package/package.json

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