@taqueria/protocol 0.0.0-pr-436-0c8bb7b1 → 0.0.0-pr-659-ec26fd9f

package/Alias.ts

@@ -0,0 +1,34 @@
+import {z, ZodError} from "zod"
+import * as Verb from '@taqueria/protocol/Verb'
+import * as SingleChar from '@taqueria/protocol/SingleChar'
+import {resolve, reject} from "fluture"
+import {toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+
+export const internalSchema = z
+    .union([Verb.schema, SingleChar.schema], {description: "Alias"})
+
+export const rawSchema = z
+    .union([Verb.rawSchema, SingleChar.rawSchema], {description: "Alias"})
+
+const aliasType: unique symbol = Symbol("Alias")
+
+export type Alias = string & {
+    readonly [aliasType]: void
+}
+
+export type t = Alias    
+    
+export const schema = internalSchema.transform((val: unknown) => val as Alias)
+
+export const make = (value: string) => {
+    try {
+        const alias = schema.parse(value)
+        return resolve(alias)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<Alias>(err, `${value} is not a valid alias`, value)
+        }
+        return toParseUnknownErr<Alias>(err, 'Something went wrong trying to parse an alias', value)
+    }
+}

package/Command.ts

@@ -0,0 +1,33 @@
+import {z, ZodError} from 'zod'
+import {resolve, reject, mapRej} from "fluture"
+import {TaqError, toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+
+export const rawSchema = z
+    .string({description: "Command"})
+    .regex(/^([A-Za-z-_ ]+ ?)((\[.+\] ?)|(\<.+\>) ?)*$/, "Must be a command that can be interpreted using yargs")
+
+export const schema = rawSchema.transform(val => val as Command)
+
+const commandType: unique symbol = Symbol("Command")
+
+export type Command = string & {
+    readonly [commandType]: void
+}
+
+export type t = Command
+
+export const make = (value: string) => {
+    try {
+        const retval = schema.parse(value)
+        return resolve(retval)
+            .pipe(mapRej(err => err as TaqError))
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<Command>(err, `${value} is not a valid command`, value)
+        }
+        return toParseUnknownErr<Command>(err, 'There was a problem trying to parse the command', value)
+    }
+}
+
+export const create = (value: string) => schema.parse(value)

package/Config.ts

@@ -0,0 +1,168 @@
+import {z, ZodError} 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 {toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+import {resolve, reject} from "fluture"
+
+const networkMap = z
+    .record(
+        z.union([
+            NetworkConfig.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.schema,
+            z.string({description: "config.sandbox"})
+            .nonempty("Default sandbox must reference the name of an existing sandbox configuration.")
+        ]),
+        {description: "Sandbox configurations"}
+    )
+    .optional()
+
+const environmentMap = z
+    .record(
+        z.union([
+            Environment.schema,
+            z.string({description: "config.environment"})
+            .nonempty("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"}
+    )
+)
+
+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.schema, {description: "config.plugins"})
+        .optional()
+        .transform((val: unknown) => val ?? ([] as InstalledPlugin.t[])),
+    testsDir: z
+        .preprocess(
+            (val: unknown) => val ?? "tests",
+            z.string({description: "config.testsDir"})
+            .nonempty("config.testsDir must have a value")
+            .optional()
+        ),
+    contractsDir: z
+        .preprocess(
+            (val: unknown) => val ?? "contracts",
+            z.string({description: "config.contractsDir"})
+            .nonempty("config.contractsDir must have a value")
+            .optional()
+        ),
+    artifactsDir: z
+        .preprocess(
+            (val: unknown) => val ?? "artifacts",
+            z.string({description: "config.artifactsDir"})
+            .nonempty("config.artifactsDir must have a value")
+            .optional()
+        ),
+    operationsDir: z
+        .preprocess(
+            (val: unknown) => val ?? "operations",
+            z.string({description: "config.operationsDir"})
+            .nonempty("config.operationsDir must have a value")
+            .optional()
+        )
+}).describe("config")
+
+export const internalSchema = commonSchema.extend({
+    network: networkMap,
+    sandbox: sandboxMap,
+    environment: environmentMap,
+    accounts: accountsMap
+})
+
+export const rawSchema = commonSchema.extend({
+    network: z
+        .record(
+            z.union([
+                NetworkConfig.rawSchema,
+                z.string({description: "config.network"})
+                .nonempty("Default network must reference the name of an  existing network configuration.")
+            ])
+        )
+        .optional(),
+    sandbox: z
+        .record(
+            z.union([
+                SandboxConfig.rawSchema,
+                z.string({description: "config.sandbox"})
+                .nonempty("Default sandbox must reference the name of an existing sandbox configuration.")
+            ])
+        )
+        .optional(),
+    environment: z
+        .record(
+            z.union([
+                Environment.rawSchema,
+                z.string({description: "config.environment"})
+            .nonempty("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")
+
+export const schema = internalSchema.transform((val: unknown) => val as t)
+
+const configType: unique symbol = Symbol("Config")
+
+type Input = z.infer<typeof internalSchema>
+
+type RawInput = z.infer<typeof rawSchema>
+
+export type t = Input & {
+    readonly [configType]: void
+    readonly contractsDir: string
+    readonly artifactsDir: string
+    readonly testsDir: string
+    readonly plugins: InstalledPlugin.t[]
+}
+
+export type Config = t
+
+export const make = (data: Input) => {
+    try {
+        const retval = schema.parse(data)
+        return resolve(retval)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<Config>(err, `The provided config is invalid.`, data)
+        }
+        return toParseUnknownErr<Config>(err, 'There was a problem trying to parse the Taqueria configuration', data)
+    }
+}
+
+export const create = (data: RawInput | Record<string, unknown>) => schema.parse(data)

package/Crypto.ts

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

package/EconomicalProtocolHash.ts

@@ -0,0 +1,32 @@
+import {z, ZodError} from 'zod'
+import {resolve, reject} from "fluture"
+import {toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+
+const protocolHashType: unique symbol = Symbol("EconomicalProtocolHash")
+
+export const schema = 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`})
+    )
+    .transform(val => val as EconomicalProtocolHash)
+
+export type EconomicalProtocolHash = string & {
+    readonly [protocolHashType]: void
+}
+
+export type t = EconomicalProtocolHash
+
+export const make = (value: string) => {
+    try {
+        const retval = schema.parse(value)
+        return resolve(retval)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<EconomicalProtocolHash>(err, `${value} is not a valid economical protocol hash`, value)
+        }
+        return toParseUnknownErr<EconomicalProtocolHash>(err, "There was a problem trying to parse the economical protocol", value)
+    }
+}

package/Environment.ts

@@ -0,0 +1,44 @@
+import {z, ZodError} from 'zod'
+import {reject, resolve} from "fluture"
+import {toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+
+export const rawSchema = z.object({
+    networks: z.array(
+        z.string({description: "Environment network"})
+        .nonempty("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")
+    ),
+    storage: z.record(
+        z.any({description: "Environment storage value"}),
+        {description: "Environment storage"}
+    )
+    .optional()
+}).describe("Environment Config")
+
+export const schema = rawSchema.transform(val => val as Environment)
+
+const envType: unique symbol = Symbol("Environment")
+
+type Input = z.infer<typeof rawSchema>
+
+export type Environment = Input & {
+    readonly [envType]: void
+}
+
+export type t = Environment
+
+export const make = (value: Input) => {
+    try {
+        const retval = schema.parse(value)
+        return resolve(retval)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<Environment>(err, `The provided environment is invalid`, value)
+        }
+        return toParseUnknownErr<Environment>(err, "There was a problem trying to parse the environment configuration", value)
+    }
+}

package/EphermalState.ts

@@ -0,0 +1,209 @@
+import {z, ZodError} from 'zod'
+import {FutureInstance as Future, resolve, mapRej, attemptP, promise} from "fluture"
+import {TaqError, toParseErr, toParseUnknownErr, E_TaqError} from "@taqueria/protocol/TaqError"
+import * as InstalledPlugin from "@taqueria/protocol/InstalledPlugin"
+import * as Command from "@taqueria/protocol/Command"
+import * as Option from '@taqueria/protocol/Option'
+import * as Verb from "@taqueria/protocol/Verb"
+import * as Task from '@taqueria/protocol/Task'
+import * as ParsedOperation from '@taqueria/protocol/ParsedOperation'
+import * as ParsedPluginInfo from '@taqueria/protocol/ParsedPluginInfo'
+import * as Config from "@taqueria/protocol/Config"
+import type {i18n} from "@taqueria/protocol/i18n"
+
+const eager = <T>(f: Future<TaqError, T>) => promise (
+    mapRej
+    ((err: TaqError) => new E_TaqError(err))
+    (f)
+)
+
+const taskToPluginMap = z.record(
+    z.union([
+        InstalledPlugin.schema,
+        Task.schema
+    ], {description: "Task/Plugin Mapping"})
+)
+const operationToPluginMap = z.record(
+    z.union([
+        InstalledPlugin.schema,
+        ParsedOperation.schema
+    ], {description: "Operation/Plugin Mapping"})
+)
+
+const internalSchema = z.object({
+    build: z.string({description: "cache.build"}),
+    configHash: z.string({description: "cache.configHash"}),
+    tasks: taskToPluginMap,
+    operations: operationToPluginMap,
+    plugins: z.array(ParsedPluginInfo.schema, {description: "cache.plugins"})
+}).describe("Ephermal State")
+
+export const schema = internalSchema.transform(val => val as EphemeralState)
+
+const ephemeralStateType: unique symbol = Symbol("EphemeralState")
+
+export type Input = z.infer<typeof internalSchema>
+
+export type EphemeralState = Input & {
+    readonly [ephemeralStateType]: void
+}
+
+export type t = EphemeralState
+
+export type TaskToPluginMap = z.infer<typeof taskToPluginMap>
+
+export type OpToPluginMap = z.infer<typeof operationToPluginMap>
+
+export const make = (value: Input) => {
+    try {
+        const retval = schema.parse(value)
+        return resolve(retval)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<EphemeralState>(err, `The ephermal state is invalid`, value)
+        }
+        return toParseUnknownErr<EphemeralState>(err, `Something went wrong trying to parse the ephermal state`, value)
+    }
+}
+
+
+/**
+ * Private functions
+ */
+type Counts = Record<Verb.t, ParsedPluginInfo.t[]>
+const getTaskCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
+    return pluginInfo.reduce(
+        (retval, pluginInfo) => pluginInfo.tasks === undefined
+        ? {}
+        : pluginInfo.tasks.reduce(
+            (retval: Counts, task: Task.t) => {
+                const taskName = task.task
+                const providers: ParsedPluginInfo.t[] = retval[taskName]
+                    ? [...retval[taskName], pluginInfo]
+                    : [pluginInfo]
+                const mapping: Counts = {}
+                mapping[taskName] = providers.filter(provider => provider !== undefined)
+                return {...retval, ...mapping}
+            },
+            retval
+        ),
+        ({} as Counts)
+    )
+}
+
+
+const getOperationCounts = (pluginInfo: ParsedPluginInfo.t[]): Counts => {
+    return pluginInfo.reduce(
+        (retval, pluginInfo) => pluginInfo.operations === undefined
+        ? retval
+        : pluginInfo.operations.reduce(
+            (retval: Counts, operation: ParsedOperation.t) => {
+                const operationName = operation.operation
+                const providers = retval[operationName]
+                    ? [...retval[operationName], pluginInfo]
+                    : [pluginInfo]
+                const mapping: Counts = {}
+                mapping[operationName] = providers.filter(provider => provider !== undefined)
+                return {...retval, ...mapping}
+            },
+            retval
+        ),
+        {} as Counts
+    )
+}
+
+const toChoices = (plugins: ParsedPluginInfo.t[]) => plugins.reduce(
+    (retval, pluginInfo) => {
+        return [...retval, pluginInfo.name as string, pluginInfo.alias as string]
+    },
+    [] as string[]
+)
+
+const isComposite = (name: Verb.t, counts: Counts) => counts[name].length > 1
+
+const getInstalledPlugin = (config: Config.t, name: string) => config.plugins?.find(
+    (plugin: InstalledPlugin.t) => [`taqueria-plugin-${name}`, name].includes(plugin.name)
+)
+
+
+export const mapTasksToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo.t[], i18n: i18n) => {
+    const taskCounts = getTaskCounts(pluginInfo)
+    return attemptP<TaqError, TaskToPluginMap>(async () => await pluginInfo.reduce(
+        async (retval, pluginInfo) => !pluginInfo.tasks
+            ? Promise.resolve({} as TaskToPluginMap)
+            : await pluginInfo.tasks.reduce(
+                async (retval, {task}) => {
+                    if (isComposite(task, taskCounts)) {
+                        const command = await eager (Command.make(task))
+                        const compositeTask = await eager (Task.make({
+                            task,
+                            command,
+                            description: i18n.__("providedByMany"),
+                            hidden: false,
+                            options: [
+                                await eager (Option.make({
+                                    flag: await eager (Verb.make("plugin")),
+                                    description: "Specify which plugin should be used to execute this task",
+                                    choices: toChoices(taskCounts[task]),
+                                    required: true
+                                }))
+                            ],
+                            handler: "proxy"
+                        }))
+                        return {...await retval, [task]: compositeTask}
+                    }
+
+                    // Task is provided by just a single plugin
+                    const installedPlugin = getInstalledPlugin(config, pluginInfo.name)
+                    return installedPlugin
+                        ? {...await retval, [task]: installedPlugin}
+                        : retval
+                },
+                retval
+            ),
+        Promise.resolve({} as TaskToPluginMap)
+    )).pipe(mapRej (rej => rej as TaqError))
+}
+
+export const mapOperationsToPlugins = (config: Config.t, pluginInfo: ParsedPluginInfo.t[], i18n: i18n) => {
+    const opCounts = getOperationCounts(pluginInfo)
+    return attemptP(async () => await pluginInfo.reduce(
+        async (retval, pluginInfo) => !pluginInfo.operations
+            ? Promise.resolve({} as OpToPluginMap)
+            : await pluginInfo.operations.reduce(
+                async (retval, {operation}) => {
+                    if (isComposite(operation, opCounts)) {
+                        const command = await eager (Command.make(operation))
+                        const compositeOp = await eager (ParsedOperation.make({
+                            operation,
+                            command,
+                            description: i18n.__("providedByMany"),
+                            options: [
+                                await eager (Option.make({
+                                    flag: await eager (Verb.make("plugin")),
+                                    description: "Specify which plugin should be used to execute this operation",
+                                    choices: toChoices(opCounts[operation]),
+                                    required: true
+                                }))
+                            ]
+                        }))
+                        return {...await retval, [operation]: compositeOp}
+                    }
+
+                    // Operation is provided by just a single plugin
+                    const installedPlugin = getInstalledPlugin(config, pluginInfo.name)
+                    return installedPlugin
+                        ? {...await retval, [operation]: installedPlugin}
+                        : retval
+                },
+                retval
+            ),
+        Promise.resolve({} as OpToPluginMap)
+    )).pipe(mapRej (rej => rej as TaqError))
+}
+
+export const getTasks = (pluginInfo: ParsedPluginInfo.t[]) => pluginInfo.reduce(
+    (retval: Task.t[], pluginInfo) => [...retval, ...(pluginInfo.tasks ?? [])],
+    []
+)

package/Faucet.ts

@@ -0,0 +1,57 @@
+import {z, ZodError} from 'zod'
+import * as PublicKeyHash from "@taqueria/protocol/PublicKeyHash"
+import {resolve, reject} from 'fluture'
+import {toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+
+const internalSchema = z.object({
+    pkh: PublicKeyHash.schema,
+    mnemonic: z.array(
+        z.string({description: "Faucet Mnemonic Word"}).nonempty().regex(/^[a-z]{2,}$/),
+        {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()
+}).describe("Faucet")
+
+export const rawSchema = z.object({
+    pkh: z.string({description: "Faucet Public Key Hash"}).nonempty(),
+    mnemonic: z.array(
+        z.string({description: "Faucet Mnemonic Word"}).nonempty(),
+        {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()
+}).describe("Faucet")
+
+export const schema = internalSchema.transform(val => val as Faucet)
+
+type Input = z.infer<typeof internalSchema>
+
+type RawInput = z.infer<typeof rawSchema>
+
+const faucetType: unique symbol = Symbol("Faucet")
+
+export type Faucet = Input & {
+    readonly [faucetType]: void
+}
+
+export type t = Faucet
+
+export const make = (data: Input) => {
+    try {
+        const retval = schema.parse(data)
+        return resolve(retval)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<Faucet>(err, `The provided faucet is invalid.`, data)
+        }
+        return toParseUnknownErr<Faucet>(err, "There was a problem trying to parse the faucet configuration", data)
+    }
+}
+
+export const create = (data: RawInput) => schema.parse(data)

package/HumanReadableIdentifier.ts

@@ -0,0 +1,30 @@
+import {z, ZodError} from 'zod'
+import {resolve, reject} from 'fluture'
+import {toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+
+export const rawSchema = z
+    .string({description: "Human Readable Identifier"})
+    .regex(/^[A-Za-z]+[A-Za-z0-9-_ ]*$/, "Must be a valid human-readable identifier")
+
+export const schema = rawSchema.transform(val => val as t)
+
+const hrType: unique symbol = Symbol("HumanReadableIdentifier")
+
+export type t = string & {
+    readonly [hrType]: void
+}
+
+export type HumanReadableIdentifier = t
+
+export const make = (value: string) => {
+    try {
+        const retval = schema.parse(value)
+        return resolve(retval)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<HumanReadableIdentifier>(err, `${value} is not a valid identifier`, value)
+        }
+        return toParseUnknownErr<HumanReadableIdentifier>(err, "There was a problem trying to parse the identifier", value)
+    }
+}

package/InstalledPlugin.ts

@@ -0,0 +1,37 @@
+import {z, ZodError} from 'zod'
+import {resolve} from "fluture"
+import {toParseErr, toParseUnknownErr} from "@taqueria/protocol/TaqError"
+
+const installedPluginType: unique symbol = Symbol("InstalledPlugin")
+
+const internalSchema = z.object({
+    name: z.string({description: "Plugin Name"}).nonempty(),
+    type: z.union(
+        [z.literal('npm'), z.literal('binary'), z.literal('deno')],
+        {description: "Plugin Type"}
+    )
+}).describe("InstalledPlugin")
+
+export const schema = internalSchema.transform(val => val as InstalledPlugin)
+
+type Input = z.infer<typeof internalSchema>
+
+export interface InstalledPlugin extends Input {
+    readonly [installedPluginType]: void
+}
+
+export type t = InstalledPlugin
+
+
+export const make = (data: Input) => {
+    try {
+        const retval = schema.parse(data)
+        return resolve(retval)
+    }
+    catch (err) {
+        if (err instanceof ZodError) {
+            return toParseErr<InstalledPlugin>(err, `The provided plugin is invalid.`, data)
+        }
+        return toParseUnknownErr<InstalledPlugin>(err, "There was a problem trying to parse an installed plugin", data)
+    }
+}