diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 1469921..9366c6a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -33,22 +33,12 @@ jobs: - name: Install Apex CLI run: deno install -A --unstable -f -n apex https://deno.land/x/apex_cli/apex.ts - # - run: npm install - # working-directory: ./codegen - - # - run: npm run test - # working-directory: ./codegen - - # #- run: npm run lint - # - run: npm run build - # working-directory: ./codegen - - # - name: Install codegen module - # run: apex install file:. - # working-directory: ./codegen + - name: Run codegen tests + run: apex test + working-directory: ./codegen - name: Bundle module and dependencies - run: deno bundle src/mod.ts bundle.js + run: apex build working-directory: ./codegen - name: Generator diff test diff --git a/codegen/.gitignore b/codegen/.gitignore index 62035fc..9ff4ca8 100644 --- a/codegen/.gitignore +++ b/codegen/.gitignore @@ -3,6 +3,7 @@ /testdata/*/actual/* # compiled output +bundle.js dist tmp /out-tsc diff --git a/codegen/.vscode/settings.json b/codegen/.vscode/settings.json index c5d71f6..e7d927a 100644 --- a/codegen/.vscode/settings.json +++ b/codegen/.vscode/settings.json @@ -1,6 +1,7 @@ { + "editor.formatOnSave": true, "deno.enable": true, "[typescript]": { "editor.defaultFormatter": "denoland.vscode-deno" } -} +} \ No newline at end of file diff --git a/codegen/apex.yaml b/codegen/apex.yaml new file mode 100644 index 0000000..37324a0 --- /dev/null +++ b/codegen/apex.yaml @@ -0,0 +1,11 @@ +tasks: + build: + cmds: + - deno bundle src/mod.ts bundle.js + + test: + cmds: + - deno fmt --check src/ test/ + - deno lint src/ + - deno check --unstable src/mod.ts + - deno test --allow-env test/utils.test.ts diff --git a/codegen/justfile b/codegen/justfile deleted file mode 100644 index b03b264..0000000 --- a/codegen/justfile +++ /dev/null @@ -1,22 +0,0 @@ -install: - npm install - -build: install - npm run build - -watch: - npm run watch - -test: - deno test --allow-env test/*.test.ts - -update-deps: - npx npm-check-updates -u - -apex-install: - npm run devbuild - -clean: - rm -rf packages/*/node_modules - rm -rf node_modules - diff --git a/codegen/src/deps/codegen/go.ts b/codegen/src/deps/codegen/go.ts index cf85b13..4ba2246 100644 --- a/codegen/src/deps/codegen/go.ts +++ b/codegen/src/deps/codegen/go.ts @@ -1 +1 @@ -export * from "https://deno.land/x/apex_codegen@v0.1.6/go/mod.ts"; +export * from "https://deno.land/x/apex_codegen@v0.1.9/go/mod.ts"; diff --git a/codegen/src/deps/codegen/mod.ts b/codegen/src/deps/codegen/mod.ts index 84220fc..e4ea1ce 100644 --- a/codegen/src/deps/codegen/mod.ts +++ b/codegen/src/deps/codegen/mod.ts @@ -1 +1 @@ -export * from "https://deno.land/x/apex_codegen@v0.1.6/mod.ts"; +export * from "https://deno.land/x/apex_codegen@v0.1.9/mod.ts"; diff --git a/codegen/src/deps/codegen/rust.ts b/codegen/src/deps/codegen/rust.ts index 94a2e1f..d9232a7 100644 --- a/codegen/src/deps/codegen/rust.ts +++ b/codegen/src/deps/codegen/rust.ts @@ -1 +1 @@ -export * from "https://deno.land/x/apex_codegen@v0.1.6/rust/mod.ts"; +export * from "https://deno.land/x/apex_codegen@v0.1.9/rust/mod.ts"; diff --git a/codegen/src/deps/codegen/utils.ts b/codegen/src/deps/codegen/utils.ts index 3262c52..8d0fb15 100644 --- a/codegen/src/deps/codegen/utils.ts +++ b/codegen/src/deps/codegen/utils.ts @@ -1 +1 @@ -export * from "https://deno.land/x/apex_codegen@v0.1.6/utils/mod.ts"; +export * from "https://deno.land/x/apex_codegen@v0.1.9/utils/mod.ts"; diff --git a/codegen/src/deps/core/mod.ts b/codegen/src/deps/core/mod.ts index 851704e..94fe043 100644 --- a/codegen/src/deps/core/mod.ts +++ b/codegen/src/deps/core/mod.ts @@ -1 +1 @@ -export * from 'https://deno.land/x/apex_core@v0.1.2/mod.ts'; +export * from "https://deno.land/x/apex_core@v0.1.3/mod.ts"; diff --git a/codegen/src/deps/core/model.ts b/codegen/src/deps/core/model.ts index 01768eb..c9cf081 100644 --- a/codegen/src/deps/core/model.ts +++ b/codegen/src/deps/core/model.ts @@ -1 +1 @@ -export * from "https://deno.land/x/apex_core@v0.1.2/model/mod.ts"; +export * from "https://deno.land/x/apex_core@v0.1.3/model/mod.ts"; diff --git a/codegen/src/rust/plugin.ts b/codegen/src/rust/plugin.ts index 90da14d..80655c1 100644 --- a/codegen/src/rust/plugin.ts +++ b/codegen/src/rust/plugin.ts @@ -1,7 +1,7 @@ import { Configuration, TaskDefinition, -} from "https://deno.land/x/apex_cli@v0.0.15/src/config.ts"; +} from "https://deno.land/x/apex_cli@v0.0.18/src/config.ts"; import * as apex from "../deps/core/mod.ts"; import * as rust from "../deps/codegen/rust.ts"; import { Context, Operation } from "../deps/core/model.ts"; @@ -37,9 +37,12 @@ export default function ( config.config.name ||= module; try { const cargoToml = Deno.readTextFileSync("./Cargo.toml"); + // deno-lint-ignore no-explicit-any const cargo = parse(cargoToml) as any; config.config.name ||= cargo.package.name; - } catch {} + } catch { + // Ignore + } if (!config.config.name) { throw new Error( "No name provided in config, and no Cargo.toml found with a name", diff --git a/codegen/src/rust/visitors/base.ts b/codegen/src/rust/visitors/base.ts index c961a6f..4afe3f8 100644 --- a/codegen/src/rust/visitors/base.ts +++ b/codegen/src/rust/visitors/base.ts @@ -8,7 +8,7 @@ import { Type, Union, Writer, -} from '../../deps/core/model.ts'; +} from "../../deps/core/model.ts"; export type VisitorTypes = Alias | Type | Union | Enum | Interface; diff --git a/codegen/src/rust/visitors/provider-visitor.ts b/codegen/src/rust/visitors/provider-visitor.ts index d529326..7524f91 100644 --- a/codegen/src/rust/visitors/provider-visitor.ts +++ b/codegen/src/rust/visitors/provider-visitor.ts @@ -1,7 +1,6 @@ import { Context, Interface, - Kind, ObjectMap, Operation, Stream, diff --git a/codegen/src/templates.ts b/codegen/src/templates.ts index a886423..349ae61 100644 --- a/codegen/src/templates.ts +++ b/codegen/src/templates.ts @@ -1,4 +1,4 @@ -import { Template } from "https://deno.land/x/apex_cli@v0.0.15/src/config.ts"; +import { Template } from "https://deno.land/x/apex_cli@v0.0.18/src/config.ts"; const template: Template = { info: { diff --git a/codegen/src/templates/mod.ts b/codegen/src/templates/mod.ts index dd7f205..da9f32c 100644 --- a/codegen/src/templates/mod.ts +++ b/codegen/src/templates/mod.ts @@ -1,4 +1,4 @@ -import { Template } from "https://deno.land/x/apex_cli@v0.0.15/src/config.ts"; +import { Template } from "https://deno.land/x/apex_cli@v0.0.18/src/config.ts"; const template: Template = { info: { diff --git a/codegen/src/templates/rust/.vscode/extensions.json b/codegen/src/templates/rust/.vscode/extensions.json index bb39c68..bd9f051 100644 --- a/codegen/src/templates/rust/.vscode/extensions.json +++ b/codegen/src/templates/rust/.vscode/extensions.json @@ -1,3 +1,3 @@ { "recommendations": ["apexlang.apexlang"] -} \ No newline at end of file +} diff --git a/codegen/src/templates/rust/template.ts b/codegen/src/templates/rust/template.ts index 24a53f2..7fa861d 100644 --- a/codegen/src/templates/rust/template.ts +++ b/codegen/src/templates/rust/template.ts @@ -2,7 +2,7 @@ import { FSStructure, Template, -} from "https://deno.land/x/apex_cli@v0.0.15/src/config.ts"; +} from "https://deno.land/x/apex_cli@v0.0.18/src/config.ts"; const importUrl = new URL(".", import.meta.url); function urlify(relpath: string): string { diff --git a/codegen/src/templates/tinygo/.vscode/settings.json b/codegen/src/templates/tinygo/.vscode/settings.json index 1dcba76..8cd3970 100644 --- a/codegen/src/templates/tinygo/.vscode/settings.json +++ b/codegen/src/templates/tinygo/.vscode/settings.json @@ -1,3 +1,8 @@ { - "task.allowAutomaticTasks": "on" + "task.allowAutomaticTasks": "on", + "editor.formatOnSave": true, + "deno.enable": true, + "[typescript]": { + "editor.defaultFormatter": "denoland.vscode-deno" + } } diff --git a/codegen/src/templates/tinygo/template.ts b/codegen/src/templates/tinygo/template.ts index a4fbda2..06c5ad3 100644 --- a/codegen/src/templates/tinygo/template.ts +++ b/codegen/src/templates/tinygo/template.ts @@ -2,7 +2,7 @@ import { FSStructure, Template, -} from "https://deno.land/x/apex_cli@v0.0.15/src/config.ts"; +} from "https://deno.land/x/apex_cli@v0.0.18/src/config.ts"; const importUrl = new URL(".", import.meta.url); function urlify(relpath: string): string { diff --git a/codegen/src/tinygo/constants.ts b/codegen/src/tinygo/constants.ts index 2f73fdb..0d8d283 100644 --- a/codegen/src/tinygo/constants.ts +++ b/codegen/src/tinygo/constants.ts @@ -31,10 +31,46 @@ export const primitiveTransformers = new Map([ ["bytes", "transform.Bytes"], ]); +export const primitiveToBytes = new Map([ + ["bool", "BoolToBytes"], + ["string", "StringToBytes"], + ["datetime", "TimeToBytes"], + ["i8", "I8ToBytes"], + ["u8", "U8ToBytes"], + ["i16", "I16ToBytes"], + ["u16", "U16ToBytes"], + ["i32", "I32ToBytes"], + ["u32", "U32ToBytes"], + ["i64", "I64ToBytes"], + ["u64", "U64ToBytes"], + ["f32", "F32ToBytes"], + ["f64", "F64ToBytes"], + ["bytes", "BytesToBytes"], +]); + +export const primitiveDecode = new Map([ + ["bool", "BoolDecode"], + ["string", "StringDecode"], + ["datetime", "TimeDecode"], + ["i8", "Int8Decode"], + ["u8", "Uint8Decode"], + ["i16", "Int16Decode"], + ["u16", "Uint16Decode"], + ["i32", "Int32Decode"], + ["u32", "Uint32Decode"], + ["i64", "Int64Decode"], + ["u64", "Uint64Decode"], + ["f32", "Float32Decode"], + ["f64", "Float64Decode"], + ["bytes", "BytesDecode"], +]); + export const IMPORTS = { context: "context", + errors: "errors", binary: "encoding/binary", guest: "github.com/nanobus/iota/go/transport/wasmrs/guest", + rsocket: "github.com/nanobus/iota/go/transport/rsocket", invoke: "github.com/nanobus/iota/go/invoke", msgpack: "github.com/nanobus/iota/go/msgpack", convert: "github.com/nanobus/iota/go/msgpack/convert", diff --git a/codegen/src/tinygo/export_visitor.ts b/codegen/src/tinygo/export_visitor.ts index d8193ad..7de2fcd 100644 --- a/codegen/src/tinygo/export_visitor.ts +++ b/codegen/src/tinygo/export_visitor.ts @@ -14,9 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. */ -import { - Context, -} from "../deps/core/model.ts"; +import { Context } from "../deps/core/model.ts"; import { GoVisitor } from "../deps/codegen/go.ts"; import { WrappersVisitor } from "./wrappers_visitor.ts"; import { RegisterVisitor } from "./register_visitor.ts"; diff --git a/codegen/src/tinygo/import_visitor.ts b/codegen/src/tinygo/import_visitor.ts index 888af7e..e9decf6 100644 --- a/codegen/src/tinygo/import_visitor.ts +++ b/codegen/src/tinygo/import_visitor.ts @@ -29,6 +29,7 @@ import { IMPORTS } from "./constants.ts"; export class ImportBaseVisitor extends GoVisitor { private hasAny: (context: Context) => boolean; private filter: (context: Context) => boolean; + private resources = new Set(); constructor( writer: Writer, @@ -47,39 +48,79 @@ export class ImportBaseVisitor extends GoVisitor { visitNamespace(context: Context): void { const { namespace: ns } = context; const $ = getImporter(context, IMPORTS); - - if (!this.hasAny(context)) { - this.write(` - var ( - gCaller ${$.invoke}.Caller - ) - - func Initialize(caller ${$.invoke}.Caller) { - gCaller = caller - }\n\n`); - return; - } - const importedFuncs = Object.values(ns.functions).filter((f) => - isProvider(context.clone({ operation: f })) - ); + const importedFuncs = Object.values(ns.functions).filter((oper) => { + const c = context.clone({ operation: oper }); + return !this.filter(c); + }); + const importedIfaces = Object.values(ns.interfaces).filter((iface) => { + const c = context.clone({ interface: iface }); + return !this.filter(c) || this.resources.has(iface.name); + }); - this.write(`var ( - gCaller ${$.invoke}.Caller\n`); + this.write(`type Dependencies struct {\n`); + importedFuncs.forEach((f) => { + this.write(`${methodName(f, f.name)} ${methodName(f, f.name)}Fn\n`); + }); + importedIfaces.forEach((i) => { + this.write(`${i.name} ${i.name}\n`); + }); + this.write(`}\n\n`); + + this.write(`type Client struct { + caller invoke.Caller\n`); + importedFuncs.forEach((f) => { + this.write( + `_op${methodName(f, f.name)} uint32\n`, + ); + }); + importedIfaces.forEach((i) => { + i.operations.forEach((o) => { + this.write( + `_op${i.name}${methodName(o, o.name)} uint32\n`, + ); + }); + }); + this.write(`} + + func New(caller invoke.Caller) *Client { + return &Client{ + caller: caller,\n`); importedFuncs.forEach((f) => { const parts = getOperationParts(f); this.write( `_op${ methodName(f, f.name) - } = ${$.invoke}.Import${parts.type}("${ns.name}", "${f.name}")\n`, + }: ${$.invoke}.Import${parts.type}("${ns.name}", "${f.name}"),\n`, ); }); + importedIfaces.forEach((i) => { + i.operations.forEach((o) => { + const parts = getOperationParts(o); + this.write( + `_op${i.name}${ + methodName(o, o.name) + }: ${$.invoke}.Import${parts.type}("${ns.name}.${i.name}", "${o.name}"),\n`, + ); + }); + }); - this.write(`) + this.write(`}\n}\n`); + + this.write(`func (c *Client) Dependencies() Dependencies { + return Dependencies{\n`); + importedFuncs.forEach((f) => { + this.write(`${methodName(f, f.name)}: c.${methodName(f, f.name)},\n`); + }); + importedIfaces.forEach((i) => { + this.write(`${i.name}: c.${i.name}(),\n`); + }); + this.write(`}\n} - func Initialize(caller ${$.invoke}.Caller) { - gCaller = caller + func GetDependencies(caller invoke.Caller) Dependencies { + c := New(caller) + return c.Dependencies() }\n\n`); } @@ -87,21 +128,21 @@ export class ImportBaseVisitor extends GoVisitor { if (this.filter(context)) { return; } - const invokersVisitor = new InvokersVisitor(this.writer); + const invokersVisitor = new InvokersVisitor(this.writer, this.resources); context.operation.accept(context, invokersVisitor); } visitInterface(context: Context): void { - if (this.filter(context)) { + const { interface: iface } = context; + if (this.filter(context) && !this.resources.has(iface.name)) { return; } - const { interface: iface } = context; const providerStructVisitor = new ProviderStructVisitor(this.writer); iface.accept(context, providerStructVisitor); const providerNewVisitor = new ProviderNewVisitor(this.writer); iface.accept(context, providerNewVisitor); - const invokersVisitor = new InvokersVisitor(this.writer); + const invokersVisitor = new InvokersVisitor(this.writer, this.resources); iface.accept(context, invokersVisitor); } } @@ -134,6 +175,9 @@ export class ProviderVisitor extends ImportBaseVisitor { return false; }, (context: Context): boolean => { + if (!context.interface) { + return true; + } return !isProvider(context) || noCode(context.operation); }, ); @@ -146,21 +190,22 @@ export class ImportVisitor extends ImportBaseVisitor { writer, (context: Context): boolean => { const { namespace: ns } = context; + if (Object.keys(ns.functions).length > 0) { + return true; + } for (const name in ns.interfaces) { const iface = ns.interfaces[name]; if (iface.annotation("service")) { return true; } } - for (const name in ns.functions) { - const iface = ns.functions[name]; - if (iface.annotation("service")) { - return true; - } - } + return false; }, (context: Context): boolean => { + if (!context.interface) { + return false; + } return !isHandler(context); }, ); @@ -170,12 +215,9 @@ export class ImportVisitor extends ImportBaseVisitor { class ProviderStructVisitor extends BaseVisitor { visitInterfaceBefore(context: Context): void { const { interface: iface } = context; - this.write(`type ${iface.name}Impl struct {\n`); - } - - visitOperation(context: Context): void { - const { operation } = context; - this.write(`op${methodName(operation, operation.name)} uint32\n`); + this.write(`type ${iface.name}Client struct { + c *Client + instanceID uint64\n`); } visitInterfaceAfter(_context: Context): void { @@ -186,19 +228,9 @@ class ProviderStructVisitor extends BaseVisitor { class ProviderNewVisitor extends BaseVisitor { visitInterfaceBefore(context: Context): void { const { interface: iface } = context; - this.write(`func New${iface.name}() *${iface.name}Impl { - return &${iface.name}Impl{\n`); - } - - visitOperation(context: Context): void { - const { namespace: ns, interface: iface, operation } = context; - const $ = getImporter(context, IMPORTS); - const parts = getOperationParts(operation); - this.write( - `op${ - methodName(operation, operation.name) - }: ${$.invoke}.Import${parts.type}("${ns.name}.${iface.name}", "${operation.name}"),\n`, - ); + this.write(`func (c *Client) ${iface.name}() ${iface.name} { + return &${iface.name}Client{ + c: c,\n`); } visitInterfaceAfter(_context: Context): void { diff --git a/codegen/src/tinygo/interface_visitor.ts b/codegen/src/tinygo/interface_visitor.ts index 81b8fe1..8eeb70d 100644 --- a/codegen/src/tinygo/interface_visitor.ts +++ b/codegen/src/tinygo/interface_visitor.ts @@ -45,7 +45,9 @@ export class InterfaceVisitor extends GoInterfaceVisitor { } else { rxWrapper = `${$.mono}.Mono`; } - this.write(` ${rxWrapper}[${expandType(t, undefined, true, translate)}]`); + this.write( + ` ${rxWrapper}[${expandType(t, undefined, true, translate)}]`, + ); } else { this.write(` ${$.mono}.Void`); } diff --git a/codegen/src/tinygo/interfaces_visitor.ts b/codegen/src/tinygo/interfaces_visitor.ts index 861339d..8d83926 100644 --- a/codegen/src/tinygo/interfaces_visitor.ts +++ b/codegen/src/tinygo/interfaces_visitor.ts @@ -17,6 +17,7 @@ limitations under the License. import { Context, Visitor, Writer } from "../deps/core/model.ts"; import { InterfacesVisitor as GoInterfacesVisitor } from "../deps/codegen/go.ts"; import { InterfaceVisitor } from "./interface_visitor.ts"; +import { isHandler, isProvider } from "../deps/codegen/utils.ts"; export class InterfacesVisitor extends GoInterfacesVisitor { constructor(writer: Writer) { @@ -27,6 +28,17 @@ export class InterfacesVisitor extends GoInterfacesVisitor { new InterfaceVisitor(writer); } + visitInterfaceBefore(context: Context): void { + const { interface: iface } = context; + if (isProvider(context)) { + const visitor = this.dependencyVisitor(this.writer); + iface.accept(context, visitor); + } else if (isHandler(context)) { + const visitor = this.serviceVisitor(this.writer); + iface.accept(context, visitor); + } + } + visitContextBefore(context: Context): void { context.config.noEnumJSON = true; } diff --git a/codegen/src/tinygo/invokers_visitor.ts b/codegen/src/tinygo/invokers_visitor.ts index ccd29a6..2364192 100644 --- a/codegen/src/tinygo/invokers_visitor.ts +++ b/codegen/src/tinygo/invokers_visitor.ts @@ -18,17 +18,22 @@ import { Alias, Context, Enum, + Interface, Kind, List, + Map, Named, Primitive, Stream, + Writer, } from "../deps/core/model.ts"; import { expandType, fieldName, getImporter, + getImports, GoVisitor, + Import, mapParam, methodName, parameterName, @@ -41,10 +46,23 @@ import { isVoid, operationArgsType, } from "../deps/codegen/utils.ts"; +import { msgpackRead, msgpackWrite } from "./msgpack_helpers.ts"; import { getOperationParts } from "./utilities.ts"; -import { IMPORTS, primitiveTransformers } from "./constants.ts"; +import { + IMPORTS, + primitiveDecode, + primitiveToBytes, + primitiveTransformers, +} from "./constants.ts"; export class InvokersVisitor extends GoVisitor { + private resources: Set; + + constructor(writer: Writer, resources: Set) { + super(writer); + this.resources = resources; + } + visitOperation(context: Context): void { this.doHandler(context); } @@ -73,7 +91,8 @@ export class InvokersVisitor extends GoVisitor { } else { rxWrapper = `${$.mono}.Mono`; } - this.write(` ${rxWrapper}[${expandType(t, undefined, true, translate)}]`); + const expanded = expandType(t, undefined, true, translate); + this.write(` ${rxWrapper}[${expanded}]`); } else { this.write(` ${$.mono}.Void`); } @@ -83,10 +102,20 @@ export class InvokersVisitor extends GoVisitor { const tr = translateAlias(context); const { interface: iface, operation } = context; const $ = getImporter(context, IMPORTS); + const imports = getImports(context); + + const { type, unaryIn, parameters, streamIn, returns, returnPackage } = + getOperationParts(operation); + + const returnType = !returns || isVoid(returns) + ? "struct{}" + : returns.kind == Kind.Interface + ? (returns as Interface).name + : expandType(returns, undefined, false, tr); let receiver = ""; if (iface) { - const structName = iface.name + "Impl"; + const structName = iface.name + "Client"; receiver = structName.substring(0, 1).toLowerCase(); this.write( `func (${receiver} *${structName}) ${ @@ -98,7 +127,7 @@ export class InvokersVisitor extends GoVisitor { ); } else { this.write( - `func ${ + `func (c *Client) ${ methodName(operation, operation.name) }(ctx ${$.context}.Context`, ); @@ -111,13 +140,6 @@ export class InvokersVisitor extends GoVisitor { this.visitOperationReturn(context); this.write(` {\n`); - const { type, unaryIn, parameters, streamIn, returns, returnPackage } = - getOperationParts(operation); - - const returnType = !returns || isVoid(returns) - ? "struct{}" - : expandType(returns, undefined, false, tr); - if (unaryIn) { if (unaryIn.type.kind == Kind.Enum) { this @@ -133,21 +155,108 @@ export class InvokersVisitor extends GoVisitor { }\n`, ); } else if (unaryIn.type.kind == Kind.Alias) { - // const a = unaryIn.type as Alias; - // const primitiveExpanded = expandType(a.type, undefined, false, tr); - // const unaryParamExpanded = expandType( - // unaryIn.type, - // undefined, - // false, - // tr - // ); - // this.write(`aliasVal, err := transform.${capitalize( - // primitiveExpanded - // )}.Decode(p) - // if err != nil { - // return ${error}[payload.Payload](err) - // } - // request := ${unaryParamExpanded}(aliasVal)\n`); + const a = unaryIn.type as Alias; + const aliases = (context.config.aliases as { [key: string]: Import }) || + {}; + const imp = aliases[a.name]; + if (imp && imp.format) { + if (imp.import) { + imports.thirdparty(imp.import); + } + this.write( + `payloadData, err := ${$.msgpack}.${ + primitiveToBytes.get("string") + }(${ + parameterName( + unaryIn, + unaryIn.name, + ) + }.${imp.format}()) + if err != nil { + return ${returnPackage}.Error[${returnType}](err) + }\n`, + ); + } else { + const primitiveExpanded = expandType(a.type, undefined, false, tr); + this.write( + `payloadData, err := ${$.msgpack}.${ + primitiveToBytes.get(primitiveExpanded) + }(${primitiveExpanded}(${ + parameterName( + unaryIn, + unaryIn.name, + ) + })) + if err != nil { + return ${returnPackage}.Error[${returnType}](err) + }\n`, + ); + } + } else if (unaryIn.type.kind == Kind.List) { + const l = unaryIn.type as List; + const expanded = expandType(l.type, undefined, false, tr); + this.write( + `payloadData, err := ${$.msgpack}.SliceToBytes(${ + parameterName( + unaryIn, + unaryIn.name, + ) + }, func(writer ${$.msgpack}.Writer, val ${expanded}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "val", + l.type, + false, + ) + } }) + if err != nil { + return ${returnPackage}.Error[${returnType}](err) + }\n`, + ); + } else if (unaryIn.type.kind == Kind.Map) { + const m = unaryIn.type as Map; + const expandedKey = expandType(m.keyType, undefined, false, tr); + const expandedVal = expandType(m.valueType, undefined, false, tr); + this.write( + `payloadData, err := ${$.msgpack}.MapToBytes(${ + parameterName( + unaryIn, + unaryIn.name, + ) + }, func(writer ${$.msgpack}.Writer, val ${expandedKey}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "val", + m.keyType, + false, + ) + } }, func(writer ${$.msgpack}.Writer, val ${expandedVal}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "val", + m.valueType, + false, + ) + } }) + if err != nil { + return ${returnPackage}.Error[${returnType}](err) + }\n`, + ); } else if (isObject(unaryIn.type)) { this.write(`payloadData, err := ${$.msgpack}.ToBytes(${ parameterName( @@ -161,10 +270,10 @@ export class InvokersVisitor extends GoVisitor { } else if (isPrimitive(unaryIn.type)) { const p = unaryIn.type as Primitive; this.write(`payloadData, err := ${$.msgpack}.${ - capitalize( + primitiveToBytes.get( p.name, ) - }ToBytes(${parameterName(unaryIn, unaryIn.name)}) + }(${parameterName(unaryIn, unaryIn.name)}) if err != nil { return ${returnPackage}.Error[${returnType}](err) }\n`); @@ -174,8 +283,9 @@ export class InvokersVisitor extends GoVisitor { const argsName = operationArgsType(iface, operation); this.write(`request := ${argsName} {\n`); parameters.forEach((p) => { + const ref = isObject(p.type, false) ? "*" : ""; this.write( - `\t${fieldName(p, p.name)}: ${parameterName(p, p.name)},\n`, + `\t${fieldName(p, p.name)}: ${ref}${parameterName(p, p.name)},\n`, ); }); this.write(`} @@ -188,32 +298,57 @@ export class InvokersVisitor extends GoVisitor { } } const opVar = iface - ? `${receiver}.op${methodName(operation, operation.name)}` - : `_op${methodName(operation, operation.name)}`; + ? `${receiver}.c._op${iface.name}${methodName(operation, operation.name)}` + : `c._op${methodName(operation, operation.name)}`; + const callerVar = iface ? `${receiver}.c.caller` : `c.caller`; this.write( - `var metadata [8]byte + `var metadata [16]byte stream, ok := ${$.proxy}.FromContext(ctx) ${$.binary}.BigEndian.PutUint32(metadata[0:4], ${opVar}) if ok { ${$.binary}.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) - } - pl := ${$.payload}.New(payloadData, metadata[:])\n`, + }\n`, ); + if (iface && this.resources.has(iface.name)) { + this.write( + `binary.BigEndian.PutUint64(metadata[8:], ${receiver}.instanceID)\n`, + ); + } + this.write(`pl := ${$.payload}.New(payloadData, metadata[:])\n`); if (streamIn) { let transformFn = ""; switch (streamIn.type.kind) { case Kind.Primitive: { const p = streamIn.type as Primitive; - transformFn = `${$.transform}.${capitalize(p.name)}.Encode`; + imports.thirdparty(IMPORTS.transform); + transformFn = `${ + primitiveTransformers.get( + p.name, + ) + }.Encode`; break; } case Kind.Alias: { const a = streamIn.type as Alias; if (a.type.kind == Kind.Primitive) { const p = a.type as Primitive; - transformFn = `${$.transform}.${ - capitalize(p.name) - }Encode[${a.name}]`; + const aliases = + (context.config.aliases as { [key: string]: Import }) || + {}; + const imp = aliases[a.name]; + if (imp && imp.parse) { + if (imp.import) { + imports.thirdparty(imp.import); + } + transformFn = + `${$.transform}.ToStringEncode(func (val ${imp.type}) string { + return val.${imp.format}() + })`; + } else { + transformFn = `${$.transform}.${ + capitalize(p.name) + }Encode[${a.name}]`; + } } else { const expanded = expandType(a.type, undefined, undefined, tr); transformFn = `func(value ${a.name}) (payload.Payload, error) { @@ -227,6 +362,57 @@ export class InvokersVisitor extends GoVisitor { transformFn = `${$.transform}.Int32Encode[${e.name}]`; break; } + case Kind.List: { + const l = streamIn.type as List; + const expanded = expandType(l.type, undefined, undefined, tr); + transformFn = + `${$.transform}.SliceEncode(func(writer ${$.msgpack}.Writer, val ${expanded}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "val", + l.type, + false, + ) + } })`; + break; + } + case Kind.Map: { + const m = streamIn.type as Map; + const expandedKey = expandType(m.keyType, undefined, undefined, tr); + const expandedVal = expandType(m.valueType, undefined, undefined, tr); + transformFn = + `${$.transform}.MapEncode(func(writer ${$.msgpack}.Writer, key ${expandedKey}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "key", + m.keyType, + false, + ) + } }, func(writer ${$.msgpack}.Writer, val ${expandedVal}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "val", + m.valueType, + false, + ) + } })`; + break; + } case Kind.Type: case Kind.Union: { const t = streamIn.type as Named; @@ -234,41 +420,70 @@ export class InvokersVisitor extends GoVisitor { break; } default: { - console.log(streamIn.type.kind); + console.error(streamIn.type.kind); } } const inMap = `${$.flux}.Map(${streamIn.parameter.name}, ${transformFn})`; if (returns && operation.type.kind != Kind.Stream && !isVoid(returns)) { - this.write(`futureStream := gCaller.${type}(ctx, pl, ${inMap})\n`); - this.write("future := transform.FluxToMono(futureStream)\n"); + this.write(`futureStream := ${callerVar}.${type}(ctx, pl, ${inMap})\n`); + this.write(`future := ${$.transform}.FluxToMono(futureStream)\n`); } else { - this.write(`future := gCaller.${type}(ctx, pl, ${inMap})\n`); + this.write(`future := ${callerVar}.${type}(ctx, pl, ${inMap})\n`); } } else { - this.write(`future := gCaller.${type}(ctx, pl)\n`); + this.write(`future := ${callerVar}.${type}(ctx, pl)\n`); } if (streamIn && (!returns || isVoid(returns))) { - this.write("return transform.FluxToVoid(future)\n"); + this.write(`return ${$.transform}.FluxToVoid(future)\n`); } else if (returns.kind == Kind.Alias) { const a = returns as Alias; if (a.type.kind == Kind.Primitive) { const p = a.type as Primitive; - this.write( - `return ${returnPackage}.Map(future, ${$.transform}.${ - capitalize( - p.name, - ) - }Decode[${a.name}])\n`, - ); + const aliases = (context.config.aliases as { [key: string]: Import }) || + {}; + const imp = aliases[a.name]; + if (imp && imp.parse) { + if (imp.import) { + imports.thirdparty(imp.import); + } + this.write( + `return ${returnPackage}.Map(future, ${$.transform}.ToStringDecode(func (val string) (${imp.type}, error) { + return ${imp.parse}(val) + }))`, + ); + } else { + imports.thirdparty(IMPORTS.transform); + this.write( + `return ${returnPackage}.Map(future, ${$.transform}.${ + primitiveDecode.get( + p.name, + ) + }[${a.name}])\n`, + ); + } } else { const expanded = expandType(a.type, undefined, undefined, tr); this.write( - `return ${returnPackage}.Map(future, func(raw payload.Payload) (val ${a.name}, err error) { + `return ${returnPackage}.Map(future, func(raw ${$.payload}.Payload) (val ${a.name}, err error) { err = ${$.transform}.CodecDecode(raw, (*${expanded})(&val)) return val, err })\n`, ); } + } else if (returns.kind == Kind.Interface) { + const c = iface ? `${receiver}.c` : `c`; + this.write( + `return ${$.mono}.Map(future, func(p ${$.payload}.Payload) (${returnType}, error) { + instId, err := ${$.transform}.Uint64.Decode(p) + if err != nil { + return nil, err + } + return &${returnType}Client{ + c: ${c}, + instanceID: instId, + }, nil + })\n`, + ); } else if (returns.kind == Kind.Enum) { const e = returns as Enum; this.write( @@ -280,10 +495,49 @@ export class InvokersVisitor extends GoVisitor { this.write(`return ${returnPackage}.Map(future, ${transform}.Decode)\n`); } else if (returns.kind == Kind.List) { const l = returns as List; - const expanded = expandType(l.type, undefined, undefined, tr); + const expanded = expandType(l.type, undefined, false, tr); this.write( - `return ${returnPackage}.Map(future, ${$.transform}.SliceDecode[${expanded}])\n`, + `return ${returnPackage}.Map(future, ${$.transform}.SliceDecode(func(decoder ${$.msgpack}.Reader) (${expanded}, error) { + ${ + msgpackRead( + context, + false, + "", + false, + "", + l.type, + false, + ) + }}))\n`, ); + } else if (returns.kind == Kind.Map) { + const m = returns as Map; + const expandedKey = expandType(m.keyType, undefined, false, tr); + const expandedVal = expandType(m.valueType, undefined, false, tr); + this.write(`return ${returnPackage}.Map(future, ${$.transform}.MapDecode( + func(decoder ${$.msgpack}.Reader) (${expandedKey}, error) { + ${ + msgpackRead( + context, + false, + "", + false, + "", + m.keyType, + false, + ) + }}, func(decoder ${$.msgpack}.Reader) (${expandedVal}, error) { + ${ + msgpackRead( + context, + false, + "", + false, + "", + m.valueType, + false, + ) + }}))`); } else if (!returns || isVoid(returns)) { this.write( `return ${returnPackage}.Map(future, ${$.transform}.Void.Decode)\n`, diff --git a/codegen/src/tinygo/main_visitor.ts b/codegen/src/tinygo/main_visitor.ts index eb52aa3..f4f0d93 100644 --- a/codegen/src/tinygo/main_visitor.ts +++ b/codegen/src/tinygo/main_visitor.ts @@ -21,7 +21,12 @@ import { isService, UsesVisitor, } from "../deps/codegen/utils.ts"; -import { getImporter, getImports, GoVisitor } from "../deps/codegen/go.ts"; +import { + getImporter, + getImports, + GoVisitor, + methodName, +} from "../deps/codegen/go.ts"; import { IMPORTS } from "./constants.ts"; export class MainVisitor extends GoVisitor { @@ -41,12 +46,6 @@ export class MainVisitor extends GoVisitor { visitNamespaceBefore(context: Context): void { super.visitNamespaceBefore(context); - const importPath = context.config.import || - context.config.module || - "github.com/myorg/mymodule/pkg/module"; - const importer = getImports(context); - importer.firstparty(importPath); - this.uses = this.usesVisitor(this.writer); context.namespace.accept(context, this.uses); } @@ -55,43 +54,105 @@ export class MainVisitor extends GoVisitor { const $ = getImporter(context, IMPORTS); this.write(`\n`); + const transport = context.config.transport as string || "wasmrs"; + this.write(`func main() {\n`); const packageName = getPackageName(context); - this.write(`\t${packageName}.Initialize(${$.guest}.HostInvoker)\n\n`); - this.write(`// Create providers\n`); - this.uses!.dependencies.forEach((dependency) => { - this.write( - `${ - camelCase( - dependency, - ) - }Provider := ${packageName}.New${dependency}()\n`, + if (transport == "rsocket") { + this.write(`ctx := ${$.context}.Background() + h := ${$.rsocket}.Handler(ctx)\n\n`); + } + + const funcs = Object.values(context.namespace.functions); + const services = Object.values(context.namespace.interfaces).filter((i) => + i.annotation("service") !== undefined || + i.annotation("events") !== undefined || + i.annotation("actor") !== undefined || + i.annotation("resource") !== undefined + ); + const created = Object.values(context.namespace.interfaces).filter((i) => + i.annotation("service") !== undefined || + i.annotation("events") !== undefined || + i.annotation("actor") !== undefined + ); + + if (funcs.length > 0 || created.length > 0) { + const importPath = context.config.import || + context.config.module || + "github.com/myorg/mymodule/pkg/module"; + const importer = getImports(context); + importer.firstparty(importPath); + } + + if (created.length > 0) { + this.write(`// Create providers\n`); + if (transport == "wasmrs") { + this.write( + `deps := ${packageName}.GetDependencies(${$.guest}.HostInvoker)\n`, + ); + } else if (transport == "rsocket") { + this.write( + `deps := ${packageName}.GetDependencies(h)\n`, + ); + } + this.write(`\n`); + + this.write(`// Create services\n`); + created.forEach( + (service) => { + this.write( + `${ + camelCase( + service.name, + ) + }Service := ${packageName}.New${service.name}(deps)\n`, + ); + }, ); - }); - - this.write(`\n\n// Create services\n`); - this.uses!.services.forEach((dependencies, service) => { - const deps = dependencies - .map((d) => camelCase(d) + "Provider") - .join(", "); - this.write( - `${ - camelCase( - service, - ) - }Service := ${packageName}.New${service}(${deps})\n`, + this.write(`\n`); + } + + if (funcs.length > 0 || services.length > 0) { + this.write(`// Register services\n`); + const registration = new HandlerRegistrationVisitor( + this.writer, ); - }); + context.namespace.accept(context, registration); + } + + if (transport == "rsocket") { + this.write(`if err := ${$.rsocket}.Connect(h); err != nil { + panic(err) + }\n`); + } - this.write(`\n\n// Register services\n`); - const registration = new HandlerRegistrationVisitor(this.writer); - context.namespace.accept(context, registration); this.write(`}\n`); } } class HandlerRegistrationVisitor extends BaseVisitor { + private hasResources = false; + + public visitFunction(context: Context): void { + const packageName = getPackageName(context); + const { operation } = context; + + this.write( + `\t\t${packageName}.Register${ + methodName( + operation, + operation.name, + ) + }(${packageName}.${ + methodName( + operation, + operation.name, + ) + })\n`, + ); + } + visitInterface(context: Context): void { if (!isService(context)) { return; @@ -107,6 +168,17 @@ class HandlerRegistrationVisitor extends BaseVisitor { }Service)\n`, ); } + + public visitNamespaceAfter(context: Context): void { + if (!this.hasResources) { + return; + } + + const packageName = getPackageName(context); + this.write( + `\t\t${packageName}.RegisterResources()\n`, + ); + } } function getPackageName(context: Context): string { @@ -118,4 +190,4 @@ function getPackageName(context: Context): string { packageName = packageName.substring(idx + 1); } return packageName; -} \ No newline at end of file +} diff --git a/codegen/src/tinygo/msgpack_helpers.ts b/codegen/src/tinygo/msgpack_helpers.ts index e8c5a17..b7e64c3 100644 --- a/codegen/src/tinygo/msgpack_helpers.ts +++ b/codegen/src/tinygo/msgpack_helpers.ts @@ -67,15 +67,7 @@ export function msgpackRead( const imports = getImports(context); const $ = getImporter(context, IMPORTS); const tr = translateAlias(context); - const returnPrefix = defaultVal == "" ? "" : `${defaultVal}, `; let prefix = "return "; - const assign = variable == "item" || - variable == "key" || - variable == "value" || - variable == "ret" || - variable == "request" - ? ":=" - : "="; if (variable != "") { if ( variable == "item" || @@ -103,7 +95,7 @@ export function msgpackRead( } } } - const passedType = t; + if (t.kind == Kind.Alias) { const aliases = (context.config.aliases as { [key: string]: Import }) || {}; const a = t as Alias; @@ -134,6 +126,7 @@ export function msgpackRead( } t = a.type; } + switch (t.kind) { case Kind.Union: case Kind.Type: @@ -165,128 +158,72 @@ export function msgpackRead( return `${prefix}${decodeFn}\n`; } case Kind.Map: { - let mapCode = `mapSize, err := decoder.ReadMapSize() - if err != nil { - return ${returnPrefix}err - }\n`; - if (variable == "ret") { - mapCode += "ret :="; - } else { - mapCode += `${variable} ${assign} `; - } - mapCode += `make(${ - expandType( - passedType, - undefined, - true, - tr, - ) - }, mapSize)\n`; - mapCode += `for mapSize > 0 { - mapSize--\n`; - mapCode += msgpackRead( - context, - typeInstRef, - "key", + const m = t as Map; + const expandedKey = expandType( + m.keyType, + undefined, true, - defaultVal, - (t as Map).keyType, - false, + tr, ); - if (!mapCode.endsWith(`\n`)) { - mapCode += `\n`; - } - mapCode += `if err != nil { - return ${returnPrefix}err - }\n`; - mapCode += msgpackRead( - context, - typeInstRef, - "value", + const expandedVal = expandType( + m.valueType, + undefined, true, - defaultVal, - (t as Map).valueType, - false, + tr, ); - if (!mapCode.endsWith(`\n`)) { - mapCode += `\n`; - } - mapCode += `if err != nil { - return ${returnPrefix}err - }\n`; - mapCode += `${variable}[key] = value - }\n`; - return mapCode; + return `${prefix}${$.msgpack}.ReadMap(decoder, func(decoder ${$.msgpack}.Reader) (${expandedKey}, error) { ${ + msgpackRead( + context, + typeInstRef, + "", + false, + defaultVal, + m.keyType, + false, + ) + } }, func(decoder ${$.msgpack}.Reader) (${expandedVal}, error) { ${ + msgpackRead( + context, + typeInstRef, + "", + false, + defaultVal, + m.valueType, + false, + ) + } })\n`; } case Kind.List: { - let listCode = `listSize, err := decoder.ReadArraySize() - if err != nil { - return ${returnPrefix}err - }\n`; - if (variable == "ret") { - listCode += "ret :="; - } else { - listCode += `${variable} ${assign} `; - } - listCode += `make(${ - expandType( - passedType, - undefined, - true, - tr, - ) - }, 0, listSize)\n`; - listCode += `for listSize > 0 { - listSize-- - var nonNilItem ${(t as List).type.kind == Kind.Optional ? "*" : ""}${ - expandType((t as List).type, undefined, false, tr) - }\n`; - listCode += msgpackRead( - context, - typeInstRef, - "nonNilItem", + const l = t as List; + const expanded = expandType( + l.type, + undefined, true, - defaultVal, - (t as List).type, - false, + tr, ); - if (!listCode.endsWith(`\n`)) { - listCode += `\n`; - } - listCode += `if err != nil { - return ${returnPrefix}err - }\n`; - listCode += `${variable} = append(${variable}, nonNilItem) - }\n`; - return listCode; + return `${prefix}${$.msgpack}.ReadSlice(decoder, func(decoder ${$.msgpack}.Reader) (${expanded}, error) { ${ + msgpackRead( + context, + typeInstRef, + "", + false, + defaultVal, + l.type, + false, + ) + } })\n`; } case Kind.Optional: { const optNode = t as Optional; - optNode.type; - switch (optNode.type.kind) { - case Kind.List: - case Kind.Map: - return msgpackRead( - context, - typeInstRef, - variable, - false, - defaultVal, - optNode.type, - true, - ); - } - let optCode = ""; - optCode += msgpackRead( + return msgpackRead( context, typeInstRef, variable, - true, + errorHandling, defaultVal, optNode.type, true, ); - return optCode; } default: return "unknown\n"; diff --git a/codegen/src/tinygo/msgpack_visitor.ts b/codegen/src/tinygo/msgpack_visitor.ts index ef17237..e4c8f24 100644 --- a/codegen/src/tinygo/msgpack_visitor.ts +++ b/codegen/src/tinygo/msgpack_visitor.ts @@ -19,7 +19,11 @@ import { convertOperationToType, convertUnionToType, } from "../deps/codegen/utils.ts"; -import { GoVisitor, StructVisitor } from "../deps/codegen/go.ts"; +import { + DefaultsVisitor, + GoVisitor, + StructVisitor, +} from "../deps/codegen/go.ts"; import { MsgPackDecoderVisitor } from "./msgpack_decoder_visitor.ts"; import { MsgPackEncoderUnionVisitor, @@ -42,6 +46,8 @@ export class MsgPackVisitor extends GoVisitor { const ctx = context.clone({ type: type }); const struct = new StructVisitor(this.writer); type.accept(ctx, struct); + const defaults = new DefaultsVisitor(this.writer); + type.accept(ctx, defaults); const decoder = new MsgPackDecoderVisitor(this.writer); type.accept(ctx, decoder); const encoder = new MsgPackEncoderVisitor(this.writer); diff --git a/codegen/src/tinygo/plugin.ts b/codegen/src/tinygo/plugin.ts index 9b74e21..39c62d4 100644 --- a/codegen/src/tinygo/plugin.ts +++ b/codegen/src/tinygo/plugin.ts @@ -1,7 +1,7 @@ import { Configuration, TaskDefinition, -} from "https://deno.land/x/apex_cli@v0.0.15/src/config.ts"; +} from "https://deno.land/x/apex_cli@v0.0.18/src/config.ts"; import * as apex from "../deps/core/mod.ts"; const importUrl = new URL(".", import.meta.url); @@ -33,7 +33,8 @@ export default function ( config.config.aliases ||= {}; config.generates ||= {}; - const mode = config.config.mode || "export"; + const transport = config.config.transport as string || "wasmrs"; + const mode = config.config.mode as string || "export"; const mainRegenerate = config.config.mainRegenerate !== undefined ? config.config.mainRegenerate as boolean : true; @@ -67,34 +68,31 @@ export default function ( config.generates = generates; const prefixCmd = config.config.prefixCmd != undefined - ? config.config.prefixCmd - : `cmd/`; - let prefixPkg = config.config.prefixPkg != undefined + ? config.config.prefixCmd as string + : `cmd`; + const prefixPkg = config.config.prefixPkg != undefined ? config.config.prefixPkg as string - : `pkg/`; - - if (prefixPkg.length > 0 && !prefixPkg.endsWith("/")) { - prefixPkg += "/"; - } + : `pkg/${pkg}`; if (mode == "export") { - generates[`${prefixCmd}main.go`] = { + generates[`${trailingSlash(prefixCmd)}main.go`] = { ifNotExists: !mainRegenerate, module: mod, visitorClass: `MainVisitor`, config: { package: "main", - import: `${module}/pkg/${pkg}`, + import: `${module}/${prefixPkg}`, + transport: transport, }, }; - generates[`${prefixPkg}${pkg}/interfaces.go`] = { + generates[`${trailingSlash(prefixPkg)}interfaces.go`] = { module: mod, visitorClass: "InterfacesVisitor", }; - generates[`${prefixPkg}${pkg}/iota.go`] = { - module: "https://deno.land/x/apex_codegen@v0.1.6/go/mod.ts", + generates[`${trailingSlash(prefixPkg)}iota.go`] = { + module: "https://deno.land/x/apex_codegen@v0.1.9/go/mod.ts", visitorClass: "GoVisitor", append: [ { @@ -113,7 +111,7 @@ export default function ( }; if (hasServices) { - generates[`${prefixPkg}${pkg}/services.go`] = { + generates[`${trailingSlash(prefixPkg)}services.go`] = { ifNotExists: true, module: mod, visitorClass: `ScaffoldVisitor`, @@ -123,8 +121,8 @@ export default function ( }; } } else if (mode == "import") { - generates[`${prefixPkg}${pkg}/iota.go`] = { - module: "https://deno.land/x/apex_codegen@v0.1.6/go/mod.ts", + generates[`${trailingSlash(prefixPkg)}iota.go`] = { + module: "https://deno.land/x/apex_codegen@v0.1.9/go/mod.ts", visitorClass: "GoVisitor", append: [ { @@ -180,3 +178,10 @@ export default function ( return config; } + +function trailingSlash(value: string): string { + if (!value.endsWith("/")) { + return value + "/"; + } + return value; +} diff --git a/codegen/src/tinygo/register_visitor.ts b/codegen/src/tinygo/register_visitor.ts index 6a7c60b..a8bdfda 100644 --- a/codegen/src/tinygo/register_visitor.ts +++ b/codegen/src/tinygo/register_visitor.ts @@ -15,7 +15,11 @@ limitations under the License. */ import { Context, Kind, Stream } from "../deps/core/model.ts"; -import { getImporter, GoVisitor, setExpandStreamPattern } from "../deps/codegen/go.ts"; +import { + getImporter, + GoVisitor, + setExpandStreamPattern, +} from "../deps/codegen/go.ts"; import { capitalize, isHandler, @@ -33,7 +37,6 @@ export class RegisterVisitor extends GoVisitor { if (!isHandler(context) || noCode(context.operation)) { return; } - const { interface: iface } = context; this.write(`func Register${iface.name}(svc ${iface.name}) {\n`); @@ -45,6 +48,7 @@ export class RegisterVisitor extends GoVisitor { } const { namespace: ns, interface: iface, operation } = context; + const $ = getImporter(context, IMPORTS); const wrapperName = `${uncapitalize(iface.name)}${ capitalize( diff --git a/codegen/src/tinygo/scaffold_visitor.ts b/codegen/src/tinygo/scaffold_visitor.ts index f1b98fa..c6b3590 100644 --- a/codegen/src/tinygo/scaffold_visitor.ts +++ b/codegen/src/tinygo/scaffold_visitor.ts @@ -14,24 +14,11 @@ See the License for the specific language governing permissions and limitations under the License. */ -import { - Alias, - AnyType, - BaseVisitor, - Context, - Kind, - List, - Map, - Operation, - Optional, - Primitive, - PrimitiveName, - Stream, - Type, -} from "../deps/core/model.ts"; +import { Context, Kind, Stream } from "../deps/core/model.ts"; import { expandType, - Import, + getImporter, + GoVisitor, mapParams, methodName, receiver, @@ -39,11 +26,11 @@ import { } from "../deps/codegen/go.ts"; import { camelCase, - hasServiceCode, isOneOfType, isVoid, noCode, } from "../deps/codegen/utils.ts"; +import { IMPORTS } from "./constants.ts"; interface Logger { import: string; @@ -54,49 +41,21 @@ function getLogger(context: Context): Logger | undefined { return context.config.logger as Logger; } -export class ScaffoldVisitor extends BaseVisitor { +export class ScaffoldVisitor extends GoVisitor { writeHead(context: Context): void { context.config.doNotEdit = false; super.writeHead(context); } visitNamespaceBefore(context: Context): void { - const packageName = context.config.package || "myapp"; super.visitNamespaceBefore(context); - const logger = getLogger(context); - - const roleNames = (context.config.names as string[]) || []; - const roleTypes = (context.config.types as string[]) || []; - - const hasInterfaces = - Object.values(context.namespace.interfaces).find((iface) => { - const c = context.clone({ interface: iface }); - return isOneOfType(c, roleTypes) || roleNames.indexOf(iface.name) != -1; - }) != undefined; - - this.write(`package ${packageName}\n\n`); - - // Only emit import section if there are interfaces to generate. - if (hasInterfaces) { - this.write(`import (\n`); - if (hasServiceCode(context)) { - this.write(`\t"context"\n`); - } - this.write(`\t"errors"\n`); - const importsVisitor = new ImportsVisitor(this.writer); - context.namespace.accept(context, importsVisitor); - if (logger) { - this.write(`\t"${logger.import}"\n`); - } - this.write(`)\n\n`); - } const service = new ServiceVisitor(this.writer); context.namespace.accept(context, service); } } -class ServiceVisitor extends BaseVisitor { +class ServiceVisitor extends GoVisitor { visitInterfaceBefore(context: Context): void { const roleNames = (context.config.names as string[]) || []; const roleTypes = (context.config.types as string[]) || []; @@ -133,230 +92,106 @@ class ServiceVisitor extends BaseVisitor { this.write(`, `); } } - this.write(`${ - dependencies - .map((e) => camelCase(e) + " " + e) - .join(", ") - }) *${iface.name}Impl { + this.write(`deps Dependencies) *${iface.name}Impl { return &${iface.name}Impl{\n`); if (logger) { this.write("log: log,\n"); } this.write(`${ dependencies - .map((e) => camelCase(e) + ": " + camelCase(e) + ",") + .map((e) => camelCase(e) + `: deps.${e},`) .join("\n\t\t") } } }\n\n`); } + visitFunction(context: Context): void { + this.handleOperation(context); + } + visitOperation(context: Context): void { if (!isValid(context)) { return; } + this.handleOperation(context); + } + + handleOperation(context: Context): void { + const $ = getImporter(context, IMPORTS); const { operation, interface: iface } = context; if (noCode(operation)) { return; } this.write(`\n`); - this.write( - `func (${receiver(iface)} *${iface.name}Impl) ${ - methodName( - operation, - operation.name, - ) - }(`, - ); + if (iface) { + this.write( + `func (${receiver(iface)} *${iface.name}Impl) ${ + methodName( + operation, + operation.name, + ) + }(`, + ); + } else { + this.write( + `func ${ + methodName( + operation, + operation.name, + ) + }(`, + ); + } const translate = translateAlias(context); this.write( `${mapParams(context, operation.parameters, undefined, translate)})`, ); if (!isVoid(operation.type)) { let t = operation.type; - let rxWrapper = `mono.Mono`; + let rxWrapper; if (t.kind == Kind.Stream) { const s = t as Stream; t = s.type; - rxWrapper = `flux.Flux`; + rxWrapper = `${$.flux}.Flux`; + } else { + rxWrapper = `${$.mono}.Mono`; } - const expanded = expandType(operation.type, undefined, true, translate); + const expanded = expandType(t, undefined, true, translate); this.write(` ${rxWrapper}[${expanded}]`); } else { - this.write(` mono.Void`); + this.write(` ${$.mono}.Void`); } this.write(` {\n`); this.write(` // TODO: Provide implementation.\n`); if (!isVoid(operation.type)) { let t = operation.type; - let rxWrapper = `mono`; + let rxWrapper; if (t.kind == Kind.Stream) { const s = t as Stream; t = s.type; - rxWrapper = `flux`; + rxWrapper = `${$.flux}`; + } else { + rxWrapper = `${$.mono}`; } - const expanded = expandType(operation.type, undefined, true, translate); + const expanded = expandType(t, undefined, true, translate); this.write( - ` return ${rxWrapper}.Error[${expanded}](errors.New("not_implemented"))\n`, + ` return ${rxWrapper}.Error[${expanded}](${$.errors}.New("not_implemented"))\n`, ); } else { this.write( - ` return mono.Error[struct{}](errors.New("not_implemented"))\n`, + ` return ${$.mono}.Error[struct{}](${$.errors}.New("not_implemented"))\n`, ); } this.write(`}\n`); } } -class ImportsVisitor extends BaseVisitor { - private imports: { [key: string]: Import } = {}; - private externalImports: { [key: string]: Import } = {}; - - visitNamespaceAfter(_context: Context): void { - const stdLib = []; - for (const key in this.imports) { - const i = this.imports[key]; - if (i.import) { - stdLib.push(i.import); - } - } - stdLib.sort(); - for (const lib of stdLib) { - this.write(`\t"${lib}"\n`); - } - - const thirdPartyLib = []; - for (const key in this.externalImports) { - const i = this.externalImports[key]; - if (i.import) { - thirdPartyLib.push(i.import); - } - } - thirdPartyLib.sort(); - if (thirdPartyLib.length > 0) { - this.write(`\n`); - } - for (const lib of thirdPartyLib) { - this.write(`\t"${lib}"\n`); - } - } - - visitFunction(context: Context): void { - this.checkReturn(context.operation); - super.visitFunction(context); - } - - visitParameter(context: Context): void { - if (!isValid(context)) { - return; - } - this.checkType(context, context.parameter.type); - } - - visitOperation(context: Context): void { - if (!isValid(context)) { - return; - } - this.checkReturn(context.operation); - this.checkType(context, context.operation.type); - } - - addType(name: string, i: Import) { - if (i == undefined || i.import == undefined) { - return; - } - if (i.import.indexOf(".") != -1) { - if (this.externalImports[name] === undefined) { - this.externalImports[name] = i; - } - } else { - if (this.imports[name] === undefined) { - this.imports[name] = i; - } - } - } - - checkReturn(operation: Operation) { - if (operation.type.kind != Kind.Stream) { - this.addType("mono", { - type: "mono.Mono", - import: "github.com/nanobus/iota/go/rx/mono", - }); - } - } - - checkType(context: Context, type: AnyType): void { - const aliases = (context.config.aliases as { [key: string]: Import }) || {}; - - switch (type.kind) { - case Kind.Alias: { - const a = type as Alias; - const i = aliases[a.name]; - this.addType(a.name, i); - break; - } - - case Kind.Primitive: { - const prim = type as Primitive; - switch (prim.name) { - case PrimitiveName.DateTime: - this.addType("Time", { - type: "time.Time", - import: "time", - }); - break; - } - break; - } - case Kind.Type: { - const named = type as Type; - const i = aliases[named.name]; - if (named.name === "datetime" && i == undefined) { - this.addType("Time", { - type: "time.Time", - import: "time", - }); - return; - } - this.addType(named.name, i); - break; - } - case Kind.List: { - const list = type as List; - this.checkType(context, list.type); - break; - } - case Kind.Map: { - const map = type as Map; - this.checkType(context, map.keyType); - this.checkType(context, map.valueType); - break; - } - case Kind.Optional: { - const optional = type as Optional; - this.checkType(context, optional.type); - break; - } - case Kind.Stream: { - const stream = type as Stream; - this.addType("flux", { - type: "flux.Flux", - import: "github.com/nanobus/iota/go/rx/flux", - }); - this.checkType(context, stream.type); - break; - } - case Kind.Enum: { - break; - } - } - } -} - function isValid(context: Context): boolean { const roleNames = (context.config.names as string[]) || []; const roleTypes = (context.config.types as string[]) || []; const { interface: iface } = context; - return isOneOfType(context, roleTypes) || roleNames.indexOf(iface.name) != -1; + return isOneOfType(context, roleTypes) || + (iface && roleNames.indexOf(iface.name) != -1); } diff --git a/codegen/src/tinygo/wrappers_visitor.ts b/codegen/src/tinygo/wrappers_visitor.ts index 2c0f662..ec1003f 100644 --- a/codegen/src/tinygo/wrappers_visitor.ts +++ b/codegen/src/tinygo/wrappers_visitor.ts @@ -18,32 +18,39 @@ import { Alias, Context, Enum, + Interface, Kind, List, + Map, Primitive, Stream, } from "../deps/core/model.ts"; import { expandType, getImporter, + getImports, GoVisitor, + Import, methodName, - msgpackRead, - msgpackVarAccessParam, returnShare, setExpandStreamPattern, translateAlias, } from "../deps/codegen/go.ts"; import { + camelCase, capitalize, isHandler, isObject, - isProvider, isVoid, noCode, operationArgsType, uncapitalize, } from "../deps/codegen/utils.ts"; +import { + msgpackRead, + msgpackVarAccessParam, + msgpackWrite, +} from "./msgpack_helpers.ts"; import { IMPORTS, primitiveTransformers } from "./constants.ts"; export class WrappersVisitor extends GoVisitor { @@ -59,7 +66,7 @@ export class WrappersVisitor extends GoVisitor { } visitFunction(context: Context): void { - if (isProvider(context)) { + if (noCode(context.operation)) { return; } this.doRegister(context); @@ -97,6 +104,7 @@ export class WrappersVisitor extends GoVisitor { const tr = translateAlias(context); const { interface: iface, operation } = context; const $ = getImporter(context, IMPORTS); + const imports = getImports(context); const handlerName = `${capitalize(operation.name)}Fn`; const wrapperName = iface ? `${uncapitalize(iface.name)}${capitalize(operation.name)}Wrapper` @@ -105,14 +113,17 @@ export class WrappersVisitor extends GoVisitor { let rxWrapper = "mono.Mono"; let rxArgs = `p ${$.payload}.Payload`; let rxHandlerIn = ``; - const rxPackage = operation.type.kind == Kind.Stream ? `${$.flux}` : `${$.mono}`; const streams = operation.parameters .filter((p) => p.type.kind == Kind.Stream) .map((p) => (p.type as Stream).type); + const streamIn = streams.length > 0 ? streams[0] : undefined; + const rxPackage = operation.type.kind == Kind.Stream || streamIn + ? `${$.flux}` + : `${$.mono}`; + const parameters = operation.parameters.filter( (p) => p.type.kind != Kind.Stream, ); - const streamIn = streams.length > 0 ? streams[0] : undefined; if (streams.length > 1) { throw new Error( @@ -128,6 +139,7 @@ export class WrappersVisitor extends GoVisitor { switch (streamIn.kind) { case Kind.Primitive: { const prim = streamIn as Primitive; + imports.thirdparty(IMPORTS.transform); rxHandlerIn = `, ${$.flux}.Map(in, ${ primitiveTransformers.get( prim.name, @@ -137,18 +149,81 @@ export class WrappersVisitor extends GoVisitor { } case Kind.Enum: { const e = streamIn as Enum; - rxHandlerIn = `, ${$.flux}.Map(in, ${$.transform}.Int32Decode[${e.name}])`; + rxHandlerIn = + `, ${$.flux}.Map(in, ${$.transform}.Int32Decode[${e.name}])`; + break; + } + case Kind.List: { + const l = streamIn as List; + const expanded = expandType(l.type, undefined, false, tr); + rxHandlerIn = + `, ${$.flux}.Map(in, ${$.transform}.SliceDecode(func(decoder ${$.msgpack}.Reader) (${expanded}, error) { + ${ + msgpackRead( + context, + false, + "", + false, + "", + l.type, + false, + ) + }}))`; + break; + } + case Kind.Map: { + const m = streamIn as Map; + const expandedKey = expandType(m.keyType, undefined, false, tr); + const expandedVal = expandType(m.valueType, undefined, false, tr); + rxHandlerIn = `, ${$.flux}.Map(in, ${$.transform}.MapDecode( + func(decoder ${$.msgpack}.Reader) (${expandedKey}, error) { + ${ + msgpackRead( + context, + false, + "", + false, + "", + m.keyType, + false, + ) + }}, func(decoder ${$.msgpack}.Reader) (${expandedVal}, error) { + ${ + msgpackRead( + context, + false, + "", + false, + "", + m.valueType, + false, + ) + }}))`; break; } case Kind.Alias: { const a = streamIn as Alias; if (a.type.kind == Kind.Primitive) { const p = a.type as Primitive; - rxHandlerIn = `, ${$.flux}.Map(in, ${$.transform}.${ - capitalize( - p.name, - ) - }Decode[${a.name}])`; + const aliases = + (context.config.aliases as { [key: string]: Import }) || + {}; + const imp = aliases[a.name]; + if (imp && imp.parse) { + if (imp.import) { + imports.thirdparty(imp.import); + } + rxHandlerIn = + `, ${$.flux}.Map(in, ${$.transform}.ToStringDecode(func (val string) (${imp.type}, error) { + return ${imp.parse}(val) + }))`; + } else { + rxHandlerIn = `, ${$.flux}.Map(in, ${$.transform}.${ + capitalize( + p.name, + ) + }Decode[${a.name}])`; + } } else { const expanded = expandType(a.type, undefined, undefined, tr); rxHandlerIn = @@ -215,8 +290,22 @@ export class WrappersVisitor extends GoVisitor { }.Decode(p) if err != nil { return ${rxPackage}.Error[${$.payload}.Payload](err) + }\n`); + + const aliases = (context.config.aliases as { [key: string]: Import }) || + {}; + const imp = aliases[a.name]; + if (imp && imp.parse) { + if (imp.import) { + imports.thirdparty(imp.import); } - request := ${unaryParamExpanded}(aliasVal)\n`); + this.write(`request, err := ${imp.parse}(aliasVal) + if err != nil { + return ${rxPackage}.Error[${$.payload}.Payload](err) + }\n`); + } else { + this.write(`request := ${unaryParamExpanded}(aliasVal)\n`); + } } else if (isObject(unaryParam.type)) { this.write(`var request ${ expandType( @@ -231,7 +320,8 @@ export class WrappersVisitor extends GoVisitor { }\n`); } else { this.write( - `decoder := ${$.msgpack}.NewDecoder(p.Data()) + `d := ${$.msgpack}.NewDecoder(p.Data()) + decoder := &d ${ msgpackRead( context, @@ -248,29 +338,54 @@ export class WrappersVisitor extends GoVisitor { return ${rxPackage}.Error[${$.payload}.Payload](err) }\n`); } - this.write( - `response := ${handlerMethodName}(ctx, ${ - returnShare( - unaryParam.type, - ) - }request${rxHandlerIn})\n`, - ); + + if (streamIn && operation.type.kind != Kind.Stream) { + this.write( + `responseStream := ${handlerMethodName}(ctx, { + returnShare( + unaryParam.type, + ) + }request${rxHandlerIn})\n`, + ); + this.write(`response := ${$.transform}.MonoToFlux(responseStream)\n`); + } else { + this.write( + `response := ${handlerMethodName}(ctx, ${ + returnShare( + unaryParam.type, + ) + }request${rxHandlerIn})\n`, + ); + } } else { if (parameters.length > 0) { const argsName = operationArgsType(iface, operation); - this.write(`var inputArgs ${argsName} + this.write(`inputArgs := Default${argsName}() if err := ${$.transform}.CodecDecode(p, &inputArgs); err != nil { return ${rxPackage}.Error[${$.payload}.Payload](err) }\n`); } - this.write( - `response := ${handlerMethodName}(${ - msgpackVarAccessParam( - "inputArgs", - parameters, - ) - }${rxHandlerIn})\n`, - ); + + if (streamIn && operation.type.kind != Kind.Stream) { + this.write( + `responseStream := ${handlerMethodName}(${ + msgpackVarAccessParam( + "inputArgs", + parameters, + ) + }${rxHandlerIn})\n`, + ); + this.write(`response := ${$.transform}.MonoToFlux(responseStream)\n`); + } else { + this.write( + `response := ${handlerMethodName}(${ + msgpackVarAccessParam( + "inputArgs", + parameters, + ) + }${rxHandlerIn})\n`, + ); + } } let returnType = operation.type; if (returnType.kind == Kind.Stream) { @@ -278,9 +393,12 @@ export class WrappersVisitor extends GoVisitor { } if (isVoid(returnType)) { this.visitWrapperBeforeReturn(context); - this.write(`return ${$.mono}.Map(response, ${$.transform}.Void.Encode)\n`); + this.write( + `return ${rxPackage}.Map(response, ${$.transform}.Void.Encode)\n`, + ); } else if (returnType.kind == Kind.Primitive) { const prim = returnType as Primitive; + imports.thirdparty(IMPORTS.transform); this.write( `return ${rxPackage}.Map(response, ${ primitiveTransformers.get( @@ -293,7 +411,18 @@ export class WrappersVisitor extends GoVisitor { let transformFn = `${$.transform}.${capitalize(a.name)}.Encode`; if (a.type.kind == Kind.Primitive) { const p = a.type as Primitive; - transformFn = `${$.transform}.${capitalize(p.name)}Encode[${a.name}]`; + const aliases = (context.config.aliases as { [key: string]: Import }) || + {}; + const imp = aliases[a.name]; + if (imp && imp.parse) { + if (imp.import) { + imports.thirdparty(imp.import); + } + transformFn = `${$.transform}.ToStringEncode( + func (v ${imp.type}) string { return v.${imp.format}() })`; + } else { + transformFn = `${$.transform}.${capitalize(p.name)}Encode[${a.name}]`; + } } else { const expanded = expandType(a.type, undefined, undefined, tr); transformFn = `func(value ${a.name}) (${$.payload}.Payload, error) { @@ -310,23 +439,72 @@ export class WrappersVisitor extends GoVisitor { const l = returnType as List; const expanded = expandType(l.type, undefined, undefined, tr); this.write( - `return ${$.mono}.Map(response, ${$.transform}.SliceEncode[${expanded}])`, + `return ${rxPackage}.Map(response, ${$.transform}.SliceEncode(func(writer ${$.msgpack}.Writer, val ${expanded}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "val", + l.type, + false, + ) + } }))`, + ); + } else if (returnType.kind == Kind.Map) { + const m = returnType as Map; + const expandedKey = expandType(m.keyType, undefined, undefined, tr); + const expandedVal = expandType(m.valueType, undefined, undefined, tr); + this.write( + `return ${rxPackage}.Map(response, ${$.transform}.MapEncode(func(writer ${$.msgpack}.Writer, key ${expandedKey}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "key", + m.keyType, + false, + ) + } }, func(writer ${$.msgpack}.Writer, val ${expandedVal}) { + ${ + msgpackWrite( + context, + "writer", + false, + "", + "", + "val", + m.valueType, + false, + ) + } }))`, ); } else if (isObject(returnType)) { this.visitWrapperBeforeReturn(context); this.write( `return ${rxPackage}.Map(response, ${$.transform}.MsgPackEncode[${ expandType( - operation.type, + returnType, undefined, false, tr, ) }])\n`, ); + } else if (returnType.kind == Kind.Interface) { + const iface = returnType as Interface; + this.write( + `return ${rxPackage}.Map(response, ${$.transform}.InterfaceEncode(_${ + camelCase(iface.name) + }Instances))\n`, + ); } - this.write(`} - }\n\n`); + this.write(`}\n}\n\n`); } visitWrapperBeforeReturn(context: Context): void { diff --git a/codegen/test/templates.test.ts b/codegen/test/templates.test.ts deleted file mode 100644 index aecb153..0000000 --- a/codegen/test/templates.test.ts +++ /dev/null @@ -1,9 +0,0 @@ -import { parseTemplateExpression } from "../src/rust/templates.ts"; -import { assertEquals } from "./deps.ts"; - -Deno.test("template expressions", () => { - const replaced = parseTemplateExpression("${new_id}", { - new_id: "myNewId", - }); - assertEquals(replaced, "myNewId"); -}); diff --git a/codegen/testdata/diffcheck.sh b/codegen/testdata/diffcheck.sh index 912087c..894bae3 100755 --- a/codegen/testdata/diffcheck.sh +++ b/codegen/testdata/diffcheck.sh @@ -10,6 +10,7 @@ for dir in */; do echo "Generating code in $dir" mkdir -p "$dir/actual" cd "$dir/actual" + cp ../expected/go.* . apex generate ../apex.yaml cd .. echo "Checking $dir for diffs" diff --git a/codegen/testdata/tinygo/apex.axdl b/codegen/testdata/tinygo/apex.axdl index 0318809..4fb48d4 100644 --- a/codegen/testdata/tinygo/apex.axdl +++ b/codegen/testdata/tinygo/apex.axdl @@ -1,51 +1,204 @@ import * from "@apexlang/core" -import * from "@apexlang/rest" -import * from "@apexlang/openapi" - -namespace "urlshortener.v1" - @info( - title: "Simple URL shortener API" - description: "Simple API for shortening URLs created using NanoBus and Dapr." - version: "1.0.0" - termsOfService: "https://api.goodcorp.com/terms/" - contact: { - name: "API Support", - url: "https://api.goodcorp.com/support", - email: "api@goodcorp.com" - }, - license: { - name: "Apache 2.0", - url: "https://www.apache.org/licenses/LICENSE-2.0" - } - ) - @host("api.goodcorp.com") - @path("/v1") - -"The URL shortening service." -interface Shortener @service @uses([Repository]) { - "Shorten a URL and return a generated identifier." - shorten(url: string @url): URL - @PUT @path("/shorten") - - "Return the URL using the generated identifier." - lookup(id: string): URL - @GET @path("/{id}") @nocode + +namespace "iota.testing" + +# UUID is an alias that is mapped to a custom data type +alias UUID = string +alias MyAlias = string + +func someCalc(rhs: i64, lhs: i64): i64 + +interface MyStreamer @service { + requestStreamI64(): stream i64 + requestStreamF64(): stream f64 + requestStreamType(): stream MyType + requestStreamEnum(): stream MyEnum + requestStreamUUID(): stream UUID + requestStreamAlias(): stream MyAlias + requestStreamString(): stream string + requestStreamBool(): stream bool + requestStreamDatetime(): stream datetime + requestStreamList(): stream [string] + requestStreamMap(): stream { string : string } + requestStreamArgsI64(value: i64): stream i64 + requestStreamArgsF64(value: f64): stream f64 + requestStreamArgsType(value: MyType): stream MyType + requestStreamArgsEnum(value: MyEnum): stream MyEnum + requestStreamArgsUUID(value: UUID): stream UUID + requestStreamArgsAlias(value: MyAlias): stream MyAlias + requestStreamArgsString(value: string): stream string + requestStreamArgsBool(value: bool): stream bool + requestStreamArgsDatetime(value: datetime): stream datetime + requestStreamArgsList(value: [string]): stream [string] + requestStreamArgsMap(value: { string : string }): stream { string : string } + + requestChannelVoid(in: stream i64) + requestChannelSingle(in: stream i64): i64 + requestChannelI64(in: stream i64): stream i64 + requestChannelF64(in: stream f64): stream f64 + requestChannelType(in: stream MyType): stream MyType + requestChannelEnum(in: stream MyEnum): stream MyEnum + requestChannelAlias(in: stream UUID): stream UUID + requestChannelString(in: stream string): stream string + requestChannelBool(in: stream bool): stream bool + requestChannelDatetime(in: stream datetime): stream datetime + requestChannelList(in: stream [string]): stream [string] + requestChannelMap(in: stream { string : string }): stream { string : string } + requestChannelArgsSingle(value: i64, in: stream i64): i64 + requestChannelArgsI64(value: i64, in: stream i64): stream i64 + requestChannelArgsF64(value: f64, in: stream f64): stream f64 + requestChannelArgsType(value: MyType, in: stream MyType): stream MyType + requestChannelArgsEnum(value: MyEnum, in: stream MyEnum): stream MyEnum + requestChannelArgsAlias(value: UUID, in: stream UUID): stream UUID + requestChannelArgsString(value: string, in: stream string): stream string + requestChannelArgsBool(value: bool, in: stream bool): stream bool + requestChannelArgsDatetime(value: datetime, in: stream datetime): stream datetime + requestChannelArgsList(value: [string], in: stream [string]): stream [string] + requestChannelArgsMap(value: { string : string }, in: stream { string : string }): stream { string : string } +} + +interface MyService @service @uses(["Repository"]) { + emptyVoid(): void + unaryType[value: MyType]: MyType + unaryEnum[value : MyEnum]: MyEnum + unaryUUID[value : UUID]: UUID + unaryAlias[value : MyAlias]: MyAlias + unaryString[value : string]: string + unaryI64[value : i64]: i64 + unaryI32[value : i32]: i32 + unaryI16[value : i16]: i16 + unaryI8[value : i8]: i8 + unaryU64[value : u64]: u64 + unaryU32[value : u32]: u32 + unaryU16[value : u16]: u16 + unaryU8[value : u8]: u8 + unaryF64[value : f64]: f64 + unaryF32[value : f32]: f32 + unaryBytes[value : bytes]: bytes + unaryDatetime[value : datetime]: datetime + unaryList[value: [string]]: [string] + unaryMap[value: { string : string }]: { string : string } + + funcType(value: MyType, optional: MyType?): MyType + funcEnum(value: MyEnum, optional: MyEnum?): MyEnum + funcUUID(value: UUID, optional: UUID?): UUID + funcAlias(value: MyAlias, optional: MyAlias?): MyAlias + funcString(value: string, optional: string?): string + funcI64(value: i64, optional: i64?): i64 + funcI32(value: i32, optional: i32?): i32 + funcI16(value: i16, optional: i16?): i16 + funcI8(value: i8, optional: i8?): i8 + funcU64(value: u64, optional: u64?): u64 + funcU32(value: u32, optional: u32?): u32 + funcU16(value: u16, optional: u16?): u16 + funcU8(value: u8, optional: u8?): u8 + funcF64(value: f64, optional: f64?): f64 + funcF32(value: f32, optional: f32?): f32 + funcBytes(value: bytes, optional: bytes?): bytes + funcDatetime(value: datetime, optional: datetime?): datetime + funcList(value: [string], optional: [string]?): [string] + funcMap(value: { string : string }, optional: { string : string }?): { string : string } +} + +interface Repository @dependency { + getData(): MyType } -"Repository handles loading and storing shortened URLs." -interface Repository @provider { - "Load the URL by its identifier." - loadById(id: string): URL - "Load the ID by its URL." - loadByURL(url: string): URL - "Store a URL and its identifier." - storeURL[url: URL] +union MyUnion = MyType | MyEnum | string + +"MyType is a class" +type MyType { + "same type value" + sameValue: MyType? + "type value" + typeValue: MyOtherType + "string value" + stringValue: string + "string option" + stringOption: string? + "i64 value" + i64Value: i64 + "i64 option" + i64Option: i64? + "i32 value" + i32Value: i32 + "i32 option" + i32Option: i32? + "i16 value" + i16Value: i16 + "i16 option" + i16Option: i16? @n(10) + "i8 value" + i8Value: i8 @n(11) + "i8 option" + i8Option: i8? @n(12) + "u64 value" + u64Value: u64 @n(13) + "u64 option" + u64Option: u64? @n(14) + "u32 value" + u32Value: u32 @n(15) + "u32 option" + u32Option: u32? @n(16) + "u16 value" + u16Value: u16 @n(17) + "u16 option" + u16Option: u16? @n(18) + "u8 value" + u8Value: u8 @n(19) + "u8 option" + u8Option: u8? @n(20) + "f64 value" + f64Value: f64 @n(21) + "f64 option" + f64Option: f64? @n(22) + "f32 value" + f32Value: f32 @n(23) + "f32 option" + f32Option: f32? @n(24) + "datetime value" + datetimeValue: datetime @n(25) + "datetime option" + datetimeOption: datetime? @n(26) + "bytes value" + bytesValue: bytes @n(27) + "bytes option" + bytesOption: bytes? @n(28) + "map value" + mapValue: { string: i64 } @n(29) + "map of types" + mapOfTypes: { string: MyType } @n(30) + "array value" + arrayValue: [string] @n(31) + "array of types" + arrayOfTypes: [MyType] @n(32) + "union value" + unionValue: MyUnion @n(33) + "union option" + unionOption: MyUnion? @n(34) + "enum value" + enumValue: MyEnum @n(35) + "enum option" + enumOption: MyEnum? @n(36) + "enum value" + aliasValue: UUID @n(37) + "enum option" + aliasOption: UUID? @n(38) + # "any value" + # anyValue: any @n(999) } -"URL encapsulates the dynamic identifier and the URL it points to." -type URL @entity(table: "url") { - "The dynamically generated URL identifier." - id: string @key - "The original URL that was shortened." - url: string @rename({go: "URL"}) +type MyOtherType { + foo: string + bar: string } + +"MyEnum is an emuneration" +enum MyEnum { + "ONE value" + ONE = 0 as "one" + "TWO value" + TWO = 1 + "THREE value" + THREE = 2 as "three" +} \ No newline at end of file diff --git a/codegen/testdata/tinygo/apex.yaml b/codegen/testdata/tinygo/apex.yaml index d44fc1d..10274aa 100644 --- a/codegen/testdata/tinygo/apex.yaml +++ b/codegen/testdata/tinygo/apex.yaml @@ -1,34 +1,17 @@ spec: ../apex.axdl config: - module: github.com/nanobus/examples/urlshortener - package: urlshortener -generates: - cmd/main.go: - # ifNotExists: false - module: '../../../src/tinygo/mod.ts' - visitorClass: MainVisitor - config: - import: github.com/nanobus/examples/urlshortener/pkg/urlshortener - pkg/urlshortener/msgpack.go: - module: '../../../src/tinygo/mod.ts' - visitorClass: MsgPackVisitor - pkg/urlshortener/interfaces.go: - module: '../../../src/tinygo/mod.ts' - visitorClass: InterfacesVisitor - pkg/urlshortener/export.go: - module: '../../../src/tinygo/mod.ts' - visitorClass: ExportVisitor - pkg/urlshortener/providers.go: - module: '../../../src/tinygo/mod.ts' - visitorClass: ProviderVisitor - pkg/urlshortener/services.go: - # ifNotExists: true - module: 'https://deno.land/x/apex_codegen@v0.1.0/go/mod.ts' - visitorClass: ScaffoldVisitor - config: - types: - - service - bus.yaml: - # ifNotExists: true - module: '../../../src/bus/mod.ts' - visitorClass: BusVisitor + name: iotatest + module: github.com/nanobus/iota/testing/iotatest + package: iotatest +plugins: + - ../../../src/tinygo/plugin.ts +--- +spec: ../apex.axdl +config: + name: iotatest + module: github.com/nanobus/iota/testing/iotatest + package: client + mode: import + prefixPkg: pkg/client +plugins: + - ../../../src/tinygo/plugin.ts diff --git a/codegen/testdata/tinygo/expected/bus.yaml b/codegen/testdata/tinygo/expected/bus.yaml deleted file mode 100644 index 4af9f93..0000000 --- a/codegen/testdata/tinygo/expected/bus.yaml +++ /dev/null @@ -1,120 +0,0 @@ -application: - id: undefined - version: 0.0.1 - environment: local - -transports: - rest: - uses: rest - with: - address: :8080 - documentation: - swaggerUI: true - postman: true - restClient: true - httprpc: - uses: httprpc - with: - address: :9090 - -compute: - - uses: wasmrs - with: - filename: build/undefined.wasm - -specs: - - uses: apex - with: - filename: apex.aidl - -# json, msgpack, and xml are built-in codecs. -# Configure others here. -codecs: - # avro: - # type: confluentavro - # with: - # schemaRegistryURLs: - # - http://localhost:8081 - -inputBindings: - # - binding: twitter - # codec: json - # function: handleTweet - -subscriptions: - # - pubsub: pubsub - # topic: mytopic - # codec: json - -resiliency: - retries: - events: - policy: constant - duration: 3s - - # database: - # policy: constant - # duration: 3s - # - # publish: - # policy: constant - # duration: 3s - - circuitBreakers: - # database: - # policy: constant - # duration: 3s - # - # publish: - # maxRequests: 2 - # timeout: 30s - -services: - 'urlshortener.v1.Shortener': - # shorten: - # name: Shorten a URL and return a generated identifier. - # steps: - - lookup: - name: Return the URL using the generated identifier. - steps: - - -events: - -providers: - 'urlshortener.v1.Repository': - loadById: - name: Load the URL by its identifier. - steps: - # - name: Get state - # uses: '@dapr/get_state' - # with: - # resource: statestore - # key: input.id - # retry: database - # circuitBreaker: database - - loadByURL: - name: Load the ID by its URL. - steps: - # - name: Get state - # uses: '@dapr/get_state' - # with: - # resource: statestore - # key: input.id - # retry: database - # circuitBreaker: database - - storeURL: - name: Store a URL and its identifier. - steps: - # - name: Save state - # uses: '@dapr/set_state' - # with: - # resource: statestore - # items: - # - key: input.id - # retry: database - # circuitBreaker: database - diff --git a/codegen/testdata/tinygo/expected/cmd/main.go b/codegen/testdata/tinygo/expected/cmd/main.go index 373ccab..5bb0218 100644 --- a/codegen/testdata/tinygo/expected/cmd/main.go +++ b/codegen/testdata/tinygo/expected/cmd/main.go @@ -3,18 +3,19 @@ package main import ( "github.com/nanobus/iota/go/transport/wasmrs/guest" - "github.com/nanobus/examples/urlshortener/pkg/urlshortener" + "github.com/nanobus/iota/testing/iotatest/pkg/iotatest" ) func main() { - urlshortener.Initialize(guest.HostInvoker) - // Create providers - repositoryProvider := urlshortener.NewRepository() + deps := iotatest.GetDependencies(guest.HostInvoker) // Create services - shortenerService := urlshortener.NewShortener(repositoryProvider) + myStreamerService := iotatest.NewMyStreamer(deps) + myServiceService := iotatest.NewMyService(deps) // Register services - urlshortener.RegisterShortener(shortenerService) + iotatest.RegisterSomeCalc(iotatest.SomeCalc) + iotatest.RegisterMyStreamer(myStreamerService) + iotatest.RegisterMyService(myServiceService) } diff --git a/codegen/testdata/tinygo/expected/go.mod b/codegen/testdata/tinygo/expected/go.mod new file mode 100644 index 0000000..2754db8 --- /dev/null +++ b/codegen/testdata/tinygo/expected/go.mod @@ -0,0 +1,12 @@ +module github.com/nanobus/iota/testing/iotatest + +go 1.19 + +require ( + github.com/google/uuid v1.3.0 + github.com/nanobus/iota/go v0.0.0-20230205011029-b3c6923905e4 +) + +require golang.org/x/exp v0.0.0-20221230185412-738e83a70c30 // indirect + +replace github.com/nanobus/iota/go => ../../../../go diff --git a/codegen/testdata/tinygo/expected/go.sum b/codegen/testdata/tinygo/expected/go.sum new file mode 100644 index 0000000..e1e4ffa --- /dev/null +++ b/codegen/testdata/tinygo/expected/go.sum @@ -0,0 +1,10 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/nanobus/iota/go v0.0.0-20230205011029-b3c6923905e4 h1:TwtXRE4NT/1aIY6ZGyko3Ges1GrdXgYtd/+TQaq76dY= +github.com/nanobus/iota/go v0.0.0-20230205011029-b3c6923905e4/go.mod h1:8bZhaLzTq6LqwB0Gc0ZU4HVMDNROxCvQbmrdb+uEgCU= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +golang.org/x/exp v0.0.0-20221230185412-738e83a70c30 h1:m9O6OTJ627iFnN2JIWfdqlZCzneRO6EEBsHXI25P8ws= +golang.org/x/exp v0.0.0-20221230185412-738e83a70c30/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/codegen/testdata/tinygo/expected/pkg/client/iota.go b/codegen/testdata/tinygo/expected/pkg/client/iota.go new file mode 100644 index 0000000..233fd97 --- /dev/null +++ b/codegen/testdata/tinygo/expected/pkg/client/iota.go @@ -0,0 +1,4503 @@ +// Code generated by @apexlang/codegen. DO NOT EDIT. + +package client + +import ( + "context" + "encoding/binary" + "errors" + "time" + + "github.com/google/uuid" + "github.com/nanobus/iota/go/invoke" + "github.com/nanobus/iota/go/msgpack" + "github.com/nanobus/iota/go/msgpack/convert" + "github.com/nanobus/iota/go/payload" + "github.com/nanobus/iota/go/proxy" + "github.com/nanobus/iota/go/rx/flux" + "github.com/nanobus/iota/go/rx/mono" + "github.com/nanobus/iota/go/transform" +) + +type MyAlias string + +type SomeCalcFn func(ctx context.Context, rhs int64, lhs int64) mono.Mono[int64] + +type MyStreamer interface { + RequestStreamI64(ctx context.Context) flux.Flux[int64] + RequestStreamF64(ctx context.Context) flux.Flux[float64] + RequestStreamType(ctx context.Context) flux.Flux[MyType] + RequestStreamEnum(ctx context.Context) flux.Flux[MyEnum] + RequestStreamUUID(ctx context.Context) flux.Flux[uuid.UUID] + RequestStreamAlias(ctx context.Context) flux.Flux[MyAlias] + RequestStreamString(ctx context.Context) flux.Flux[string] + RequestStreamBool(ctx context.Context) flux.Flux[bool] + RequestStreamDatetime(ctx context.Context) flux.Flux[time.Time] + RequestStreamList(ctx context.Context) flux.Flux[[]string] + RequestStreamMap(ctx context.Context) flux.Flux[map[string]string] + RequestStreamArgsI64(ctx context.Context, value int64) flux.Flux[int64] + RequestStreamArgsF64(ctx context.Context, value float64) flux.Flux[float64] + RequestStreamArgsType(ctx context.Context, value *MyType) flux.Flux[MyType] + RequestStreamArgsEnum(ctx context.Context, value MyEnum) flux.Flux[MyEnum] + RequestStreamArgsUUID(ctx context.Context, value uuid.UUID) flux.Flux[uuid.UUID] + RequestStreamArgsAlias(ctx context.Context, value MyAlias) flux.Flux[MyAlias] + RequestStreamArgsString(ctx context.Context, value string) flux.Flux[string] + RequestStreamArgsBool(ctx context.Context, value bool) flux.Flux[bool] + RequestStreamArgsDatetime(ctx context.Context, value time.Time) flux.Flux[time.Time] + RequestStreamArgsList(ctx context.Context, value []string) flux.Flux[[]string] + RequestStreamArgsMap(ctx context.Context, value map[string]string) flux.Flux[map[string]string] + RequestChannelVoid(ctx context.Context, in flux.Flux[int64]) mono.Void + RequestChannelSingle(ctx context.Context, in flux.Flux[int64]) mono.Mono[int64] + RequestChannelI64(ctx context.Context, in flux.Flux[int64]) flux.Flux[int64] + RequestChannelF64(ctx context.Context, in flux.Flux[float64]) flux.Flux[float64] + RequestChannelType(ctx context.Context, in flux.Flux[MyType]) flux.Flux[MyType] + RequestChannelEnum(ctx context.Context, in flux.Flux[MyEnum]) flux.Flux[MyEnum] + RequestChannelAlias(ctx context.Context, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] + RequestChannelString(ctx context.Context, in flux.Flux[string]) flux.Flux[string] + RequestChannelBool(ctx context.Context, in flux.Flux[bool]) flux.Flux[bool] + RequestChannelDatetime(ctx context.Context, in flux.Flux[time.Time]) flux.Flux[time.Time] + RequestChannelList(ctx context.Context, in flux.Flux[[]string]) flux.Flux[[]string] + RequestChannelMap(ctx context.Context, in flux.Flux[map[string]string]) flux.Flux[map[string]string] + RequestChannelArgsSingle(ctx context.Context, value int64, in flux.Flux[int64]) mono.Mono[int64] + RequestChannelArgsI64(ctx context.Context, value int64, in flux.Flux[int64]) flux.Flux[int64] + RequestChannelArgsF64(ctx context.Context, value float64, in flux.Flux[float64]) flux.Flux[float64] + RequestChannelArgsType(ctx context.Context, value *MyType, in flux.Flux[MyType]) flux.Flux[MyType] + RequestChannelArgsEnum(ctx context.Context, value MyEnum, in flux.Flux[MyEnum]) flux.Flux[MyEnum] + RequestChannelArgsAlias(ctx context.Context, value uuid.UUID, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] + RequestChannelArgsString(ctx context.Context, value string, in flux.Flux[string]) flux.Flux[string] + RequestChannelArgsBool(ctx context.Context, value bool, in flux.Flux[bool]) flux.Flux[bool] + RequestChannelArgsDatetime(ctx context.Context, value time.Time, in flux.Flux[time.Time]) flux.Flux[time.Time] + RequestChannelArgsList(ctx context.Context, value []string, in flux.Flux[[]string]) flux.Flux[[]string] + RequestChannelArgsMap(ctx context.Context, value map[string]string, in flux.Flux[map[string]string]) flux.Flux[map[string]string] +} + +type MyService interface { + EmptyVoid(ctx context.Context) mono.Void + UnaryType(ctx context.Context, value *MyType) mono.Mono[MyType] + UnaryEnum(ctx context.Context, value MyEnum) mono.Mono[MyEnum] + UnaryUUID(ctx context.Context, value uuid.UUID) mono.Mono[uuid.UUID] + UnaryAlias(ctx context.Context, value MyAlias) mono.Mono[MyAlias] + UnaryString(ctx context.Context, value string) mono.Mono[string] + UnaryI64(ctx context.Context, value int64) mono.Mono[int64] + UnaryI32(ctx context.Context, value int32) mono.Mono[int32] + UnaryI16(ctx context.Context, value int16) mono.Mono[int16] + UnaryI8(ctx context.Context, value int8) mono.Mono[int8] + UnaryU64(ctx context.Context, value uint64) mono.Mono[uint64] + UnaryU32(ctx context.Context, value uint32) mono.Mono[uint32] + UnaryU16(ctx context.Context, value uint16) mono.Mono[uint16] + UnaryU8(ctx context.Context, value uint8) mono.Mono[uint8] + UnaryF64(ctx context.Context, value float64) mono.Mono[float64] + UnaryF32(ctx context.Context, value float32) mono.Mono[float32] + UnaryBytes(ctx context.Context, value []byte) mono.Mono[[]byte] + UnaryDatetime(ctx context.Context, value time.Time) mono.Mono[time.Time] + UnaryList(ctx context.Context, value []string) mono.Mono[[]string] + UnaryMap(ctx context.Context, value map[string]string) mono.Mono[map[string]string] + FuncType(ctx context.Context, value *MyType, optional *MyType) mono.Mono[MyType] + FuncEnum(ctx context.Context, value MyEnum, optional *MyEnum) mono.Mono[MyEnum] + FuncUUID(ctx context.Context, value uuid.UUID, optional *uuid.UUID) mono.Mono[uuid.UUID] + FuncAlias(ctx context.Context, value MyAlias, optional *MyAlias) mono.Mono[MyAlias] + FuncString(ctx context.Context, value string, optional *string) mono.Mono[string] + FuncI64(ctx context.Context, value int64, optional *int64) mono.Mono[int64] + FuncI32(ctx context.Context, value int32, optional *int32) mono.Mono[int32] + FuncI16(ctx context.Context, value int16, optional *int16) mono.Mono[int16] + FuncI8(ctx context.Context, value int8, optional *int8) mono.Mono[int8] + FuncU64(ctx context.Context, value uint64, optional *uint64) mono.Mono[uint64] + FuncU32(ctx context.Context, value uint32, optional *uint32) mono.Mono[uint32] + FuncU16(ctx context.Context, value uint16, optional *uint16) mono.Mono[uint16] + FuncU8(ctx context.Context, value uint8, optional *uint8) mono.Mono[uint8] + FuncF64(ctx context.Context, value float64, optional *float64) mono.Mono[float64] + FuncF32(ctx context.Context, value float32, optional *float32) mono.Mono[float32] + FuncBytes(ctx context.Context, value []byte, optional []byte) mono.Mono[[]byte] + FuncDatetime(ctx context.Context, value time.Time, optional *time.Time) mono.Mono[time.Time] + FuncList(ctx context.Context, value []string, optional []string) mono.Mono[[]string] + FuncMap(ctx context.Context, value map[string]string, optional map[string]string) mono.Mono[map[string]string] +} + +type Repository interface { + GetData(ctx context.Context) mono.Mono[MyType] +} + +// MyType is a class +type MyType struct { + // same type value + SameValue *MyType `json:"sameValue,omitempty" yaml:"sameValue,omitempty" msgpack:"sameValue,omitempty"` + // type value + TypeValue MyOtherType `json:"typeValue" yaml:"typeValue" msgpack:"typeValue"` + // string value + StringValue string `json:"stringValue" yaml:"stringValue" msgpack:"stringValue"` + // string option + StringOption *string `json:"stringOption,omitempty" yaml:"stringOption,omitempty" msgpack:"stringOption,omitempty"` + // i64 value + I64Value int64 `json:"i64Value" yaml:"i64Value" msgpack:"i64Value"` + // i64 option + I64Option *int64 `json:"i64Option,omitempty" yaml:"i64Option,omitempty" msgpack:"i64Option,omitempty"` + // i32 value + I32Value int32 `json:"i32Value" yaml:"i32Value" msgpack:"i32Value"` + // i32 option + I32Option *int32 `json:"i32Option,omitempty" yaml:"i32Option,omitempty" msgpack:"i32Option,omitempty"` + // i16 value + I16Value int16 `json:"i16Value" yaml:"i16Value" msgpack:"i16Value"` + // i16 option + I16Option *int16 `json:"i16Option,omitempty" yaml:"i16Option,omitempty" msgpack:"i16Option,omitempty"` + // i8 value + I8Value int8 `json:"i8Value" yaml:"i8Value" msgpack:"i8Value"` + // i8 option + I8Option *int8 `json:"i8Option,omitempty" yaml:"i8Option,omitempty" msgpack:"i8Option,omitempty"` + // u64 value + U64Value uint64 `json:"u64Value" yaml:"u64Value" msgpack:"u64Value"` + // u64 option + U64Option *uint64 `json:"u64Option,omitempty" yaml:"u64Option,omitempty" msgpack:"u64Option,omitempty"` + // u32 value + U32Value uint32 `json:"u32Value" yaml:"u32Value" msgpack:"u32Value"` + // u32 option + U32Option *uint32 `json:"u32Option,omitempty" yaml:"u32Option,omitempty" msgpack:"u32Option,omitempty"` + // u16 value + U16Value uint16 `json:"u16Value" yaml:"u16Value" msgpack:"u16Value"` + // u16 option + U16Option *uint16 `json:"u16Option,omitempty" yaml:"u16Option,omitempty" msgpack:"u16Option,omitempty"` + // u8 value + U8Value uint8 `json:"u8Value" yaml:"u8Value" msgpack:"u8Value"` + // u8 option + U8Option *uint8 `json:"u8Option,omitempty" yaml:"u8Option,omitempty" msgpack:"u8Option,omitempty"` + // f64 value + F64Value float64 `json:"f64Value" yaml:"f64Value" msgpack:"f64Value"` + // f64 option + F64Option *float64 `json:"f64Option,omitempty" yaml:"f64Option,omitempty" msgpack:"f64Option,omitempty"` + // f32 value + F32Value float32 `json:"f32Value" yaml:"f32Value" msgpack:"f32Value"` + // f32 option + F32Option *float32 `json:"f32Option,omitempty" yaml:"f32Option,omitempty" msgpack:"f32Option,omitempty"` + // datetime value + DatetimeValue time.Time `json:"datetimeValue" yaml:"datetimeValue" msgpack:"datetimeValue"` + // datetime option + DatetimeOption *time.Time `json:"datetimeOption,omitempty" yaml:"datetimeOption,omitempty" msgpack:"datetimeOption,omitempty"` + // bytes value + BytesValue []byte `json:"bytesValue" yaml:"bytesValue" msgpack:"bytesValue"` + // bytes option + BytesOption []byte `json:"bytesOption,omitempty" yaml:"bytesOption,omitempty" msgpack:"bytesOption,omitempty"` + // map value + MapValue map[string]int64 `json:"mapValue" yaml:"mapValue" msgpack:"mapValue"` + // map of types + MapOfTypes map[string]MyType `json:"mapOfTypes" yaml:"mapOfTypes" msgpack:"mapOfTypes"` + // array value + ArrayValue []string `json:"arrayValue" yaml:"arrayValue" msgpack:"arrayValue"` + // array of types + ArrayOfTypes []MyType `json:"arrayOfTypes" yaml:"arrayOfTypes" msgpack:"arrayOfTypes"` + // union value + UnionValue MyUnion `json:"unionValue" yaml:"unionValue" msgpack:"unionValue"` + // union option + UnionOption *MyUnion `json:"unionOption,omitempty" yaml:"unionOption,omitempty" msgpack:"unionOption,omitempty"` + // enum value + EnumValue MyEnum `json:"enumValue" yaml:"enumValue" msgpack:"enumValue"` + // enum option + EnumOption *MyEnum `json:"enumOption,omitempty" yaml:"enumOption,omitempty" msgpack:"enumOption,omitempty"` + // enum value + AliasValue uuid.UUID `json:"aliasValue" yaml:"aliasValue" msgpack:"aliasValue"` + // enum option + AliasOption *uuid.UUID `json:"aliasOption,omitempty" yaml:"aliasOption,omitempty" msgpack:"aliasOption,omitempty"` +} + +// DefaultMyType returns a `MyType` struct populated with its default values. +func DefaultMyType() MyType { + return MyType{} +} + +type MyOtherType struct { + Foo string `json:"foo" yaml:"foo" msgpack:"foo"` + Bar string `json:"bar" yaml:"bar" msgpack:"bar"` +} + +// DefaultMyOtherType returns a `MyOtherType` struct populated with its default +// values. +func DefaultMyOtherType() MyOtherType { + return MyOtherType{} +} + +type MyUnion struct { + MyType *MyType `json:"MyType,omitempty" yaml:"MyType,omitempty" msgpack:"MyType,omitempty"` + MyEnum *MyEnum `json:"MyEnum,omitempty" yaml:"MyEnum,omitempty" msgpack:"MyEnum,omitempty"` + String *string `json:"string,omitempty" yaml:"string,omitempty" msgpack:"string,omitempty"` +} + +// MyEnum is an emuneration +type MyEnum int32 + +const ( + // ONE value + MyEnumOne MyEnum = 0 + // TWO value + MyEnumTwo MyEnum = 1 + // THREE value + MyEnumThree MyEnum = 2 +) + +var toStringMyEnum = map[MyEnum]string{ + MyEnumOne: "one", + MyEnumTwo: "TWO", + MyEnumThree: "three", +} + +var toIDMyEnum = map[string]MyEnum{ + "one": MyEnumOne, + "TWO": MyEnumTwo, + "three": MyEnumThree, +} + +func (e MyEnum) String() string { + str, ok := toStringMyEnum[e] + if !ok { + return "unknown" + } + return str +} + +func (e *MyEnum) FromString(str string) error { + var ok bool + *e, ok = toIDMyEnum[str] + if !ok { + return errors.New("unknown value \"" + str + "\" for MyEnum") + } + return nil +} + +type SomeCalcArgs struct { + Rhs int64 `json:"rhs" yaml:"rhs" msgpack:"rhs"` + Lhs int64 `json:"lhs" yaml:"lhs" msgpack:"lhs"` +} + +// DefaultSomeCalcArgs returns a `SomeCalcArgs` struct populated with its default +// values. +func DefaultSomeCalcArgs() SomeCalcArgs { + return SomeCalcArgs{} +} + +func (o *SomeCalcArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "rhs": + o.Rhs, err = decoder.ReadInt64() + case "lhs": + o.Lhs, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *SomeCalcArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("rhs") + encoder.WriteInt64(o.Rhs) + encoder.WriteString("lhs") + encoder.WriteInt64(o.Lhs) + + return nil +} + +type MyStreamerRequestStreamArgsI64Args struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsI64Args returns a +// `MyStreamerRequestStreamArgsI64Args` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsI64Args() MyStreamerRequestStreamArgsI64Args { + return MyStreamerRequestStreamArgsI64Args{} +} + +func (o *MyStreamerRequestStreamArgsI64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsI64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsF64Args struct { + Value float64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsF64Args returns a +// `MyStreamerRequestStreamArgsF64Args` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsF64Args() MyStreamerRequestStreamArgsF64Args { + return MyStreamerRequestStreamArgsF64Args{} +} + +func (o *MyStreamerRequestStreamArgsF64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsF64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteFloat64(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsTypeArgs struct { + Value MyType `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsTypeArgs returns a +// `MyStreamerRequestStreamArgsTypeArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsTypeArgs() MyStreamerRequestStreamArgsTypeArgs { + return MyStreamerRequestStreamArgsTypeArgs{} +} + +func (o *MyStreamerRequestStreamArgsTypeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + err = o.Value.Decode(decoder) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsTypeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + o.Value.Encode(encoder) + + return nil +} + +type MyStreamerRequestStreamArgsEnumArgs struct { + Value MyEnum `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsEnumArgs returns a +// `MyStreamerRequestStreamArgsEnumArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsEnumArgs() MyStreamerRequestStreamArgsEnumArgs { + return MyStreamerRequestStreamArgsEnumArgs{} +} + +func (o *MyStreamerRequestStreamArgsEnumArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsEnumArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt32(int32(o.Value)) + + return nil +} + +type MyStreamerRequestStreamArgsUUIDArgs struct { + Value uuid.UUID `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsUUIDArgs returns a +// `MyStreamerRequestStreamArgsUUIDArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsUUIDArgs() MyStreamerRequestStreamArgsUUIDArgs { + return MyStreamerRequestStreamArgsUUIDArgs{} +} + +func (o *MyStreamerRequestStreamArgsUUIDArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsUUIDArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value.String()) + + return nil +} + +type MyStreamerRequestStreamArgsAliasArgs struct { + Value MyAlias `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsAliasArgs returns a +// `MyStreamerRequestStreamArgsAliasArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsAliasArgs() MyStreamerRequestStreamArgsAliasArgs { + return MyStreamerRequestStreamArgsAliasArgs{} +} + +func (o *MyStreamerRequestStreamArgsAliasArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.String[MyAlias](decoder.ReadString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsAliasArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(string(o.Value)) + + return nil +} + +type MyStreamerRequestStreamArgsStringArgs struct { + Value string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsStringArgs returns a +// `MyStreamerRequestStreamArgsStringArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestStreamArgsStringArgs() MyStreamerRequestStreamArgsStringArgs { + return MyStreamerRequestStreamArgsStringArgs{} +} + +func (o *MyStreamerRequestStreamArgsStringArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsStringArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsBoolArgs struct { + Value bool `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsBoolArgs returns a +// `MyStreamerRequestStreamArgsBoolArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsBoolArgs() MyStreamerRequestStreamArgsBoolArgs { + return MyStreamerRequestStreamArgsBoolArgs{} +} + +func (o *MyStreamerRequestStreamArgsBoolArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadBool() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsBoolArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteBool(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsDatetimeArgs struct { + Value time.Time `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsDatetimeArgs returns a +// `MyStreamerRequestStreamArgsDatetimeArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestStreamArgsDatetimeArgs() MyStreamerRequestStreamArgsDatetimeArgs { + return MyStreamerRequestStreamArgsDatetimeArgs{} +} + +func (o *MyStreamerRequestStreamArgsDatetimeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadTime() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsDatetimeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteTime(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsListArgs struct { + Value []string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsListArgs returns a +// `MyStreamerRequestStreamArgsListArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsListArgs() MyStreamerRequestStreamArgsListArgs { + return MyStreamerRequestStreamArgsListArgs{} +} + +func (o *MyStreamerRequestStreamArgsListArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsListArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteArraySize(uint32(len(o.Value))) + for _, v := range o.Value { + encoder.WriteString(v) + } + + return nil +} + +type MyStreamerRequestStreamArgsMapArgs struct { + Value map[string]string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsMapArgs returns a +// `MyStreamerRequestStreamArgsMapArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsMapArgs() MyStreamerRequestStreamArgsMapArgs { + return MyStreamerRequestStreamArgsMapArgs{} +} + +func (o *MyStreamerRequestStreamArgsMapArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsMapArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteMapSize(uint32(len(o.Value))) + if o.Value != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Value { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + + return nil +} + +type MyStreamerRequestChannelArgsSingleArgs struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsSingleArgs returns a +// `MyStreamerRequestChannelArgsSingleArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsSingleArgs() MyStreamerRequestChannelArgsSingleArgs { + return MyStreamerRequestChannelArgsSingleArgs{} +} + +func (o *MyStreamerRequestChannelArgsSingleArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsSingleArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsI64Args struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsI64Args returns a +// `MyStreamerRequestChannelArgsI64Args` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsI64Args() MyStreamerRequestChannelArgsI64Args { + return MyStreamerRequestChannelArgsI64Args{} +} + +func (o *MyStreamerRequestChannelArgsI64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsI64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsF64Args struct { + Value float64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsF64Args returns a +// `MyStreamerRequestChannelArgsF64Args` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsF64Args() MyStreamerRequestChannelArgsF64Args { + return MyStreamerRequestChannelArgsF64Args{} +} + +func (o *MyStreamerRequestChannelArgsF64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsF64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteFloat64(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsTypeArgs struct { + Value MyType `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsTypeArgs returns a +// `MyStreamerRequestChannelArgsTypeArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsTypeArgs() MyStreamerRequestChannelArgsTypeArgs { + return MyStreamerRequestChannelArgsTypeArgs{} +} + +func (o *MyStreamerRequestChannelArgsTypeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + err = o.Value.Decode(decoder) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsTypeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + o.Value.Encode(encoder) + + return nil +} + +type MyStreamerRequestChannelArgsEnumArgs struct { + Value MyEnum `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsEnumArgs returns a +// `MyStreamerRequestChannelArgsEnumArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsEnumArgs() MyStreamerRequestChannelArgsEnumArgs { + return MyStreamerRequestChannelArgsEnumArgs{} +} + +func (o *MyStreamerRequestChannelArgsEnumArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsEnumArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt32(int32(o.Value)) + + return nil +} + +type MyStreamerRequestChannelArgsAliasArgs struct { + Value uuid.UUID `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsAliasArgs returns a +// `MyStreamerRequestChannelArgsAliasArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsAliasArgs() MyStreamerRequestChannelArgsAliasArgs { + return MyStreamerRequestChannelArgsAliasArgs{} +} + +func (o *MyStreamerRequestChannelArgsAliasArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsAliasArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value.String()) + + return nil +} + +type MyStreamerRequestChannelArgsStringArgs struct { + Value string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsStringArgs returns a +// `MyStreamerRequestChannelArgsStringArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsStringArgs() MyStreamerRequestChannelArgsStringArgs { + return MyStreamerRequestChannelArgsStringArgs{} +} + +func (o *MyStreamerRequestChannelArgsStringArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsStringArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsBoolArgs struct { + Value bool `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsBoolArgs returns a +// `MyStreamerRequestChannelArgsBoolArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsBoolArgs() MyStreamerRequestChannelArgsBoolArgs { + return MyStreamerRequestChannelArgsBoolArgs{} +} + +func (o *MyStreamerRequestChannelArgsBoolArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadBool() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsBoolArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteBool(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsDatetimeArgs struct { + Value time.Time `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsDatetimeArgs returns a +// `MyStreamerRequestChannelArgsDatetimeArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsDatetimeArgs() MyStreamerRequestChannelArgsDatetimeArgs { + return MyStreamerRequestChannelArgsDatetimeArgs{} +} + +func (o *MyStreamerRequestChannelArgsDatetimeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadTime() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsDatetimeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteTime(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsListArgs struct { + Value []string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsListArgs returns a +// `MyStreamerRequestChannelArgsListArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsListArgs() MyStreamerRequestChannelArgsListArgs { + return MyStreamerRequestChannelArgsListArgs{} +} + +func (o *MyStreamerRequestChannelArgsListArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsListArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteArraySize(uint32(len(o.Value))) + for _, v := range o.Value { + encoder.WriteString(v) + } + + return nil +} + +type MyStreamerRequestChannelArgsMapArgs struct { + Value map[string]string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsMapArgs returns a +// `MyStreamerRequestChannelArgsMapArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsMapArgs() MyStreamerRequestChannelArgsMapArgs { + return MyStreamerRequestChannelArgsMapArgs{} +} + +func (o *MyStreamerRequestChannelArgsMapArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsMapArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteMapSize(uint32(len(o.Value))) + if o.Value != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Value { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + + return nil +} + +type MyServiceFuncTypeArgs struct { + Value MyType `json:"value" yaml:"value" msgpack:"value"` + Optional *MyType `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncTypeArgs returns a `MyServiceFuncTypeArgs` struct populated +// with its default values. +func DefaultMyServiceFuncTypeArgs() MyServiceFuncTypeArgs { + return MyServiceFuncTypeArgs{} +} + +func (o *MyServiceFuncTypeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + err = o.Value.Decode(decoder) + case "optional": + o.Optional, err = msgpack.DecodeNillable[MyType](decoder) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncTypeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + o.Value.Encode(encoder) + encoder.WriteString("optional") + o.Optional.Encode(encoder) + + return nil +} + +type MyServiceFuncEnumArgs struct { + Value MyEnum `json:"value" yaml:"value" msgpack:"value"` + Optional *MyEnum `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncEnumArgs returns a `MyServiceFuncEnumArgs` struct populated +// with its default values. +func DefaultMyServiceFuncEnumArgs() MyServiceFuncEnumArgs { + return MyServiceFuncEnumArgs{} +} + +func (o *MyServiceFuncEnumArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + case "optional": + o.Optional, err = convert.NillableNumeric[MyEnum](decoder.ReadNillableInt32()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncEnumArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt32(int32(o.Value)) + encoder.WriteString("optional") + encoder.WriteNillableInt32((*int32)(o.Optional)) + + return nil +} + +type MyServiceFuncUUIDArgs struct { + Value uuid.UUID `json:"value" yaml:"value" msgpack:"value"` + Optional *uuid.UUID `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncUUIDArgs returns a `MyServiceFuncUUIDArgs` struct populated +// with its default values. +func DefaultMyServiceFuncUUIDArgs() MyServiceFuncUUIDArgs { + return MyServiceFuncUUIDArgs{} +} + +func (o *MyServiceFuncUUIDArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + case "optional": + o.Optional, err = convert.NillableParse(uuid.Parse)(decoder.ReadNillableString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncUUIDArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteString(o.Value.String()) + encoder.WriteString("optional") + if o.Optional == nil { + encoder.WriteNil() + } else { + encoder.WriteString(o.Optional.String()) + } + + return nil +} + +type MyServiceFuncAliasArgs struct { + Value MyAlias `json:"value" yaml:"value" msgpack:"value"` + Optional *MyAlias `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncAliasArgs returns a `MyServiceFuncAliasArgs` struct +// populated with its default values. +func DefaultMyServiceFuncAliasArgs() MyServiceFuncAliasArgs { + return MyServiceFuncAliasArgs{} +} + +func (o *MyServiceFuncAliasArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.String[MyAlias](decoder.ReadString()) + case "optional": + o.Optional, err = convert.NillableString[MyAlias](decoder.ReadNillableString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncAliasArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteString(string(o.Value)) + encoder.WriteString("optional") + encoder.WriteNillableString((*string)(o.Optional)) + + return nil +} + +type MyServiceFuncStringArgs struct { + Value string `json:"value" yaml:"value" msgpack:"value"` + Optional *string `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncStringArgs returns a `MyServiceFuncStringArgs` struct +// populated with its default values. +func DefaultMyServiceFuncStringArgs() MyServiceFuncStringArgs { + return MyServiceFuncStringArgs{} +} + +func (o *MyServiceFuncStringArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadString() + case "optional": + o.Optional, err = decoder.ReadNillableString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncStringArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteString(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableString(o.Optional) + + return nil +} + +type MyServiceFuncI64Args struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` + Optional *int64 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI64Args returns a `MyServiceFuncI64Args` struct populated +// with its default values. +func DefaultMyServiceFuncI64Args() MyServiceFuncI64Args { + return MyServiceFuncI64Args{} +} + +func (o *MyServiceFuncI64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + case "optional": + o.Optional, err = decoder.ReadNillableInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt64(o.Optional) + + return nil +} + +type MyServiceFuncI32Args struct { + Value int32 `json:"value" yaml:"value" msgpack:"value"` + Optional *int32 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI32Args returns a `MyServiceFuncI32Args` struct populated +// with its default values. +func DefaultMyServiceFuncI32Args() MyServiceFuncI32Args { + return MyServiceFuncI32Args{} +} + +func (o *MyServiceFuncI32Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt32() + case "optional": + o.Optional, err = decoder.ReadNillableInt32() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI32Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt32(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt32(o.Optional) + + return nil +} + +type MyServiceFuncI16Args struct { + Value int16 `json:"value" yaml:"value" msgpack:"value"` + Optional *int16 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI16Args returns a `MyServiceFuncI16Args` struct populated +// with its default values. +func DefaultMyServiceFuncI16Args() MyServiceFuncI16Args { + return MyServiceFuncI16Args{} +} + +func (o *MyServiceFuncI16Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt16() + case "optional": + o.Optional, err = decoder.ReadNillableInt16() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI16Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt16(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt16(o.Optional) + + return nil +} + +type MyServiceFuncI8Args struct { + Value int8 `json:"value" yaml:"value" msgpack:"value"` + Optional *int8 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI8Args returns a `MyServiceFuncI8Args` struct populated with +// its default values. +func DefaultMyServiceFuncI8Args() MyServiceFuncI8Args { + return MyServiceFuncI8Args{} +} + +func (o *MyServiceFuncI8Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt8() + case "optional": + o.Optional, err = decoder.ReadNillableInt8() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI8Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt8(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt8(o.Optional) + + return nil +} + +type MyServiceFuncU64Args struct { + Value uint64 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint64 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU64Args returns a `MyServiceFuncU64Args` struct populated +// with its default values. +func DefaultMyServiceFuncU64Args() MyServiceFuncU64Args { + return MyServiceFuncU64Args{} +} + +func (o *MyServiceFuncU64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint64() + case "optional": + o.Optional, err = decoder.ReadNillableUint64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint64(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint64(o.Optional) + + return nil +} + +type MyServiceFuncU32Args struct { + Value uint32 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint32 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU32Args returns a `MyServiceFuncU32Args` struct populated +// with its default values. +func DefaultMyServiceFuncU32Args() MyServiceFuncU32Args { + return MyServiceFuncU32Args{} +} + +func (o *MyServiceFuncU32Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint32() + case "optional": + o.Optional, err = decoder.ReadNillableUint32() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU32Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint32(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint32(o.Optional) + + return nil +} + +type MyServiceFuncU16Args struct { + Value uint16 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint16 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU16Args returns a `MyServiceFuncU16Args` struct populated +// with its default values. +func DefaultMyServiceFuncU16Args() MyServiceFuncU16Args { + return MyServiceFuncU16Args{} +} + +func (o *MyServiceFuncU16Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint16() + case "optional": + o.Optional, err = decoder.ReadNillableUint16() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU16Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint16(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint16(o.Optional) + + return nil +} + +type MyServiceFuncU8Args struct { + Value uint8 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint8 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU8Args returns a `MyServiceFuncU8Args` struct populated with +// its default values. +func DefaultMyServiceFuncU8Args() MyServiceFuncU8Args { + return MyServiceFuncU8Args{} +} + +func (o *MyServiceFuncU8Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint8() + case "optional": + o.Optional, err = decoder.ReadNillableUint8() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU8Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint8(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint8(o.Optional) + + return nil +} + +type MyServiceFuncF64Args struct { + Value float64 `json:"value" yaml:"value" msgpack:"value"` + Optional *float64 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncF64Args returns a `MyServiceFuncF64Args` struct populated +// with its default values. +func DefaultMyServiceFuncF64Args() MyServiceFuncF64Args { + return MyServiceFuncF64Args{} +} + +func (o *MyServiceFuncF64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat64() + case "optional": + o.Optional, err = decoder.ReadNillableFloat64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncF64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteFloat64(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableFloat64(o.Optional) + + return nil +} + +type MyServiceFuncF32Args struct { + Value float32 `json:"value" yaml:"value" msgpack:"value"` + Optional *float32 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncF32Args returns a `MyServiceFuncF32Args` struct populated +// with its default values. +func DefaultMyServiceFuncF32Args() MyServiceFuncF32Args { + return MyServiceFuncF32Args{} +} + +func (o *MyServiceFuncF32Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat32() + case "optional": + o.Optional, err = decoder.ReadNillableFloat32() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncF32Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteFloat32(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableFloat32(o.Optional) + + return nil +} + +type MyServiceFuncBytesArgs struct { + Value []byte `json:"value" yaml:"value" msgpack:"value"` + Optional []byte `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncBytesArgs returns a `MyServiceFuncBytesArgs` struct +// populated with its default values. +func DefaultMyServiceFuncBytesArgs() MyServiceFuncBytesArgs { + return MyServiceFuncBytesArgs{} +} + +func (o *MyServiceFuncBytesArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadByteArray() + case "optional": + o.Optional, err = decoder.ReadNillableByteArray() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncBytesArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteByteArray(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableByteArray(o.Optional) + + return nil +} + +type MyServiceFuncDatetimeArgs struct { + Value time.Time `json:"value" yaml:"value" msgpack:"value"` + Optional *time.Time `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncDatetimeArgs returns a `MyServiceFuncDatetimeArgs` struct +// populated with its default values. +func DefaultMyServiceFuncDatetimeArgs() MyServiceFuncDatetimeArgs { + return MyServiceFuncDatetimeArgs{} +} + +func (o *MyServiceFuncDatetimeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadTime() + case "optional": + o.Optional, err = decoder.ReadNillableTime() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncDatetimeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteTime(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableTime(o.Optional) + + return nil +} + +type MyServiceFuncListArgs struct { + Value []string `json:"value" yaml:"value" msgpack:"value"` + Optional []string `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncListArgs returns a `MyServiceFuncListArgs` struct populated +// with its default values. +func DefaultMyServiceFuncListArgs() MyServiceFuncListArgs { + return MyServiceFuncListArgs{} +} + +func (o *MyServiceFuncListArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + case "optional": + o.Optional, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncListArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteArraySize(uint32(len(o.Value))) + for _, v := range o.Value { + encoder.WriteString(v) + } + encoder.WriteString("optional") + encoder.WriteArraySize(uint32(len(o.Optional))) + for _, v := range o.Optional { + encoder.WriteString(v) + } + + return nil +} + +type MyServiceFuncMapArgs struct { + Value map[string]string `json:"value" yaml:"value" msgpack:"value"` + Optional map[string]string `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncMapArgs returns a `MyServiceFuncMapArgs` struct populated +// with its default values. +func DefaultMyServiceFuncMapArgs() MyServiceFuncMapArgs { + return MyServiceFuncMapArgs{} +} + +func (o *MyServiceFuncMapArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + case "optional": + o.Optional, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncMapArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteMapSize(uint32(len(o.Value))) + if o.Value != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Value { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + encoder.WriteString("optional") + encoder.WriteMapSize(uint32(len(o.Optional))) + if o.Optional != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Optional { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + + return nil +} + +func (o *MyType) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "sameValue": + o.SameValue, err = msgpack.DecodeNillable[MyType](decoder) + case "typeValue": + err = o.TypeValue.Decode(decoder) + case "stringValue": + o.StringValue, err = decoder.ReadString() + case "stringOption": + o.StringOption, err = decoder.ReadNillableString() + case "i64Value": + o.I64Value, err = decoder.ReadInt64() + case "i64Option": + o.I64Option, err = decoder.ReadNillableInt64() + case "i32Value": + o.I32Value, err = decoder.ReadInt32() + case "i32Option": + o.I32Option, err = decoder.ReadNillableInt32() + case "i16Value": + o.I16Value, err = decoder.ReadInt16() + case "i16Option": + o.I16Option, err = decoder.ReadNillableInt16() + case "i8Value": + o.I8Value, err = decoder.ReadInt8() + case "i8Option": + o.I8Option, err = decoder.ReadNillableInt8() + case "u64Value": + o.U64Value, err = decoder.ReadUint64() + case "u64Option": + o.U64Option, err = decoder.ReadNillableUint64() + case "u32Value": + o.U32Value, err = decoder.ReadUint32() + case "u32Option": + o.U32Option, err = decoder.ReadNillableUint32() + case "u16Value": + o.U16Value, err = decoder.ReadUint16() + case "u16Option": + o.U16Option, err = decoder.ReadNillableUint16() + case "u8Value": + o.U8Value, err = decoder.ReadUint8() + case "u8Option": + o.U8Option, err = decoder.ReadNillableUint8() + case "f64Value": + o.F64Value, err = decoder.ReadFloat64() + case "f64Option": + o.F64Option, err = decoder.ReadNillableFloat64() + case "f32Value": + o.F32Value, err = decoder.ReadFloat32() + case "f32Option": + o.F32Option, err = decoder.ReadNillableFloat32() + case "datetimeValue": + o.DatetimeValue, err = decoder.ReadTime() + case "datetimeOption": + o.DatetimeOption, err = decoder.ReadNillableTime() + case "bytesValue": + o.BytesValue, err = decoder.ReadByteArray() + case "bytesOption": + o.BytesOption, err = decoder.ReadNillableByteArray() + case "mapValue": + o.MapValue, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (int64, error) { + return decoder.ReadInt64() + }) + case "mapOfTypes": + o.MapOfTypes, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (MyType, error) { + return msgpack.Decode[MyType](decoder) + }) + case "arrayValue": + o.ArrayValue, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + case "arrayOfTypes": + o.ArrayOfTypes, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (MyType, error) { + return msgpack.Decode[MyType](decoder) + }) + case "unionValue": + o.UnionValue, err = msgpack.Decode[MyUnion](decoder) + case "unionOption": + o.UnionOption, err = msgpack.DecodeNillable[MyUnion](decoder) + case "enumValue": + o.EnumValue, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + case "enumOption": + o.EnumOption, err = convert.NillableNumeric[MyEnum](decoder.ReadNillableInt32()) + case "aliasValue": + o.AliasValue, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + case "aliasOption": + o.AliasOption, err = convert.NillableParse(uuid.Parse)(decoder.ReadNillableString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyType) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(38) + encoder.WriteString("sameValue") + o.SameValue.Encode(encoder) + encoder.WriteString("typeValue") + o.TypeValue.Encode(encoder) + encoder.WriteString("stringValue") + encoder.WriteString(o.StringValue) + encoder.WriteString("stringOption") + encoder.WriteNillableString(o.StringOption) + encoder.WriteString("i64Value") + encoder.WriteInt64(o.I64Value) + encoder.WriteString("i64Option") + encoder.WriteNillableInt64(o.I64Option) + encoder.WriteString("i32Value") + encoder.WriteInt32(o.I32Value) + encoder.WriteString("i32Option") + encoder.WriteNillableInt32(o.I32Option) + encoder.WriteString("i16Value") + encoder.WriteInt16(o.I16Value) + encoder.WriteString("i16Option") + encoder.WriteNillableInt16(o.I16Option) + encoder.WriteString("i8Value") + encoder.WriteInt8(o.I8Value) + encoder.WriteString("i8Option") + encoder.WriteNillableInt8(o.I8Option) + encoder.WriteString("u64Value") + encoder.WriteUint64(o.U64Value) + encoder.WriteString("u64Option") + encoder.WriteNillableUint64(o.U64Option) + encoder.WriteString("u32Value") + encoder.WriteUint32(o.U32Value) + encoder.WriteString("u32Option") + encoder.WriteNillableUint32(o.U32Option) + encoder.WriteString("u16Value") + encoder.WriteUint16(o.U16Value) + encoder.WriteString("u16Option") + encoder.WriteNillableUint16(o.U16Option) + encoder.WriteString("u8Value") + encoder.WriteUint8(o.U8Value) + encoder.WriteString("u8Option") + encoder.WriteNillableUint8(o.U8Option) + encoder.WriteString("f64Value") + encoder.WriteFloat64(o.F64Value) + encoder.WriteString("f64Option") + encoder.WriteNillableFloat64(o.F64Option) + encoder.WriteString("f32Value") + encoder.WriteFloat32(o.F32Value) + encoder.WriteString("f32Option") + encoder.WriteNillableFloat32(o.F32Option) + encoder.WriteString("datetimeValue") + encoder.WriteTime(o.DatetimeValue) + encoder.WriteString("datetimeOption") + encoder.WriteNillableTime(o.DatetimeOption) + encoder.WriteString("bytesValue") + encoder.WriteByteArray(o.BytesValue) + encoder.WriteString("bytesOption") + encoder.WriteNillableByteArray(o.BytesOption) + encoder.WriteString("mapValue") + encoder.WriteMapSize(uint32(len(o.MapValue))) + if o.MapValue != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.MapValue { + encoder.WriteString(k) + encoder.WriteInt64(v) + } + } + encoder.WriteString("mapOfTypes") + encoder.WriteMapSize(uint32(len(o.MapOfTypes))) + if o.MapOfTypes != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.MapOfTypes { + encoder.WriteString(k) + v.Encode(encoder) + } + } + encoder.WriteString("arrayValue") + encoder.WriteArraySize(uint32(len(o.ArrayValue))) + for _, v := range o.ArrayValue { + encoder.WriteString(v) + } + encoder.WriteString("arrayOfTypes") + encoder.WriteArraySize(uint32(len(o.ArrayOfTypes))) + for _, v := range o.ArrayOfTypes { + v.Encode(encoder) + } + encoder.WriteString("unionValue") + o.UnionValue.Encode(encoder) + encoder.WriteString("unionOption") + if o.UnionOption == nil { + encoder.WriteNil() + } else { + o.UnionOption.Encode(encoder) + } + encoder.WriteString("enumValue") + encoder.WriteInt32(int32(o.EnumValue)) + encoder.WriteString("enumOption") + encoder.WriteNillableInt32((*int32)(o.EnumOption)) + encoder.WriteString("aliasValue") + encoder.WriteString(o.AliasValue.String()) + encoder.WriteString("aliasOption") + if o.AliasOption == nil { + encoder.WriteNil() + } else { + encoder.WriteString(o.AliasOption.String()) + } + + return nil +} + +func (o *MyOtherType) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "foo": + o.Foo, err = decoder.ReadString() + case "bar": + o.Bar, err = decoder.ReadString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyOtherType) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("foo") + encoder.WriteString(o.Foo) + encoder.WriteString("bar") + encoder.WriteString(o.Bar) + + return nil +} + +func (o *MyUnion) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "MyType": + o.MyType, err = msgpack.DecodeNillable[MyType](decoder) + case "MyEnum": + o.MyEnum, err = convert.NillableNumeric[MyEnum](decoder.ReadNillableInt32()) + case "string": + o.String, err = decoder.ReadNillableString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyUnion) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + if o.MyType != nil { + encoder.WriteMapSize(1) + encoder.WriteString("MyType") + o.MyType.Encode(encoder) + return nil + } + if o.MyEnum != nil { + encoder.WriteMapSize(1) + encoder.WriteString("MyEnum") + encoder.WriteNillableInt32((*int32)(o.MyEnum)) + return nil + } + if o.String != nil { + encoder.WriteMapSize(1) + encoder.WriteString("string") + encoder.WriteNillableString(o.String) + return nil + } + + encoder.WriteNil() + return nil +} + +type Dependencies struct { + SomeCalc SomeCalcFn + MyStreamer MyStreamer + MyService MyService +} + +type Client struct { + caller invoke.Caller + _opSomeCalc uint32 + _opMyStreamerRequestStreamI64 uint32 + _opMyStreamerRequestStreamF64 uint32 + _opMyStreamerRequestStreamType uint32 + _opMyStreamerRequestStreamEnum uint32 + _opMyStreamerRequestStreamUUID uint32 + _opMyStreamerRequestStreamAlias uint32 + _opMyStreamerRequestStreamString uint32 + _opMyStreamerRequestStreamBool uint32 + _opMyStreamerRequestStreamDatetime uint32 + _opMyStreamerRequestStreamList uint32 + _opMyStreamerRequestStreamMap uint32 + _opMyStreamerRequestStreamArgsI64 uint32 + _opMyStreamerRequestStreamArgsF64 uint32 + _opMyStreamerRequestStreamArgsType uint32 + _opMyStreamerRequestStreamArgsEnum uint32 + _opMyStreamerRequestStreamArgsUUID uint32 + _opMyStreamerRequestStreamArgsAlias uint32 + _opMyStreamerRequestStreamArgsString uint32 + _opMyStreamerRequestStreamArgsBool uint32 + _opMyStreamerRequestStreamArgsDatetime uint32 + _opMyStreamerRequestStreamArgsList uint32 + _opMyStreamerRequestStreamArgsMap uint32 + _opMyStreamerRequestChannelVoid uint32 + _opMyStreamerRequestChannelSingle uint32 + _opMyStreamerRequestChannelI64 uint32 + _opMyStreamerRequestChannelF64 uint32 + _opMyStreamerRequestChannelType uint32 + _opMyStreamerRequestChannelEnum uint32 + _opMyStreamerRequestChannelAlias uint32 + _opMyStreamerRequestChannelString uint32 + _opMyStreamerRequestChannelBool uint32 + _opMyStreamerRequestChannelDatetime uint32 + _opMyStreamerRequestChannelList uint32 + _opMyStreamerRequestChannelMap uint32 + _opMyStreamerRequestChannelArgsSingle uint32 + _opMyStreamerRequestChannelArgsI64 uint32 + _opMyStreamerRequestChannelArgsF64 uint32 + _opMyStreamerRequestChannelArgsType uint32 + _opMyStreamerRequestChannelArgsEnum uint32 + _opMyStreamerRequestChannelArgsAlias uint32 + _opMyStreamerRequestChannelArgsString uint32 + _opMyStreamerRequestChannelArgsBool uint32 + _opMyStreamerRequestChannelArgsDatetime uint32 + _opMyStreamerRequestChannelArgsList uint32 + _opMyStreamerRequestChannelArgsMap uint32 + _opMyServiceEmptyVoid uint32 + _opMyServiceUnaryType uint32 + _opMyServiceUnaryEnum uint32 + _opMyServiceUnaryUUID uint32 + _opMyServiceUnaryAlias uint32 + _opMyServiceUnaryString uint32 + _opMyServiceUnaryI64 uint32 + _opMyServiceUnaryI32 uint32 + _opMyServiceUnaryI16 uint32 + _opMyServiceUnaryI8 uint32 + _opMyServiceUnaryU64 uint32 + _opMyServiceUnaryU32 uint32 + _opMyServiceUnaryU16 uint32 + _opMyServiceUnaryU8 uint32 + _opMyServiceUnaryF64 uint32 + _opMyServiceUnaryF32 uint32 + _opMyServiceUnaryBytes uint32 + _opMyServiceUnaryDatetime uint32 + _opMyServiceUnaryList uint32 + _opMyServiceUnaryMap uint32 + _opMyServiceFuncType uint32 + _opMyServiceFuncEnum uint32 + _opMyServiceFuncUUID uint32 + _opMyServiceFuncAlias uint32 + _opMyServiceFuncString uint32 + _opMyServiceFuncI64 uint32 + _opMyServiceFuncI32 uint32 + _opMyServiceFuncI16 uint32 + _opMyServiceFuncI8 uint32 + _opMyServiceFuncU64 uint32 + _opMyServiceFuncU32 uint32 + _opMyServiceFuncU16 uint32 + _opMyServiceFuncU8 uint32 + _opMyServiceFuncF64 uint32 + _opMyServiceFuncF32 uint32 + _opMyServiceFuncBytes uint32 + _opMyServiceFuncDatetime uint32 + _opMyServiceFuncList uint32 + _opMyServiceFuncMap uint32 +} + +func New(caller invoke.Caller) *Client { + return &Client{ + caller: caller, + _opSomeCalc: invoke.ImportRequestResponse("iota.testing", "someCalc"), + _opMyStreamerRequestStreamI64: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamI64"), + _opMyStreamerRequestStreamF64: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamF64"), + _opMyStreamerRequestStreamType: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamType"), + _opMyStreamerRequestStreamEnum: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamEnum"), + _opMyStreamerRequestStreamUUID: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamUUID"), + _opMyStreamerRequestStreamAlias: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamAlias"), + _opMyStreamerRequestStreamString: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamString"), + _opMyStreamerRequestStreamBool: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamBool"), + _opMyStreamerRequestStreamDatetime: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamDatetime"), + _opMyStreamerRequestStreamList: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamList"), + _opMyStreamerRequestStreamMap: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamMap"), + _opMyStreamerRequestStreamArgsI64: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsI64"), + _opMyStreamerRequestStreamArgsF64: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsF64"), + _opMyStreamerRequestStreamArgsType: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsType"), + _opMyStreamerRequestStreamArgsEnum: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsEnum"), + _opMyStreamerRequestStreamArgsUUID: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsUUID"), + _opMyStreamerRequestStreamArgsAlias: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsAlias"), + _opMyStreamerRequestStreamArgsString: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsString"), + _opMyStreamerRequestStreamArgsBool: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsBool"), + _opMyStreamerRequestStreamArgsDatetime: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsDatetime"), + _opMyStreamerRequestStreamArgsList: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsList"), + _opMyStreamerRequestStreamArgsMap: invoke.ImportRequestStream("iota.testing.MyStreamer", "requestStreamArgsMap"), + _opMyStreamerRequestChannelVoid: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelVoid"), + _opMyStreamerRequestChannelSingle: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelSingle"), + _opMyStreamerRequestChannelI64: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelI64"), + _opMyStreamerRequestChannelF64: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelF64"), + _opMyStreamerRequestChannelType: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelType"), + _opMyStreamerRequestChannelEnum: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelEnum"), + _opMyStreamerRequestChannelAlias: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelAlias"), + _opMyStreamerRequestChannelString: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelString"), + _opMyStreamerRequestChannelBool: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelBool"), + _opMyStreamerRequestChannelDatetime: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelDatetime"), + _opMyStreamerRequestChannelList: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelList"), + _opMyStreamerRequestChannelMap: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelMap"), + _opMyStreamerRequestChannelArgsSingle: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsSingle"), + _opMyStreamerRequestChannelArgsI64: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsI64"), + _opMyStreamerRequestChannelArgsF64: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsF64"), + _opMyStreamerRequestChannelArgsType: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsType"), + _opMyStreamerRequestChannelArgsEnum: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsEnum"), + _opMyStreamerRequestChannelArgsAlias: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsAlias"), + _opMyStreamerRequestChannelArgsString: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsString"), + _opMyStreamerRequestChannelArgsBool: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsBool"), + _opMyStreamerRequestChannelArgsDatetime: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsDatetime"), + _opMyStreamerRequestChannelArgsList: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsList"), + _opMyStreamerRequestChannelArgsMap: invoke.ImportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsMap"), + _opMyServiceEmptyVoid: invoke.ImportRequestResponse("iota.testing.MyService", "emptyVoid"), + _opMyServiceUnaryType: invoke.ImportRequestResponse("iota.testing.MyService", "unaryType"), + _opMyServiceUnaryEnum: invoke.ImportRequestResponse("iota.testing.MyService", "unaryEnum"), + _opMyServiceUnaryUUID: invoke.ImportRequestResponse("iota.testing.MyService", "unaryUUID"), + _opMyServiceUnaryAlias: invoke.ImportRequestResponse("iota.testing.MyService", "unaryAlias"), + _opMyServiceUnaryString: invoke.ImportRequestResponse("iota.testing.MyService", "unaryString"), + _opMyServiceUnaryI64: invoke.ImportRequestResponse("iota.testing.MyService", "unaryI64"), + _opMyServiceUnaryI32: invoke.ImportRequestResponse("iota.testing.MyService", "unaryI32"), + _opMyServiceUnaryI16: invoke.ImportRequestResponse("iota.testing.MyService", "unaryI16"), + _opMyServiceUnaryI8: invoke.ImportRequestResponse("iota.testing.MyService", "unaryI8"), + _opMyServiceUnaryU64: invoke.ImportRequestResponse("iota.testing.MyService", "unaryU64"), + _opMyServiceUnaryU32: invoke.ImportRequestResponse("iota.testing.MyService", "unaryU32"), + _opMyServiceUnaryU16: invoke.ImportRequestResponse("iota.testing.MyService", "unaryU16"), + _opMyServiceUnaryU8: invoke.ImportRequestResponse("iota.testing.MyService", "unaryU8"), + _opMyServiceUnaryF64: invoke.ImportRequestResponse("iota.testing.MyService", "unaryF64"), + _opMyServiceUnaryF32: invoke.ImportRequestResponse("iota.testing.MyService", "unaryF32"), + _opMyServiceUnaryBytes: invoke.ImportRequestResponse("iota.testing.MyService", "unaryBytes"), + _opMyServiceUnaryDatetime: invoke.ImportRequestResponse("iota.testing.MyService", "unaryDatetime"), + _opMyServiceUnaryList: invoke.ImportRequestResponse("iota.testing.MyService", "unaryList"), + _opMyServiceUnaryMap: invoke.ImportRequestResponse("iota.testing.MyService", "unaryMap"), + _opMyServiceFuncType: invoke.ImportRequestResponse("iota.testing.MyService", "funcType"), + _opMyServiceFuncEnum: invoke.ImportRequestResponse("iota.testing.MyService", "funcEnum"), + _opMyServiceFuncUUID: invoke.ImportRequestResponse("iota.testing.MyService", "funcUUID"), + _opMyServiceFuncAlias: invoke.ImportRequestResponse("iota.testing.MyService", "funcAlias"), + _opMyServiceFuncString: invoke.ImportRequestResponse("iota.testing.MyService", "funcString"), + _opMyServiceFuncI64: invoke.ImportRequestResponse("iota.testing.MyService", "funcI64"), + _opMyServiceFuncI32: invoke.ImportRequestResponse("iota.testing.MyService", "funcI32"), + _opMyServiceFuncI16: invoke.ImportRequestResponse("iota.testing.MyService", "funcI16"), + _opMyServiceFuncI8: invoke.ImportRequestResponse("iota.testing.MyService", "funcI8"), + _opMyServiceFuncU64: invoke.ImportRequestResponse("iota.testing.MyService", "funcU64"), + _opMyServiceFuncU32: invoke.ImportRequestResponse("iota.testing.MyService", "funcU32"), + _opMyServiceFuncU16: invoke.ImportRequestResponse("iota.testing.MyService", "funcU16"), + _opMyServiceFuncU8: invoke.ImportRequestResponse("iota.testing.MyService", "funcU8"), + _opMyServiceFuncF64: invoke.ImportRequestResponse("iota.testing.MyService", "funcF64"), + _opMyServiceFuncF32: invoke.ImportRequestResponse("iota.testing.MyService", "funcF32"), + _opMyServiceFuncBytes: invoke.ImportRequestResponse("iota.testing.MyService", "funcBytes"), + _opMyServiceFuncDatetime: invoke.ImportRequestResponse("iota.testing.MyService", "funcDatetime"), + _opMyServiceFuncList: invoke.ImportRequestResponse("iota.testing.MyService", "funcList"), + _opMyServiceFuncMap: invoke.ImportRequestResponse("iota.testing.MyService", "funcMap"), + } +} +func (c *Client) Dependencies() Dependencies { + return Dependencies{ + SomeCalc: c.SomeCalc, + MyStreamer: c.MyStreamer(), + MyService: c.MyService(), + } +} + +func GetDependencies(caller invoke.Caller) Dependencies { + c := New(caller) + return c.Dependencies() +} + +func (c *Client) SomeCalc(ctx context.Context, rhs int64, lhs int64) mono.Mono[int64] { + request := SomeCalcArgs{ + Rhs: rhs, + Lhs: lhs, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[int64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], c._opSomeCalc) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int64.Decode) +} + +type MyStreamerClient struct { + c *Client + instanceID uint64 +} + +func (c *Client) MyStreamer() MyStreamer { + return &MyStreamerClient{ + c: c, + } +} + +func (m *MyStreamerClient) RequestStreamI64(ctx context.Context) flux.Flux[int64] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamI64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Int64.Decode) +} + +func (m *MyStreamerClient) RequestStreamF64(ctx context.Context) flux.Flux[float64] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamF64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Float64.Decode) +} + +func (m *MyStreamerClient) RequestStreamType(ctx context.Context) flux.Flux[MyType] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamType) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.MsgPackDecode[MyType]) +} + +func (m *MyStreamerClient) RequestStreamEnum(ctx context.Context) flux.Flux[MyEnum] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamEnum) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Int32Decode[MyEnum]) +} + +func (m *MyStreamerClient) RequestStreamUUID(ctx context.Context) flux.Flux[uuid.UUID] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamUUID) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + })) +} + +func (m *MyStreamerClient) RequestStreamAlias(ctx context.Context) flux.Flux[MyAlias] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamAlias) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.StringDecode[MyAlias]) +} + +func (m *MyStreamerClient) RequestStreamString(ctx context.Context) flux.Flux[string] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamString) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.String.Decode) +} + +func (m *MyStreamerClient) RequestStreamBool(ctx context.Context) flux.Flux[bool] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamBool) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Bool.Decode) +} + +func (m *MyStreamerClient) RequestStreamDatetime(ctx context.Context) flux.Flux[time.Time] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamDatetime) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Time.Decode) +} + +func (m *MyStreamerClient) RequestStreamList(ctx context.Context) flux.Flux[[]string] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamList) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyStreamerClient) RequestStreamMap(ctx context.Context) flux.Flux[map[string]string] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamMap) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyStreamerClient) RequestStreamArgsI64(ctx context.Context, value int64) flux.Flux[int64] { + request := MyStreamerRequestStreamArgsI64Args{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[int64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsI64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Int64.Decode) +} + +func (m *MyStreamerClient) RequestStreamArgsF64(ctx context.Context, value float64) flux.Flux[float64] { + request := MyStreamerRequestStreamArgsF64Args{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[float64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsF64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Float64.Decode) +} + +func (m *MyStreamerClient) RequestStreamArgsType(ctx context.Context, value *MyType) flux.Flux[MyType] { + request := MyStreamerRequestStreamArgsTypeArgs{ + Value: *value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[MyType](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsType) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.MsgPackDecode[MyType]) +} + +func (m *MyStreamerClient) RequestStreamArgsEnum(ctx context.Context, value MyEnum) flux.Flux[MyEnum] { + request := MyStreamerRequestStreamArgsEnumArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[MyEnum](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsEnum) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Int32Decode[MyEnum]) +} + +func (m *MyStreamerClient) RequestStreamArgsUUID(ctx context.Context, value uuid.UUID) flux.Flux[uuid.UUID] { + request := MyStreamerRequestStreamArgsUUIDArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[uuid.UUID](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsUUID) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + })) +} + +func (m *MyStreamerClient) RequestStreamArgsAlias(ctx context.Context, value MyAlias) flux.Flux[MyAlias] { + request := MyStreamerRequestStreamArgsAliasArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[MyAlias](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsAlias) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.StringDecode[MyAlias]) +} + +func (m *MyStreamerClient) RequestStreamArgsString(ctx context.Context, value string) flux.Flux[string] { + request := MyStreamerRequestStreamArgsStringArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsString) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.String.Decode) +} + +func (m *MyStreamerClient) RequestStreamArgsBool(ctx context.Context, value bool) flux.Flux[bool] { + request := MyStreamerRequestStreamArgsBoolArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[bool](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsBool) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Bool.Decode) +} + +func (m *MyStreamerClient) RequestStreamArgsDatetime(ctx context.Context, value time.Time) flux.Flux[time.Time] { + request := MyStreamerRequestStreamArgsDatetimeArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[time.Time](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsDatetime) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.Time.Decode) +} + +func (m *MyStreamerClient) RequestStreamArgsList(ctx context.Context, value []string) flux.Flux[[]string] { + request := MyStreamerRequestStreamArgsListArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[[]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsList) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyStreamerClient) RequestStreamArgsMap(ctx context.Context, value map[string]string) flux.Flux[map[string]string] { + request := MyStreamerRequestStreamArgsMapArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[map[string]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestStreamArgsMap) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestStream(ctx, pl) + return flux.Map(future, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyStreamerClient) RequestChannelVoid(ctx context.Context, in flux.Flux[int64]) mono.Void { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelVoid) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Int64.Encode)) + return transform.FluxToVoid(future) +} + +func (m *MyStreamerClient) RequestChannelSingle(ctx context.Context, in flux.Flux[int64]) mono.Mono[int64] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelSingle) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + futureStream := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Int64.Encode)) + future := transform.FluxToMono(futureStream) + return mono.Map(future, transform.Int64.Decode) +} + +func (m *MyStreamerClient) RequestChannelI64(ctx context.Context, in flux.Flux[int64]) flux.Flux[int64] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelI64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Int64.Encode)) + return flux.Map(future, transform.Int64.Decode) +} + +func (m *MyStreamerClient) RequestChannelF64(ctx context.Context, in flux.Flux[float64]) flux.Flux[float64] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelF64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Float64.Encode)) + return flux.Map(future, transform.Float64.Decode) +} + +func (m *MyStreamerClient) RequestChannelType(ctx context.Context, in flux.Flux[MyType]) flux.Flux[MyType] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelType) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.MsgPackEncode[MyType])) + return flux.Map(future, transform.MsgPackDecode[MyType]) +} + +func (m *MyStreamerClient) RequestChannelEnum(ctx context.Context, in flux.Flux[MyEnum]) flux.Flux[MyEnum] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelEnum) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Int32Encode[MyEnum])) + return flux.Map(future, transform.Int32Decode[MyEnum]) +} + +func (m *MyStreamerClient) RequestChannelAlias(ctx context.Context, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelAlias) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.ToStringEncode(func(val uuid.UUID) string { + return val.String() + }))) + return flux.Map(future, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + })) +} + +func (m *MyStreamerClient) RequestChannelString(ctx context.Context, in flux.Flux[string]) flux.Flux[string] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelString) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.String.Encode)) + return flux.Map(future, transform.String.Decode) +} + +func (m *MyStreamerClient) RequestChannelBool(ctx context.Context, in flux.Flux[bool]) flux.Flux[bool] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelBool) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Bool.Encode)) + return flux.Map(future, transform.Bool.Decode) +} + +func (m *MyStreamerClient) RequestChannelDatetime(ctx context.Context, in flux.Flux[time.Time]) flux.Flux[time.Time] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelDatetime) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Time.Encode)) + return flux.Map(future, transform.Time.Decode) +} + +func (m *MyStreamerClient) RequestChannelList(ctx context.Context, in flux.Flux[[]string]) flux.Flux[[]string] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelList) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + }))) + return flux.Map(future, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyStreamerClient) RequestChannelMap(ctx context.Context, in flux.Flux[map[string]string]) flux.Flux[map[string]string] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelMap) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + }))) + return flux.Map(future, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyStreamerClient) RequestChannelArgsSingle(ctx context.Context, value int64, in flux.Flux[int64]) mono.Mono[int64] { + request := MyStreamerRequestChannelArgsSingleArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[int64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsSingle) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + futureStream := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Int64.Encode)) + future := transform.FluxToMono(futureStream) + return mono.Map(future, transform.Int64.Decode) +} + +func (m *MyStreamerClient) RequestChannelArgsI64(ctx context.Context, value int64, in flux.Flux[int64]) flux.Flux[int64] { + request := MyStreamerRequestChannelArgsI64Args{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[int64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsI64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Int64.Encode)) + return flux.Map(future, transform.Int64.Decode) +} + +func (m *MyStreamerClient) RequestChannelArgsF64(ctx context.Context, value float64, in flux.Flux[float64]) flux.Flux[float64] { + request := MyStreamerRequestChannelArgsF64Args{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[float64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsF64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Float64.Encode)) + return flux.Map(future, transform.Float64.Decode) +} + +func (m *MyStreamerClient) RequestChannelArgsType(ctx context.Context, value *MyType, in flux.Flux[MyType]) flux.Flux[MyType] { + request := MyStreamerRequestChannelArgsTypeArgs{ + Value: *value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[MyType](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsType) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.MsgPackEncode[MyType])) + return flux.Map(future, transform.MsgPackDecode[MyType]) +} + +func (m *MyStreamerClient) RequestChannelArgsEnum(ctx context.Context, value MyEnum, in flux.Flux[MyEnum]) flux.Flux[MyEnum] { + request := MyStreamerRequestChannelArgsEnumArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[MyEnum](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsEnum) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Int32Encode[MyEnum])) + return flux.Map(future, transform.Int32Decode[MyEnum]) +} + +func (m *MyStreamerClient) RequestChannelArgsAlias(ctx context.Context, value uuid.UUID, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] { + request := MyStreamerRequestChannelArgsAliasArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[uuid.UUID](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsAlias) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.ToStringEncode(func(val uuid.UUID) string { + return val.String() + }))) + return flux.Map(future, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + })) +} + +func (m *MyStreamerClient) RequestChannelArgsString(ctx context.Context, value string, in flux.Flux[string]) flux.Flux[string] { + request := MyStreamerRequestChannelArgsStringArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsString) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.String.Encode)) + return flux.Map(future, transform.String.Decode) +} + +func (m *MyStreamerClient) RequestChannelArgsBool(ctx context.Context, value bool, in flux.Flux[bool]) flux.Flux[bool] { + request := MyStreamerRequestChannelArgsBoolArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[bool](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsBool) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Bool.Encode)) + return flux.Map(future, transform.Bool.Decode) +} + +func (m *MyStreamerClient) RequestChannelArgsDatetime(ctx context.Context, value time.Time, in flux.Flux[time.Time]) flux.Flux[time.Time] { + request := MyStreamerRequestChannelArgsDatetimeArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[time.Time](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsDatetime) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.Time.Encode)) + return flux.Map(future, transform.Time.Decode) +} + +func (m *MyStreamerClient) RequestChannelArgsList(ctx context.Context, value []string, in flux.Flux[[]string]) flux.Flux[[]string] { + request := MyStreamerRequestChannelArgsListArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[[]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsList) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + }))) + return flux.Map(future, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyStreamerClient) RequestChannelArgsMap(ctx context.Context, value map[string]string, in flux.Flux[map[string]string]) flux.Flux[map[string]string] { + request := MyStreamerRequestChannelArgsMapArgs{ + Value: value, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return flux.Error[map[string]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyStreamerRequestChannelArgsMap) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestChannel(ctx, pl, flux.Map(in, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + }))) + return flux.Map(future, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +type MyServiceClient struct { + c *Client + instanceID uint64 +} + +func (c *Client) MyService() MyService { + return &MyServiceClient{ + c: c, + } +} + +func (m *MyServiceClient) EmptyVoid(ctx context.Context) mono.Void { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceEmptyVoid) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Void.Decode) +} + +func (m *MyServiceClient) UnaryType(ctx context.Context, value *MyType) mono.Mono[MyType] { + payloadData, err := msgpack.ToBytes(value) + if err != nil { + return mono.Error[MyType](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryType) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.MsgPackDecode[MyType]) +} + +func (m *MyServiceClient) UnaryEnum(ctx context.Context, value MyEnum) mono.Mono[MyEnum] { + payloadData, err := msgpack.I32ToBytes(int32(value)) + if err != nil { + return mono.Error[MyEnum](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryEnum) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int32Decode[MyEnum]) +} + +func (m *MyServiceClient) UnaryUUID(ctx context.Context, value uuid.UUID) mono.Mono[uuid.UUID] { + payloadData, err := msgpack.StringToBytes(value.String()) + if err != nil { + return mono.Error[uuid.UUID](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryUUID) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + })) +} + +func (m *MyServiceClient) UnaryAlias(ctx context.Context, value MyAlias) mono.Mono[MyAlias] { + payloadData, err := msgpack.StringToBytes(string(value)) + if err != nil { + return mono.Error[MyAlias](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryAlias) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.StringDecode[MyAlias]) +} + +func (m *MyServiceClient) UnaryString(ctx context.Context, value string) mono.Mono[string] { + payloadData, err := msgpack.StringToBytes(value) + if err != nil { + return mono.Error[string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryString) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.String.Decode) +} + +func (m *MyServiceClient) UnaryI64(ctx context.Context, value int64) mono.Mono[int64] { + payloadData, err := msgpack.I64ToBytes(value) + if err != nil { + return mono.Error[int64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryI64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int64.Decode) +} + +func (m *MyServiceClient) UnaryI32(ctx context.Context, value int32) mono.Mono[int32] { + payloadData, err := msgpack.I32ToBytes(value) + if err != nil { + return mono.Error[int32](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryI32) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int32.Decode) +} + +func (m *MyServiceClient) UnaryI16(ctx context.Context, value int16) mono.Mono[int16] { + payloadData, err := msgpack.I16ToBytes(value) + if err != nil { + return mono.Error[int16](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryI16) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int16.Decode) +} + +func (m *MyServiceClient) UnaryI8(ctx context.Context, value int8) mono.Mono[int8] { + payloadData, err := msgpack.I8ToBytes(value) + if err != nil { + return mono.Error[int8](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryI8) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int8.Decode) +} + +func (m *MyServiceClient) UnaryU64(ctx context.Context, value uint64) mono.Mono[uint64] { + payloadData, err := msgpack.U64ToBytes(value) + if err != nil { + return mono.Error[uint64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryU64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint64.Decode) +} + +func (m *MyServiceClient) UnaryU32(ctx context.Context, value uint32) mono.Mono[uint32] { + payloadData, err := msgpack.U32ToBytes(value) + if err != nil { + return mono.Error[uint32](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryU32) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint32.Decode) +} + +func (m *MyServiceClient) UnaryU16(ctx context.Context, value uint16) mono.Mono[uint16] { + payloadData, err := msgpack.U16ToBytes(value) + if err != nil { + return mono.Error[uint16](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryU16) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint16.Decode) +} + +func (m *MyServiceClient) UnaryU8(ctx context.Context, value uint8) mono.Mono[uint8] { + payloadData, err := msgpack.U8ToBytes(value) + if err != nil { + return mono.Error[uint8](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryU8) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint8.Decode) +} + +func (m *MyServiceClient) UnaryF64(ctx context.Context, value float64) mono.Mono[float64] { + payloadData, err := msgpack.F64ToBytes(value) + if err != nil { + return mono.Error[float64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryF64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Float64.Decode) +} + +func (m *MyServiceClient) UnaryF32(ctx context.Context, value float32) mono.Mono[float32] { + payloadData, err := msgpack.F32ToBytes(value) + if err != nil { + return mono.Error[float32](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryF32) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Float32.Decode) +} + +func (m *MyServiceClient) UnaryBytes(ctx context.Context, value []byte) mono.Mono[[]byte] { + payloadData, err := msgpack.BytesToBytes(value) + if err != nil { + return mono.Error[[]byte](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryBytes) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Bytes.Decode) +} + +func (m *MyServiceClient) UnaryDatetime(ctx context.Context, value time.Time) mono.Mono[time.Time] { + payloadData, err := msgpack.TimeToBytes(value) + if err != nil { + return mono.Error[time.Time](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryDatetime) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Time.Decode) +} + +func (m *MyServiceClient) UnaryList(ctx context.Context, value []string) mono.Mono[[]string] { + payloadData, err := msgpack.SliceToBytes(value, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + }) + if err != nil { + return mono.Error[[]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryList) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyServiceClient) UnaryMap(ctx context.Context, value map[string]string) mono.Mono[map[string]string] { + payloadData, err := msgpack.MapToBytes(value, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + }) + if err != nil { + return mono.Error[map[string]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceUnaryMap) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyServiceClient) FuncType(ctx context.Context, value *MyType, optional *MyType) mono.Mono[MyType] { + request := MyServiceFuncTypeArgs{ + Value: *value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[MyType](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncType) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.MsgPackDecode[MyType]) +} + +func (m *MyServiceClient) FuncEnum(ctx context.Context, value MyEnum, optional *MyEnum) mono.Mono[MyEnum] { + request := MyServiceFuncEnumArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[MyEnum](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncEnum) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int32Decode[MyEnum]) +} + +func (m *MyServiceClient) FuncUUID(ctx context.Context, value uuid.UUID, optional *uuid.UUID) mono.Mono[uuid.UUID] { + request := MyServiceFuncUUIDArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[uuid.UUID](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncUUID) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + })) +} + +func (m *MyServiceClient) FuncAlias(ctx context.Context, value MyAlias, optional *MyAlias) mono.Mono[MyAlias] { + request := MyServiceFuncAliasArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[MyAlias](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncAlias) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.StringDecode[MyAlias]) +} + +func (m *MyServiceClient) FuncString(ctx context.Context, value string, optional *string) mono.Mono[string] { + request := MyServiceFuncStringArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncString) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.String.Decode) +} + +func (m *MyServiceClient) FuncI64(ctx context.Context, value int64, optional *int64) mono.Mono[int64] { + request := MyServiceFuncI64Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[int64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncI64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int64.Decode) +} + +func (m *MyServiceClient) FuncI32(ctx context.Context, value int32, optional *int32) mono.Mono[int32] { + request := MyServiceFuncI32Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[int32](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncI32) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int32.Decode) +} + +func (m *MyServiceClient) FuncI16(ctx context.Context, value int16, optional *int16) mono.Mono[int16] { + request := MyServiceFuncI16Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[int16](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncI16) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int16.Decode) +} + +func (m *MyServiceClient) FuncI8(ctx context.Context, value int8, optional *int8) mono.Mono[int8] { + request := MyServiceFuncI8Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[int8](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncI8) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Int8.Decode) +} + +func (m *MyServiceClient) FuncU64(ctx context.Context, value uint64, optional *uint64) mono.Mono[uint64] { + request := MyServiceFuncU64Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[uint64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncU64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint64.Decode) +} + +func (m *MyServiceClient) FuncU32(ctx context.Context, value uint32, optional *uint32) mono.Mono[uint32] { + request := MyServiceFuncU32Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[uint32](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncU32) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint32.Decode) +} + +func (m *MyServiceClient) FuncU16(ctx context.Context, value uint16, optional *uint16) mono.Mono[uint16] { + request := MyServiceFuncU16Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[uint16](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncU16) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint16.Decode) +} + +func (m *MyServiceClient) FuncU8(ctx context.Context, value uint8, optional *uint8) mono.Mono[uint8] { + request := MyServiceFuncU8Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[uint8](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncU8) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Uint8.Decode) +} + +func (m *MyServiceClient) FuncF64(ctx context.Context, value float64, optional *float64) mono.Mono[float64] { + request := MyServiceFuncF64Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[float64](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncF64) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Float64.Decode) +} + +func (m *MyServiceClient) FuncF32(ctx context.Context, value float32, optional *float32) mono.Mono[float32] { + request := MyServiceFuncF32Args{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[float32](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncF32) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Float32.Decode) +} + +func (m *MyServiceClient) FuncBytes(ctx context.Context, value []byte, optional []byte) mono.Mono[[]byte] { + request := MyServiceFuncBytesArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[[]byte](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncBytes) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Bytes.Decode) +} + +func (m *MyServiceClient) FuncDatetime(ctx context.Context, value time.Time, optional *time.Time) mono.Mono[time.Time] { + request := MyServiceFuncDatetimeArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[time.Time](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncDatetime) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.Time.Decode) +} + +func (m *MyServiceClient) FuncList(ctx context.Context, value []string, optional []string) mono.Mono[[]string] { + request := MyServiceFuncListArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[[]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncList) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} + +func (m *MyServiceClient) FuncMap(ctx context.Context, value map[string]string, optional map[string]string) mono.Mono[map[string]string] { + request := MyServiceFuncMapArgs{ + Value: value, + Optional: optional, + } + payloadData, err := msgpack.ToBytes(&request) + if err != nil { + return mono.Error[map[string]string](err) + } + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], m.c._opMyServiceFuncMap) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := m.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + })) +} diff --git a/codegen/testdata/tinygo/expected/pkg/iotatest/interfaces.go b/codegen/testdata/tinygo/expected/pkg/iotatest/interfaces.go new file mode 100644 index 0000000..df6f6f5 --- /dev/null +++ b/codegen/testdata/tinygo/expected/pkg/iotatest/interfaces.go @@ -0,0 +1,254 @@ +// Code generated by @apexlang/codegen. DO NOT EDIT. + +package iotatest + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + "github.com/nanobus/iota/go/rx/flux" + "github.com/nanobus/iota/go/rx/mono" +) + +type MyAlias string + +type SomeCalcFn func(ctx context.Context, rhs int64, lhs int64) mono.Mono[int64] + +type MyStreamer interface { + RequestStreamI64(ctx context.Context) flux.Flux[int64] + RequestStreamF64(ctx context.Context) flux.Flux[float64] + RequestStreamType(ctx context.Context) flux.Flux[MyType] + RequestStreamEnum(ctx context.Context) flux.Flux[MyEnum] + RequestStreamUUID(ctx context.Context) flux.Flux[uuid.UUID] + RequestStreamAlias(ctx context.Context) flux.Flux[MyAlias] + RequestStreamString(ctx context.Context) flux.Flux[string] + RequestStreamBool(ctx context.Context) flux.Flux[bool] + RequestStreamDatetime(ctx context.Context) flux.Flux[time.Time] + RequestStreamList(ctx context.Context) flux.Flux[[]string] + RequestStreamMap(ctx context.Context) flux.Flux[map[string]string] + RequestStreamArgsI64(ctx context.Context, value int64) flux.Flux[int64] + RequestStreamArgsF64(ctx context.Context, value float64) flux.Flux[float64] + RequestStreamArgsType(ctx context.Context, value *MyType) flux.Flux[MyType] + RequestStreamArgsEnum(ctx context.Context, value MyEnum) flux.Flux[MyEnum] + RequestStreamArgsUUID(ctx context.Context, value uuid.UUID) flux.Flux[uuid.UUID] + RequestStreamArgsAlias(ctx context.Context, value MyAlias) flux.Flux[MyAlias] + RequestStreamArgsString(ctx context.Context, value string) flux.Flux[string] + RequestStreamArgsBool(ctx context.Context, value bool) flux.Flux[bool] + RequestStreamArgsDatetime(ctx context.Context, value time.Time) flux.Flux[time.Time] + RequestStreamArgsList(ctx context.Context, value []string) flux.Flux[[]string] + RequestStreamArgsMap(ctx context.Context, value map[string]string) flux.Flux[map[string]string] + RequestChannelVoid(ctx context.Context, in flux.Flux[int64]) mono.Void + RequestChannelSingle(ctx context.Context, in flux.Flux[int64]) mono.Mono[int64] + RequestChannelI64(ctx context.Context, in flux.Flux[int64]) flux.Flux[int64] + RequestChannelF64(ctx context.Context, in flux.Flux[float64]) flux.Flux[float64] + RequestChannelType(ctx context.Context, in flux.Flux[MyType]) flux.Flux[MyType] + RequestChannelEnum(ctx context.Context, in flux.Flux[MyEnum]) flux.Flux[MyEnum] + RequestChannelAlias(ctx context.Context, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] + RequestChannelString(ctx context.Context, in flux.Flux[string]) flux.Flux[string] + RequestChannelBool(ctx context.Context, in flux.Flux[bool]) flux.Flux[bool] + RequestChannelDatetime(ctx context.Context, in flux.Flux[time.Time]) flux.Flux[time.Time] + RequestChannelList(ctx context.Context, in flux.Flux[[]string]) flux.Flux[[]string] + RequestChannelMap(ctx context.Context, in flux.Flux[map[string]string]) flux.Flux[map[string]string] + RequestChannelArgsSingle(ctx context.Context, value int64, in flux.Flux[int64]) mono.Mono[int64] + RequestChannelArgsI64(ctx context.Context, value int64, in flux.Flux[int64]) flux.Flux[int64] + RequestChannelArgsF64(ctx context.Context, value float64, in flux.Flux[float64]) flux.Flux[float64] + RequestChannelArgsType(ctx context.Context, value *MyType, in flux.Flux[MyType]) flux.Flux[MyType] + RequestChannelArgsEnum(ctx context.Context, value MyEnum, in flux.Flux[MyEnum]) flux.Flux[MyEnum] + RequestChannelArgsAlias(ctx context.Context, value uuid.UUID, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] + RequestChannelArgsString(ctx context.Context, value string, in flux.Flux[string]) flux.Flux[string] + RequestChannelArgsBool(ctx context.Context, value bool, in flux.Flux[bool]) flux.Flux[bool] + RequestChannelArgsDatetime(ctx context.Context, value time.Time, in flux.Flux[time.Time]) flux.Flux[time.Time] + RequestChannelArgsList(ctx context.Context, value []string, in flux.Flux[[]string]) flux.Flux[[]string] + RequestChannelArgsMap(ctx context.Context, value map[string]string, in flux.Flux[map[string]string]) flux.Flux[map[string]string] +} + +type MyService interface { + EmptyVoid(ctx context.Context) mono.Void + UnaryType(ctx context.Context, value *MyType) mono.Mono[MyType] + UnaryEnum(ctx context.Context, value MyEnum) mono.Mono[MyEnum] + UnaryUUID(ctx context.Context, value uuid.UUID) mono.Mono[uuid.UUID] + UnaryAlias(ctx context.Context, value MyAlias) mono.Mono[MyAlias] + UnaryString(ctx context.Context, value string) mono.Mono[string] + UnaryI64(ctx context.Context, value int64) mono.Mono[int64] + UnaryI32(ctx context.Context, value int32) mono.Mono[int32] + UnaryI16(ctx context.Context, value int16) mono.Mono[int16] + UnaryI8(ctx context.Context, value int8) mono.Mono[int8] + UnaryU64(ctx context.Context, value uint64) mono.Mono[uint64] + UnaryU32(ctx context.Context, value uint32) mono.Mono[uint32] + UnaryU16(ctx context.Context, value uint16) mono.Mono[uint16] + UnaryU8(ctx context.Context, value uint8) mono.Mono[uint8] + UnaryF64(ctx context.Context, value float64) mono.Mono[float64] + UnaryF32(ctx context.Context, value float32) mono.Mono[float32] + UnaryBytes(ctx context.Context, value []byte) mono.Mono[[]byte] + UnaryDatetime(ctx context.Context, value time.Time) mono.Mono[time.Time] + UnaryList(ctx context.Context, value []string) mono.Mono[[]string] + UnaryMap(ctx context.Context, value map[string]string) mono.Mono[map[string]string] + FuncType(ctx context.Context, value *MyType, optional *MyType) mono.Mono[MyType] + FuncEnum(ctx context.Context, value MyEnum, optional *MyEnum) mono.Mono[MyEnum] + FuncUUID(ctx context.Context, value uuid.UUID, optional *uuid.UUID) mono.Mono[uuid.UUID] + FuncAlias(ctx context.Context, value MyAlias, optional *MyAlias) mono.Mono[MyAlias] + FuncString(ctx context.Context, value string, optional *string) mono.Mono[string] + FuncI64(ctx context.Context, value int64, optional *int64) mono.Mono[int64] + FuncI32(ctx context.Context, value int32, optional *int32) mono.Mono[int32] + FuncI16(ctx context.Context, value int16, optional *int16) mono.Mono[int16] + FuncI8(ctx context.Context, value int8, optional *int8) mono.Mono[int8] + FuncU64(ctx context.Context, value uint64, optional *uint64) mono.Mono[uint64] + FuncU32(ctx context.Context, value uint32, optional *uint32) mono.Mono[uint32] + FuncU16(ctx context.Context, value uint16, optional *uint16) mono.Mono[uint16] + FuncU8(ctx context.Context, value uint8, optional *uint8) mono.Mono[uint8] + FuncF64(ctx context.Context, value float64, optional *float64) mono.Mono[float64] + FuncF32(ctx context.Context, value float32, optional *float32) mono.Mono[float32] + FuncBytes(ctx context.Context, value []byte, optional []byte) mono.Mono[[]byte] + FuncDatetime(ctx context.Context, value time.Time, optional *time.Time) mono.Mono[time.Time] + FuncList(ctx context.Context, value []string, optional []string) mono.Mono[[]string] + FuncMap(ctx context.Context, value map[string]string, optional map[string]string) mono.Mono[map[string]string] +} + +type Repository interface { + GetData(ctx context.Context) mono.Mono[MyType] +} + +// MyType is a class +type MyType struct { + // same type value + SameValue *MyType `json:"sameValue,omitempty" yaml:"sameValue,omitempty" msgpack:"sameValue,omitempty"` + // type value + TypeValue MyOtherType `json:"typeValue" yaml:"typeValue" msgpack:"typeValue"` + // string value + StringValue string `json:"stringValue" yaml:"stringValue" msgpack:"stringValue"` + // string option + StringOption *string `json:"stringOption,omitempty" yaml:"stringOption,omitempty" msgpack:"stringOption,omitempty"` + // i64 value + I64Value int64 `json:"i64Value" yaml:"i64Value" msgpack:"i64Value"` + // i64 option + I64Option *int64 `json:"i64Option,omitempty" yaml:"i64Option,omitempty" msgpack:"i64Option,omitempty"` + // i32 value + I32Value int32 `json:"i32Value" yaml:"i32Value" msgpack:"i32Value"` + // i32 option + I32Option *int32 `json:"i32Option,omitempty" yaml:"i32Option,omitempty" msgpack:"i32Option,omitempty"` + // i16 value + I16Value int16 `json:"i16Value" yaml:"i16Value" msgpack:"i16Value"` + // i16 option + I16Option *int16 `json:"i16Option,omitempty" yaml:"i16Option,omitempty" msgpack:"i16Option,omitempty"` + // i8 value + I8Value int8 `json:"i8Value" yaml:"i8Value" msgpack:"i8Value"` + // i8 option + I8Option *int8 `json:"i8Option,omitempty" yaml:"i8Option,omitempty" msgpack:"i8Option,omitempty"` + // u64 value + U64Value uint64 `json:"u64Value" yaml:"u64Value" msgpack:"u64Value"` + // u64 option + U64Option *uint64 `json:"u64Option,omitempty" yaml:"u64Option,omitempty" msgpack:"u64Option,omitempty"` + // u32 value + U32Value uint32 `json:"u32Value" yaml:"u32Value" msgpack:"u32Value"` + // u32 option + U32Option *uint32 `json:"u32Option,omitempty" yaml:"u32Option,omitempty" msgpack:"u32Option,omitempty"` + // u16 value + U16Value uint16 `json:"u16Value" yaml:"u16Value" msgpack:"u16Value"` + // u16 option + U16Option *uint16 `json:"u16Option,omitempty" yaml:"u16Option,omitempty" msgpack:"u16Option,omitempty"` + // u8 value + U8Value uint8 `json:"u8Value" yaml:"u8Value" msgpack:"u8Value"` + // u8 option + U8Option *uint8 `json:"u8Option,omitempty" yaml:"u8Option,omitempty" msgpack:"u8Option,omitempty"` + // f64 value + F64Value float64 `json:"f64Value" yaml:"f64Value" msgpack:"f64Value"` + // f64 option + F64Option *float64 `json:"f64Option,omitempty" yaml:"f64Option,omitempty" msgpack:"f64Option,omitempty"` + // f32 value + F32Value float32 `json:"f32Value" yaml:"f32Value" msgpack:"f32Value"` + // f32 option + F32Option *float32 `json:"f32Option,omitempty" yaml:"f32Option,omitempty" msgpack:"f32Option,omitempty"` + // datetime value + DatetimeValue time.Time `json:"datetimeValue" yaml:"datetimeValue" msgpack:"datetimeValue"` + // datetime option + DatetimeOption *time.Time `json:"datetimeOption,omitempty" yaml:"datetimeOption,omitempty" msgpack:"datetimeOption,omitempty"` + // bytes value + BytesValue []byte `json:"bytesValue" yaml:"bytesValue" msgpack:"bytesValue"` + // bytes option + BytesOption []byte `json:"bytesOption,omitempty" yaml:"bytesOption,omitempty" msgpack:"bytesOption,omitempty"` + // map value + MapValue map[string]int64 `json:"mapValue" yaml:"mapValue" msgpack:"mapValue"` + // map of types + MapOfTypes map[string]MyType `json:"mapOfTypes" yaml:"mapOfTypes" msgpack:"mapOfTypes"` + // array value + ArrayValue []string `json:"arrayValue" yaml:"arrayValue" msgpack:"arrayValue"` + // array of types + ArrayOfTypes []MyType `json:"arrayOfTypes" yaml:"arrayOfTypes" msgpack:"arrayOfTypes"` + // union value + UnionValue MyUnion `json:"unionValue" yaml:"unionValue" msgpack:"unionValue"` + // union option + UnionOption *MyUnion `json:"unionOption,omitempty" yaml:"unionOption,omitempty" msgpack:"unionOption,omitempty"` + // enum value + EnumValue MyEnum `json:"enumValue" yaml:"enumValue" msgpack:"enumValue"` + // enum option + EnumOption *MyEnum `json:"enumOption,omitempty" yaml:"enumOption,omitempty" msgpack:"enumOption,omitempty"` + // enum value + AliasValue uuid.UUID `json:"aliasValue" yaml:"aliasValue" msgpack:"aliasValue"` + // enum option + AliasOption *uuid.UUID `json:"aliasOption,omitempty" yaml:"aliasOption,omitempty" msgpack:"aliasOption,omitempty"` +} + +// DefaultMyType returns a `MyType` struct populated with its default values. +func DefaultMyType() MyType { + return MyType{} +} + +type MyOtherType struct { + Foo string `json:"foo" yaml:"foo" msgpack:"foo"` + Bar string `json:"bar" yaml:"bar" msgpack:"bar"` +} + +// DefaultMyOtherType returns a `MyOtherType` struct populated with its default +// values. +func DefaultMyOtherType() MyOtherType { + return MyOtherType{} +} + +type MyUnion struct { + MyType *MyType `json:"MyType,omitempty" yaml:"MyType,omitempty" msgpack:"MyType,omitempty"` + MyEnum *MyEnum `json:"MyEnum,omitempty" yaml:"MyEnum,omitempty" msgpack:"MyEnum,omitempty"` + String *string `json:"string,omitempty" yaml:"string,omitempty" msgpack:"string,omitempty"` +} + +// MyEnum is an emuneration +type MyEnum int32 + +const ( + // ONE value + MyEnumOne MyEnum = 0 + // TWO value + MyEnumTwo MyEnum = 1 + // THREE value + MyEnumThree MyEnum = 2 +) + +var toStringMyEnum = map[MyEnum]string{ + MyEnumOne: "one", + MyEnumTwo: "TWO", + MyEnumThree: "three", +} + +var toIDMyEnum = map[string]MyEnum{ + "one": MyEnumOne, + "TWO": MyEnumTwo, + "three": MyEnumThree, +} + +func (e MyEnum) String() string { + str, ok := toStringMyEnum[e] + if !ok { + return "unknown" + } + return str +} + +func (e *MyEnum) FromString(str string) error { + var ok bool + *e, ok = toIDMyEnum[str] + if !ok { + return errors.New("unknown value \"" + str + "\" for MyEnum") + } + return nil +} diff --git a/codegen/testdata/tinygo/expected/pkg/iotatest/iota.go b/codegen/testdata/tinygo/expected/pkg/iotatest/iota.go new file mode 100644 index 0000000..24b9edd --- /dev/null +++ b/codegen/testdata/tinygo/expected/pkg/iotatest/iota.go @@ -0,0 +1,3617 @@ +// Code generated by @apexlang/codegen. DO NOT EDIT. + +package iotatest + +import ( + "context" + "encoding/binary" + "time" + + "github.com/google/uuid" + "github.com/nanobus/iota/go/invoke" + "github.com/nanobus/iota/go/msgpack" + "github.com/nanobus/iota/go/msgpack/convert" + "github.com/nanobus/iota/go/payload" + "github.com/nanobus/iota/go/proxy" + "github.com/nanobus/iota/go/rx/flux" + "github.com/nanobus/iota/go/rx/mono" + "github.com/nanobus/iota/go/transform" +) + +type SomeCalcArgs struct { + Rhs int64 `json:"rhs" yaml:"rhs" msgpack:"rhs"` + Lhs int64 `json:"lhs" yaml:"lhs" msgpack:"lhs"` +} + +// DefaultSomeCalcArgs returns a `SomeCalcArgs` struct populated with its default +// values. +func DefaultSomeCalcArgs() SomeCalcArgs { + return SomeCalcArgs{} +} + +func (o *SomeCalcArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "rhs": + o.Rhs, err = decoder.ReadInt64() + case "lhs": + o.Lhs, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *SomeCalcArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("rhs") + encoder.WriteInt64(o.Rhs) + encoder.WriteString("lhs") + encoder.WriteInt64(o.Lhs) + + return nil +} + +type MyStreamerRequestStreamArgsI64Args struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsI64Args returns a +// `MyStreamerRequestStreamArgsI64Args` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsI64Args() MyStreamerRequestStreamArgsI64Args { + return MyStreamerRequestStreamArgsI64Args{} +} + +func (o *MyStreamerRequestStreamArgsI64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsI64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsF64Args struct { + Value float64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsF64Args returns a +// `MyStreamerRequestStreamArgsF64Args` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsF64Args() MyStreamerRequestStreamArgsF64Args { + return MyStreamerRequestStreamArgsF64Args{} +} + +func (o *MyStreamerRequestStreamArgsF64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsF64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteFloat64(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsTypeArgs struct { + Value MyType `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsTypeArgs returns a +// `MyStreamerRequestStreamArgsTypeArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsTypeArgs() MyStreamerRequestStreamArgsTypeArgs { + return MyStreamerRequestStreamArgsTypeArgs{} +} + +func (o *MyStreamerRequestStreamArgsTypeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + err = o.Value.Decode(decoder) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsTypeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + o.Value.Encode(encoder) + + return nil +} + +type MyStreamerRequestStreamArgsEnumArgs struct { + Value MyEnum `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsEnumArgs returns a +// `MyStreamerRequestStreamArgsEnumArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsEnumArgs() MyStreamerRequestStreamArgsEnumArgs { + return MyStreamerRequestStreamArgsEnumArgs{} +} + +func (o *MyStreamerRequestStreamArgsEnumArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsEnumArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt32(int32(o.Value)) + + return nil +} + +type MyStreamerRequestStreamArgsUUIDArgs struct { + Value uuid.UUID `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsUUIDArgs returns a +// `MyStreamerRequestStreamArgsUUIDArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsUUIDArgs() MyStreamerRequestStreamArgsUUIDArgs { + return MyStreamerRequestStreamArgsUUIDArgs{} +} + +func (o *MyStreamerRequestStreamArgsUUIDArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsUUIDArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value.String()) + + return nil +} + +type MyStreamerRequestStreamArgsAliasArgs struct { + Value MyAlias `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsAliasArgs returns a +// `MyStreamerRequestStreamArgsAliasArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsAliasArgs() MyStreamerRequestStreamArgsAliasArgs { + return MyStreamerRequestStreamArgsAliasArgs{} +} + +func (o *MyStreamerRequestStreamArgsAliasArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.String[MyAlias](decoder.ReadString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsAliasArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(string(o.Value)) + + return nil +} + +type MyStreamerRequestStreamArgsStringArgs struct { + Value string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsStringArgs returns a +// `MyStreamerRequestStreamArgsStringArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestStreamArgsStringArgs() MyStreamerRequestStreamArgsStringArgs { + return MyStreamerRequestStreamArgsStringArgs{} +} + +func (o *MyStreamerRequestStreamArgsStringArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsStringArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsBoolArgs struct { + Value bool `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsBoolArgs returns a +// `MyStreamerRequestStreamArgsBoolArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsBoolArgs() MyStreamerRequestStreamArgsBoolArgs { + return MyStreamerRequestStreamArgsBoolArgs{} +} + +func (o *MyStreamerRequestStreamArgsBoolArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadBool() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsBoolArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteBool(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsDatetimeArgs struct { + Value time.Time `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsDatetimeArgs returns a +// `MyStreamerRequestStreamArgsDatetimeArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestStreamArgsDatetimeArgs() MyStreamerRequestStreamArgsDatetimeArgs { + return MyStreamerRequestStreamArgsDatetimeArgs{} +} + +func (o *MyStreamerRequestStreamArgsDatetimeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadTime() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsDatetimeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteTime(o.Value) + + return nil +} + +type MyStreamerRequestStreamArgsListArgs struct { + Value []string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsListArgs returns a +// `MyStreamerRequestStreamArgsListArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsListArgs() MyStreamerRequestStreamArgsListArgs { + return MyStreamerRequestStreamArgsListArgs{} +} + +func (o *MyStreamerRequestStreamArgsListArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsListArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteArraySize(uint32(len(o.Value))) + for _, v := range o.Value { + encoder.WriteString(v) + } + + return nil +} + +type MyStreamerRequestStreamArgsMapArgs struct { + Value map[string]string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestStreamArgsMapArgs returns a +// `MyStreamerRequestStreamArgsMapArgs` struct populated with its default values. +func DefaultMyStreamerRequestStreamArgsMapArgs() MyStreamerRequestStreamArgsMapArgs { + return MyStreamerRequestStreamArgsMapArgs{} +} + +func (o *MyStreamerRequestStreamArgsMapArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestStreamArgsMapArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteMapSize(uint32(len(o.Value))) + if o.Value != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Value { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + + return nil +} + +type MyStreamerRequestChannelArgsSingleArgs struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsSingleArgs returns a +// `MyStreamerRequestChannelArgsSingleArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsSingleArgs() MyStreamerRequestChannelArgsSingleArgs { + return MyStreamerRequestChannelArgsSingleArgs{} +} + +func (o *MyStreamerRequestChannelArgsSingleArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsSingleArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsI64Args struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsI64Args returns a +// `MyStreamerRequestChannelArgsI64Args` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsI64Args() MyStreamerRequestChannelArgsI64Args { + return MyStreamerRequestChannelArgsI64Args{} +} + +func (o *MyStreamerRequestChannelArgsI64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsI64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsF64Args struct { + Value float64 `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsF64Args returns a +// `MyStreamerRequestChannelArgsF64Args` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsF64Args() MyStreamerRequestChannelArgsF64Args { + return MyStreamerRequestChannelArgsF64Args{} +} + +func (o *MyStreamerRequestChannelArgsF64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsF64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteFloat64(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsTypeArgs struct { + Value MyType `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsTypeArgs returns a +// `MyStreamerRequestChannelArgsTypeArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsTypeArgs() MyStreamerRequestChannelArgsTypeArgs { + return MyStreamerRequestChannelArgsTypeArgs{} +} + +func (o *MyStreamerRequestChannelArgsTypeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + err = o.Value.Decode(decoder) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsTypeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + o.Value.Encode(encoder) + + return nil +} + +type MyStreamerRequestChannelArgsEnumArgs struct { + Value MyEnum `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsEnumArgs returns a +// `MyStreamerRequestChannelArgsEnumArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsEnumArgs() MyStreamerRequestChannelArgsEnumArgs { + return MyStreamerRequestChannelArgsEnumArgs{} +} + +func (o *MyStreamerRequestChannelArgsEnumArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsEnumArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteInt32(int32(o.Value)) + + return nil +} + +type MyStreamerRequestChannelArgsAliasArgs struct { + Value uuid.UUID `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsAliasArgs returns a +// `MyStreamerRequestChannelArgsAliasArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsAliasArgs() MyStreamerRequestChannelArgsAliasArgs { + return MyStreamerRequestChannelArgsAliasArgs{} +} + +func (o *MyStreamerRequestChannelArgsAliasArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsAliasArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value.String()) + + return nil +} + +type MyStreamerRequestChannelArgsStringArgs struct { + Value string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsStringArgs returns a +// `MyStreamerRequestChannelArgsStringArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsStringArgs() MyStreamerRequestChannelArgsStringArgs { + return MyStreamerRequestChannelArgsStringArgs{} +} + +func (o *MyStreamerRequestChannelArgsStringArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsStringArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteString(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsBoolArgs struct { + Value bool `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsBoolArgs returns a +// `MyStreamerRequestChannelArgsBoolArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsBoolArgs() MyStreamerRequestChannelArgsBoolArgs { + return MyStreamerRequestChannelArgsBoolArgs{} +} + +func (o *MyStreamerRequestChannelArgsBoolArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadBool() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsBoolArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteBool(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsDatetimeArgs struct { + Value time.Time `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsDatetimeArgs returns a +// `MyStreamerRequestChannelArgsDatetimeArgs` struct populated with its default +// values. +func DefaultMyStreamerRequestChannelArgsDatetimeArgs() MyStreamerRequestChannelArgsDatetimeArgs { + return MyStreamerRequestChannelArgsDatetimeArgs{} +} + +func (o *MyStreamerRequestChannelArgsDatetimeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadTime() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsDatetimeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteTime(o.Value) + + return nil +} + +type MyStreamerRequestChannelArgsListArgs struct { + Value []string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsListArgs returns a +// `MyStreamerRequestChannelArgsListArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsListArgs() MyStreamerRequestChannelArgsListArgs { + return MyStreamerRequestChannelArgsListArgs{} +} + +func (o *MyStreamerRequestChannelArgsListArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsListArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteArraySize(uint32(len(o.Value))) + for _, v := range o.Value { + encoder.WriteString(v) + } + + return nil +} + +type MyStreamerRequestChannelArgsMapArgs struct { + Value map[string]string `json:"value" yaml:"value" msgpack:"value"` +} + +// DefaultMyStreamerRequestChannelArgsMapArgs returns a +// `MyStreamerRequestChannelArgsMapArgs` struct populated with its default values. +func DefaultMyStreamerRequestChannelArgsMapArgs() MyStreamerRequestChannelArgsMapArgs { + return MyStreamerRequestChannelArgsMapArgs{} +} + +func (o *MyStreamerRequestChannelArgsMapArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyStreamerRequestChannelArgsMapArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(1) + encoder.WriteString("value") + encoder.WriteMapSize(uint32(len(o.Value))) + if o.Value != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Value { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + + return nil +} + +type MyServiceFuncTypeArgs struct { + Value MyType `json:"value" yaml:"value" msgpack:"value"` + Optional *MyType `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncTypeArgs returns a `MyServiceFuncTypeArgs` struct populated +// with its default values. +func DefaultMyServiceFuncTypeArgs() MyServiceFuncTypeArgs { + return MyServiceFuncTypeArgs{} +} + +func (o *MyServiceFuncTypeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + err = o.Value.Decode(decoder) + case "optional": + o.Optional, err = msgpack.DecodeNillable[MyType](decoder) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncTypeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + o.Value.Encode(encoder) + encoder.WriteString("optional") + o.Optional.Encode(encoder) + + return nil +} + +type MyServiceFuncEnumArgs struct { + Value MyEnum `json:"value" yaml:"value" msgpack:"value"` + Optional *MyEnum `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncEnumArgs returns a `MyServiceFuncEnumArgs` struct populated +// with its default values. +func DefaultMyServiceFuncEnumArgs() MyServiceFuncEnumArgs { + return MyServiceFuncEnumArgs{} +} + +func (o *MyServiceFuncEnumArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + case "optional": + o.Optional, err = convert.NillableNumeric[MyEnum](decoder.ReadNillableInt32()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncEnumArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt32(int32(o.Value)) + encoder.WriteString("optional") + encoder.WriteNillableInt32((*int32)(o.Optional)) + + return nil +} + +type MyServiceFuncUUIDArgs struct { + Value uuid.UUID `json:"value" yaml:"value" msgpack:"value"` + Optional *uuid.UUID `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncUUIDArgs returns a `MyServiceFuncUUIDArgs` struct populated +// with its default values. +func DefaultMyServiceFuncUUIDArgs() MyServiceFuncUUIDArgs { + return MyServiceFuncUUIDArgs{} +} + +func (o *MyServiceFuncUUIDArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + case "optional": + o.Optional, err = convert.NillableParse(uuid.Parse)(decoder.ReadNillableString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncUUIDArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteString(o.Value.String()) + encoder.WriteString("optional") + if o.Optional == nil { + encoder.WriteNil() + } else { + encoder.WriteString(o.Optional.String()) + } + + return nil +} + +type MyServiceFuncAliasArgs struct { + Value MyAlias `json:"value" yaml:"value" msgpack:"value"` + Optional *MyAlias `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncAliasArgs returns a `MyServiceFuncAliasArgs` struct +// populated with its default values. +func DefaultMyServiceFuncAliasArgs() MyServiceFuncAliasArgs { + return MyServiceFuncAliasArgs{} +} + +func (o *MyServiceFuncAliasArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = convert.String[MyAlias](decoder.ReadString()) + case "optional": + o.Optional, err = convert.NillableString[MyAlias](decoder.ReadNillableString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncAliasArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteString(string(o.Value)) + encoder.WriteString("optional") + encoder.WriteNillableString((*string)(o.Optional)) + + return nil +} + +type MyServiceFuncStringArgs struct { + Value string `json:"value" yaml:"value" msgpack:"value"` + Optional *string `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncStringArgs returns a `MyServiceFuncStringArgs` struct +// populated with its default values. +func DefaultMyServiceFuncStringArgs() MyServiceFuncStringArgs { + return MyServiceFuncStringArgs{} +} + +func (o *MyServiceFuncStringArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadString() + case "optional": + o.Optional, err = decoder.ReadNillableString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncStringArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteString(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableString(o.Optional) + + return nil +} + +type MyServiceFuncI64Args struct { + Value int64 `json:"value" yaml:"value" msgpack:"value"` + Optional *int64 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI64Args returns a `MyServiceFuncI64Args` struct populated +// with its default values. +func DefaultMyServiceFuncI64Args() MyServiceFuncI64Args { + return MyServiceFuncI64Args{} +} + +func (o *MyServiceFuncI64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt64() + case "optional": + o.Optional, err = decoder.ReadNillableInt64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt64(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt64(o.Optional) + + return nil +} + +type MyServiceFuncI32Args struct { + Value int32 `json:"value" yaml:"value" msgpack:"value"` + Optional *int32 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI32Args returns a `MyServiceFuncI32Args` struct populated +// with its default values. +func DefaultMyServiceFuncI32Args() MyServiceFuncI32Args { + return MyServiceFuncI32Args{} +} + +func (o *MyServiceFuncI32Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt32() + case "optional": + o.Optional, err = decoder.ReadNillableInt32() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI32Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt32(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt32(o.Optional) + + return nil +} + +type MyServiceFuncI16Args struct { + Value int16 `json:"value" yaml:"value" msgpack:"value"` + Optional *int16 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI16Args returns a `MyServiceFuncI16Args` struct populated +// with its default values. +func DefaultMyServiceFuncI16Args() MyServiceFuncI16Args { + return MyServiceFuncI16Args{} +} + +func (o *MyServiceFuncI16Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt16() + case "optional": + o.Optional, err = decoder.ReadNillableInt16() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI16Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt16(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt16(o.Optional) + + return nil +} + +type MyServiceFuncI8Args struct { + Value int8 `json:"value" yaml:"value" msgpack:"value"` + Optional *int8 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncI8Args returns a `MyServiceFuncI8Args` struct populated with +// its default values. +func DefaultMyServiceFuncI8Args() MyServiceFuncI8Args { + return MyServiceFuncI8Args{} +} + +func (o *MyServiceFuncI8Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadInt8() + case "optional": + o.Optional, err = decoder.ReadNillableInt8() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncI8Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteInt8(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableInt8(o.Optional) + + return nil +} + +type MyServiceFuncU64Args struct { + Value uint64 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint64 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU64Args returns a `MyServiceFuncU64Args` struct populated +// with its default values. +func DefaultMyServiceFuncU64Args() MyServiceFuncU64Args { + return MyServiceFuncU64Args{} +} + +func (o *MyServiceFuncU64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint64() + case "optional": + o.Optional, err = decoder.ReadNillableUint64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint64(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint64(o.Optional) + + return nil +} + +type MyServiceFuncU32Args struct { + Value uint32 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint32 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU32Args returns a `MyServiceFuncU32Args` struct populated +// with its default values. +func DefaultMyServiceFuncU32Args() MyServiceFuncU32Args { + return MyServiceFuncU32Args{} +} + +func (o *MyServiceFuncU32Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint32() + case "optional": + o.Optional, err = decoder.ReadNillableUint32() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU32Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint32(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint32(o.Optional) + + return nil +} + +type MyServiceFuncU16Args struct { + Value uint16 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint16 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU16Args returns a `MyServiceFuncU16Args` struct populated +// with its default values. +func DefaultMyServiceFuncU16Args() MyServiceFuncU16Args { + return MyServiceFuncU16Args{} +} + +func (o *MyServiceFuncU16Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint16() + case "optional": + o.Optional, err = decoder.ReadNillableUint16() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU16Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint16(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint16(o.Optional) + + return nil +} + +type MyServiceFuncU8Args struct { + Value uint8 `json:"value" yaml:"value" msgpack:"value"` + Optional *uint8 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncU8Args returns a `MyServiceFuncU8Args` struct populated with +// its default values. +func DefaultMyServiceFuncU8Args() MyServiceFuncU8Args { + return MyServiceFuncU8Args{} +} + +func (o *MyServiceFuncU8Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadUint8() + case "optional": + o.Optional, err = decoder.ReadNillableUint8() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncU8Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteUint8(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableUint8(o.Optional) + + return nil +} + +type MyServiceFuncF64Args struct { + Value float64 `json:"value" yaml:"value" msgpack:"value"` + Optional *float64 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncF64Args returns a `MyServiceFuncF64Args` struct populated +// with its default values. +func DefaultMyServiceFuncF64Args() MyServiceFuncF64Args { + return MyServiceFuncF64Args{} +} + +func (o *MyServiceFuncF64Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat64() + case "optional": + o.Optional, err = decoder.ReadNillableFloat64() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncF64Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteFloat64(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableFloat64(o.Optional) + + return nil +} + +type MyServiceFuncF32Args struct { + Value float32 `json:"value" yaml:"value" msgpack:"value"` + Optional *float32 `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncF32Args returns a `MyServiceFuncF32Args` struct populated +// with its default values. +func DefaultMyServiceFuncF32Args() MyServiceFuncF32Args { + return MyServiceFuncF32Args{} +} + +func (o *MyServiceFuncF32Args) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadFloat32() + case "optional": + o.Optional, err = decoder.ReadNillableFloat32() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncF32Args) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteFloat32(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableFloat32(o.Optional) + + return nil +} + +type MyServiceFuncBytesArgs struct { + Value []byte `json:"value" yaml:"value" msgpack:"value"` + Optional []byte `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncBytesArgs returns a `MyServiceFuncBytesArgs` struct +// populated with its default values. +func DefaultMyServiceFuncBytesArgs() MyServiceFuncBytesArgs { + return MyServiceFuncBytesArgs{} +} + +func (o *MyServiceFuncBytesArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadByteArray() + case "optional": + o.Optional, err = decoder.ReadNillableByteArray() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncBytesArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteByteArray(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableByteArray(o.Optional) + + return nil +} + +type MyServiceFuncDatetimeArgs struct { + Value time.Time `json:"value" yaml:"value" msgpack:"value"` + Optional *time.Time `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncDatetimeArgs returns a `MyServiceFuncDatetimeArgs` struct +// populated with its default values. +func DefaultMyServiceFuncDatetimeArgs() MyServiceFuncDatetimeArgs { + return MyServiceFuncDatetimeArgs{} +} + +func (o *MyServiceFuncDatetimeArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = decoder.ReadTime() + case "optional": + o.Optional, err = decoder.ReadNillableTime() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncDatetimeArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteTime(o.Value) + encoder.WriteString("optional") + encoder.WriteNillableTime(o.Optional) + + return nil +} + +type MyServiceFuncListArgs struct { + Value []string `json:"value" yaml:"value" msgpack:"value"` + Optional []string `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncListArgs returns a `MyServiceFuncListArgs` struct populated +// with its default values. +func DefaultMyServiceFuncListArgs() MyServiceFuncListArgs { + return MyServiceFuncListArgs{} +} + +func (o *MyServiceFuncListArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + case "optional": + o.Optional, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncListArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteArraySize(uint32(len(o.Value))) + for _, v := range o.Value { + encoder.WriteString(v) + } + encoder.WriteString("optional") + encoder.WriteArraySize(uint32(len(o.Optional))) + for _, v := range o.Optional { + encoder.WriteString(v) + } + + return nil +} + +type MyServiceFuncMapArgs struct { + Value map[string]string `json:"value" yaml:"value" msgpack:"value"` + Optional map[string]string `json:"optional,omitempty" yaml:"optional,omitempty" msgpack:"optional,omitempty"` +} + +// DefaultMyServiceFuncMapArgs returns a `MyServiceFuncMapArgs` struct populated +// with its default values. +func DefaultMyServiceFuncMapArgs() MyServiceFuncMapArgs { + return MyServiceFuncMapArgs{} +} + +func (o *MyServiceFuncMapArgs) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "value": + o.Value, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + case "optional": + o.Optional, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyServiceFuncMapArgs) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("value") + encoder.WriteMapSize(uint32(len(o.Value))) + if o.Value != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Value { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + encoder.WriteString("optional") + encoder.WriteMapSize(uint32(len(o.Optional))) + if o.Optional != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.Optional { + encoder.WriteString(k) + encoder.WriteString(v) + } + } + + return nil +} + +func (o *MyType) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "sameValue": + o.SameValue, err = msgpack.DecodeNillable[MyType](decoder) + case "typeValue": + err = o.TypeValue.Decode(decoder) + case "stringValue": + o.StringValue, err = decoder.ReadString() + case "stringOption": + o.StringOption, err = decoder.ReadNillableString() + case "i64Value": + o.I64Value, err = decoder.ReadInt64() + case "i64Option": + o.I64Option, err = decoder.ReadNillableInt64() + case "i32Value": + o.I32Value, err = decoder.ReadInt32() + case "i32Option": + o.I32Option, err = decoder.ReadNillableInt32() + case "i16Value": + o.I16Value, err = decoder.ReadInt16() + case "i16Option": + o.I16Option, err = decoder.ReadNillableInt16() + case "i8Value": + o.I8Value, err = decoder.ReadInt8() + case "i8Option": + o.I8Option, err = decoder.ReadNillableInt8() + case "u64Value": + o.U64Value, err = decoder.ReadUint64() + case "u64Option": + o.U64Option, err = decoder.ReadNillableUint64() + case "u32Value": + o.U32Value, err = decoder.ReadUint32() + case "u32Option": + o.U32Option, err = decoder.ReadNillableUint32() + case "u16Value": + o.U16Value, err = decoder.ReadUint16() + case "u16Option": + o.U16Option, err = decoder.ReadNillableUint16() + case "u8Value": + o.U8Value, err = decoder.ReadUint8() + case "u8Option": + o.U8Option, err = decoder.ReadNillableUint8() + case "f64Value": + o.F64Value, err = decoder.ReadFloat64() + case "f64Option": + o.F64Option, err = decoder.ReadNillableFloat64() + case "f32Value": + o.F32Value, err = decoder.ReadFloat32() + case "f32Option": + o.F32Option, err = decoder.ReadNillableFloat32() + case "datetimeValue": + o.DatetimeValue, err = decoder.ReadTime() + case "datetimeOption": + o.DatetimeOption, err = decoder.ReadNillableTime() + case "bytesValue": + o.BytesValue, err = decoder.ReadByteArray() + case "bytesOption": + o.BytesOption, err = decoder.ReadNillableByteArray() + case "mapValue": + o.MapValue, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (int64, error) { + return decoder.ReadInt64() + }) + case "mapOfTypes": + o.MapOfTypes, err = msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (MyType, error) { + return msgpack.Decode[MyType](decoder) + }) + case "arrayValue": + o.ArrayValue, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + case "arrayOfTypes": + o.ArrayOfTypes, err = msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (MyType, error) { + return msgpack.Decode[MyType](decoder) + }) + case "unionValue": + o.UnionValue, err = msgpack.Decode[MyUnion](decoder) + case "unionOption": + o.UnionOption, err = msgpack.DecodeNillable[MyUnion](decoder) + case "enumValue": + o.EnumValue, err = convert.Numeric[MyEnum](decoder.ReadInt32()) + case "enumOption": + o.EnumOption, err = convert.NillableNumeric[MyEnum](decoder.ReadNillableInt32()) + case "aliasValue": + o.AliasValue, err = convert.Parse(uuid.Parse)(decoder.ReadString()) + case "aliasOption": + o.AliasOption, err = convert.NillableParse(uuid.Parse)(decoder.ReadNillableString()) + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyType) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(38) + encoder.WriteString("sameValue") + o.SameValue.Encode(encoder) + encoder.WriteString("typeValue") + o.TypeValue.Encode(encoder) + encoder.WriteString("stringValue") + encoder.WriteString(o.StringValue) + encoder.WriteString("stringOption") + encoder.WriteNillableString(o.StringOption) + encoder.WriteString("i64Value") + encoder.WriteInt64(o.I64Value) + encoder.WriteString("i64Option") + encoder.WriteNillableInt64(o.I64Option) + encoder.WriteString("i32Value") + encoder.WriteInt32(o.I32Value) + encoder.WriteString("i32Option") + encoder.WriteNillableInt32(o.I32Option) + encoder.WriteString("i16Value") + encoder.WriteInt16(o.I16Value) + encoder.WriteString("i16Option") + encoder.WriteNillableInt16(o.I16Option) + encoder.WriteString("i8Value") + encoder.WriteInt8(o.I8Value) + encoder.WriteString("i8Option") + encoder.WriteNillableInt8(o.I8Option) + encoder.WriteString("u64Value") + encoder.WriteUint64(o.U64Value) + encoder.WriteString("u64Option") + encoder.WriteNillableUint64(o.U64Option) + encoder.WriteString("u32Value") + encoder.WriteUint32(o.U32Value) + encoder.WriteString("u32Option") + encoder.WriteNillableUint32(o.U32Option) + encoder.WriteString("u16Value") + encoder.WriteUint16(o.U16Value) + encoder.WriteString("u16Option") + encoder.WriteNillableUint16(o.U16Option) + encoder.WriteString("u8Value") + encoder.WriteUint8(o.U8Value) + encoder.WriteString("u8Option") + encoder.WriteNillableUint8(o.U8Option) + encoder.WriteString("f64Value") + encoder.WriteFloat64(o.F64Value) + encoder.WriteString("f64Option") + encoder.WriteNillableFloat64(o.F64Option) + encoder.WriteString("f32Value") + encoder.WriteFloat32(o.F32Value) + encoder.WriteString("f32Option") + encoder.WriteNillableFloat32(o.F32Option) + encoder.WriteString("datetimeValue") + encoder.WriteTime(o.DatetimeValue) + encoder.WriteString("datetimeOption") + encoder.WriteNillableTime(o.DatetimeOption) + encoder.WriteString("bytesValue") + encoder.WriteByteArray(o.BytesValue) + encoder.WriteString("bytesOption") + encoder.WriteNillableByteArray(o.BytesOption) + encoder.WriteString("mapValue") + encoder.WriteMapSize(uint32(len(o.MapValue))) + if o.MapValue != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.MapValue { + encoder.WriteString(k) + encoder.WriteInt64(v) + } + } + encoder.WriteString("mapOfTypes") + encoder.WriteMapSize(uint32(len(o.MapOfTypes))) + if o.MapOfTypes != nil { // TinyGo bug: ranging over nil maps panics. + for k, v := range o.MapOfTypes { + encoder.WriteString(k) + v.Encode(encoder) + } + } + encoder.WriteString("arrayValue") + encoder.WriteArraySize(uint32(len(o.ArrayValue))) + for _, v := range o.ArrayValue { + encoder.WriteString(v) + } + encoder.WriteString("arrayOfTypes") + encoder.WriteArraySize(uint32(len(o.ArrayOfTypes))) + for _, v := range o.ArrayOfTypes { + v.Encode(encoder) + } + encoder.WriteString("unionValue") + o.UnionValue.Encode(encoder) + encoder.WriteString("unionOption") + if o.UnionOption == nil { + encoder.WriteNil() + } else { + o.UnionOption.Encode(encoder) + } + encoder.WriteString("enumValue") + encoder.WriteInt32(int32(o.EnumValue)) + encoder.WriteString("enumOption") + encoder.WriteNillableInt32((*int32)(o.EnumOption)) + encoder.WriteString("aliasValue") + encoder.WriteString(o.AliasValue.String()) + encoder.WriteString("aliasOption") + if o.AliasOption == nil { + encoder.WriteNil() + } else { + encoder.WriteString(o.AliasOption.String()) + } + + return nil +} + +func (o *MyOtherType) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "foo": + o.Foo, err = decoder.ReadString() + case "bar": + o.Bar, err = decoder.ReadString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyOtherType) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + encoder.WriteMapSize(2) + encoder.WriteString("foo") + encoder.WriteString(o.Foo) + encoder.WriteString("bar") + encoder.WriteString(o.Bar) + + return nil +} + +func (o *MyUnion) Decode(decoder msgpack.Reader) error { + numFields, err := decoder.ReadMapSize() + if err != nil { + return err + } + + for numFields > 0 { + numFields-- + field, err := decoder.ReadString() + if err != nil { + return err + } + switch field { + case "MyType": + o.MyType, err = msgpack.DecodeNillable[MyType](decoder) + case "MyEnum": + o.MyEnum, err = convert.NillableNumeric[MyEnum](decoder.ReadNillableInt32()) + case "string": + o.String, err = decoder.ReadNillableString() + default: + err = decoder.Skip() + } + if err != nil { + return err + } + } + + return nil +} + +func (o *MyUnion) Encode(encoder msgpack.Writer) error { + if o == nil { + encoder.WriteNil() + return nil + } + if o.MyType != nil { + encoder.WriteMapSize(1) + encoder.WriteString("MyType") + o.MyType.Encode(encoder) + return nil + } + if o.MyEnum != nil { + encoder.WriteMapSize(1) + encoder.WriteString("MyEnum") + encoder.WriteNillableInt32((*int32)(o.MyEnum)) + return nil + } + if o.String != nil { + encoder.WriteMapSize(1) + encoder.WriteString("string") + encoder.WriteNillableString(o.String) + return nil + } + + encoder.WriteNil() + return nil +} + +func RegisterMyStreamer(svc MyStreamer) { + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamI64", myStreamerRequestStreamI64Wrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamF64", myStreamerRequestStreamF64Wrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamType", myStreamerRequestStreamTypeWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamEnum", myStreamerRequestStreamEnumWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamUUID", myStreamerRequestStreamUUIDWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamAlias", myStreamerRequestStreamAliasWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamString", myStreamerRequestStreamStringWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamBool", myStreamerRequestStreamBoolWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamDatetime", myStreamerRequestStreamDatetimeWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamList", myStreamerRequestStreamListWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamMap", myStreamerRequestStreamMapWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsI64", myStreamerRequestStreamArgsI64Wrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsF64", myStreamerRequestStreamArgsF64Wrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsType", myStreamerRequestStreamArgsTypeWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsEnum", myStreamerRequestStreamArgsEnumWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsUUID", myStreamerRequestStreamArgsUUIDWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsAlias", myStreamerRequestStreamArgsAliasWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsString", myStreamerRequestStreamArgsStringWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsBool", myStreamerRequestStreamArgsBoolWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsDatetime", myStreamerRequestStreamArgsDatetimeWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsList", myStreamerRequestStreamArgsListWrapper(svc)) + invoke.ExportRequestStream("iota.testing.MyStreamer", "requestStreamArgsMap", myStreamerRequestStreamArgsMapWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelVoid", myStreamerRequestChannelVoidWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelSingle", myStreamerRequestChannelSingleWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelI64", myStreamerRequestChannelI64Wrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelF64", myStreamerRequestChannelF64Wrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelType", myStreamerRequestChannelTypeWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelEnum", myStreamerRequestChannelEnumWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelAlias", myStreamerRequestChannelAliasWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelString", myStreamerRequestChannelStringWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelBool", myStreamerRequestChannelBoolWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelDatetime", myStreamerRequestChannelDatetimeWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelList", myStreamerRequestChannelListWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelMap", myStreamerRequestChannelMapWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsSingle", myStreamerRequestChannelArgsSingleWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsI64", myStreamerRequestChannelArgsI64Wrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsF64", myStreamerRequestChannelArgsF64Wrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsType", myStreamerRequestChannelArgsTypeWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsEnum", myStreamerRequestChannelArgsEnumWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsAlias", myStreamerRequestChannelArgsAliasWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsString", myStreamerRequestChannelArgsStringWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsBool", myStreamerRequestChannelArgsBoolWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsDatetime", myStreamerRequestChannelArgsDatetimeWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsList", myStreamerRequestChannelArgsListWrapper(svc)) + invoke.ExportRequestChannel("iota.testing.MyStreamer", "requestChannelArgsMap", myStreamerRequestChannelArgsMapWrapper(svc)) +} + +func RegisterMyService(svc MyService) { + invoke.ExportRequestResponse("iota.testing.MyService", "emptyVoid", myServiceEmptyVoidWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryType", myServiceUnaryTypeWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryEnum", myServiceUnaryEnumWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryUUID", myServiceUnaryUUIDWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryAlias", myServiceUnaryAliasWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryString", myServiceUnaryStringWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryI64", myServiceUnaryI64Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryI32", myServiceUnaryI32Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryI16", myServiceUnaryI16Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryI8", myServiceUnaryI8Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryU64", myServiceUnaryU64Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryU32", myServiceUnaryU32Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryU16", myServiceUnaryU16Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryU8", myServiceUnaryU8Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryF64", myServiceUnaryF64Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryF32", myServiceUnaryF32Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryBytes", myServiceUnaryBytesWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryDatetime", myServiceUnaryDatetimeWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryList", myServiceUnaryListWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "unaryMap", myServiceUnaryMapWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcType", myServiceFuncTypeWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcEnum", myServiceFuncEnumWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcUUID", myServiceFuncUUIDWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcAlias", myServiceFuncAliasWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcString", myServiceFuncStringWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcI64", myServiceFuncI64Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcI32", myServiceFuncI32Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcI16", myServiceFuncI16Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcI8", myServiceFuncI8Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcU64", myServiceFuncU64Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcU32", myServiceFuncU32Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcU16", myServiceFuncU16Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcU8", myServiceFuncU8Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcF64", myServiceFuncF64Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcF32", myServiceFuncF32Wrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcBytes", myServiceFuncBytesWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcDatetime", myServiceFuncDatetimeWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcList", myServiceFuncListWrapper(svc)) + invoke.ExportRequestResponse("iota.testing.MyService", "funcMap", myServiceFuncMapWrapper(svc)) +} + +func RegisterSomeCalc(handler SomeCalcFn) { + invoke.ExportRequestResponse("iota.testing", "someCalc", someCalcWrapper(handler)) +} + +func someCalcWrapper(handler SomeCalcFn) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultSomeCalcArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := handler(ctx, inputArgs.Rhs, inputArgs.Lhs) + return mono.Map(response, transform.Int64.Encode) + } +} + +func myStreamerRequestStreamI64Wrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamI64(ctx) + return flux.Map(response, transform.Int64.Encode) + } +} + +func myStreamerRequestStreamF64Wrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamF64(ctx) + return flux.Map(response, transform.Float64.Encode) + } +} + +func myStreamerRequestStreamTypeWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamType(ctx) + return flux.Map(response, transform.MsgPackEncode[MyType]) + } +} + +func myStreamerRequestStreamEnumWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamEnum(ctx) + return flux.Map(response, transform.Int32Encode[MyEnum]) + } +} + +func myStreamerRequestStreamUUIDWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamUUID(ctx) + return flux.Map(response, transform.ToStringEncode( + func(v uuid.UUID) string { return v.String() })) + } +} + +func myStreamerRequestStreamAliasWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamAlias(ctx) + return flux.Map(response, transform.StringEncode[MyAlias]) + } +} + +func myStreamerRequestStreamStringWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamString(ctx) + return flux.Map(response, transform.String.Encode) + } +} + +func myStreamerRequestStreamBoolWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamBool(ctx) + return flux.Map(response, transform.Bool.Encode) + } +} + +func myStreamerRequestStreamDatetimeWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamDatetime(ctx) + return flux.Map(response, transform.Time.Encode) + } +} + +func myStreamerRequestStreamListWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamList(ctx) + return flux.Map(response, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myStreamerRequestStreamMapWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + response := svc.RequestStreamMap(ctx) + return flux.Map(response, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myStreamerRequestStreamArgsI64Wrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsI64Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsI64(ctx, inputArgs.Value) + return flux.Map(response, transform.Int64.Encode) + } +} + +func myStreamerRequestStreamArgsF64Wrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsF64Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsF64(ctx, inputArgs.Value) + return flux.Map(response, transform.Float64.Encode) + } +} + +func myStreamerRequestStreamArgsTypeWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsTypeArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsType(ctx, &inputArgs.Value) + return flux.Map(response, transform.MsgPackEncode[MyType]) + } +} + +func myStreamerRequestStreamArgsEnumWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsEnumArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsEnum(ctx, inputArgs.Value) + return flux.Map(response, transform.Int32Encode[MyEnum]) + } +} + +func myStreamerRequestStreamArgsUUIDWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsUUIDArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsUUID(ctx, inputArgs.Value) + return flux.Map(response, transform.ToStringEncode( + func(v uuid.UUID) string { return v.String() })) + } +} + +func myStreamerRequestStreamArgsAliasWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsAliasArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsAlias(ctx, inputArgs.Value) + return flux.Map(response, transform.StringEncode[MyAlias]) + } +} + +func myStreamerRequestStreamArgsStringWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsStringArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsString(ctx, inputArgs.Value) + return flux.Map(response, transform.String.Encode) + } +} + +func myStreamerRequestStreamArgsBoolWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsBoolArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsBool(ctx, inputArgs.Value) + return flux.Map(response, transform.Bool.Encode) + } +} + +func myStreamerRequestStreamArgsDatetimeWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsDatetimeArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsDatetime(ctx, inputArgs.Value) + return flux.Map(response, transform.Time.Encode) + } +} + +func myStreamerRequestStreamArgsListWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsListArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsList(ctx, inputArgs.Value) + return flux.Map(response, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myStreamerRequestStreamArgsMapWrapper(svc MyStreamer) invoke.RequestStreamHandler { + return func(ctx context.Context, p payload.Payload) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestStreamArgsMapArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestStreamArgsMap(ctx, inputArgs.Value) + return flux.Map(response, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myStreamerRequestChannelVoidWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + responseStream := svc.RequestChannelVoid(ctx, flux.Map(in, transform.Int64.Decode)) + response := transform.MonoToFlux(responseStream) + return flux.Map(response, transform.Void.Encode) + } +} + +func myStreamerRequestChannelSingleWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + responseStream := svc.RequestChannelSingle(ctx, flux.Map(in, transform.Int64.Decode)) + response := transform.MonoToFlux(responseStream) + return flux.Map(response, transform.Int64.Encode) + } +} + +func myStreamerRequestChannelI64Wrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelI64(ctx, flux.Map(in, transform.Int64.Decode)) + return flux.Map(response, transform.Int64.Encode) + } +} + +func myStreamerRequestChannelF64Wrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelF64(ctx, flux.Map(in, transform.Float64.Decode)) + return flux.Map(response, transform.Float64.Encode) + } +} + +func myStreamerRequestChannelTypeWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelType(ctx, flux.Map(in, transform.MsgPackDecode[MyType])) + return flux.Map(response, transform.MsgPackEncode[MyType]) + } +} + +func myStreamerRequestChannelEnumWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelEnum(ctx, flux.Map(in, transform.Int32Decode[MyEnum])) + return flux.Map(response, transform.Int32Encode[MyEnum]) + } +} + +func myStreamerRequestChannelAliasWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelAlias(ctx, flux.Map(in, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + }))) + return flux.Map(response, transform.ToStringEncode( + func(v uuid.UUID) string { return v.String() })) + } +} + +func myStreamerRequestChannelStringWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelString(ctx, flux.Map(in, transform.String.Decode)) + return flux.Map(response, transform.String.Encode) + } +} + +func myStreamerRequestChannelBoolWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelBool(ctx, flux.Map(in, transform.Bool.Decode)) + return flux.Map(response, transform.Bool.Encode) + } +} + +func myStreamerRequestChannelDatetimeWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelDatetime(ctx, flux.Map(in, transform.Time.Decode)) + return flux.Map(response, transform.Time.Encode) + } +} + +func myStreamerRequestChannelListWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelList(ctx, flux.Map(in, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }))) + return flux.Map(response, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myStreamerRequestChannelMapWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + response := svc.RequestChannelMap(ctx, flux.Map(in, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }))) + return flux.Map(response, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myStreamerRequestChannelArgsSingleWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsSingleArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + responseStream := svc.RequestChannelArgsSingle(ctx, inputArgs.Value, flux.Map(in, transform.Int64.Decode)) + response := transform.MonoToFlux(responseStream) + return flux.Map(response, transform.Int64.Encode) + } +} + +func myStreamerRequestChannelArgsI64Wrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsI64Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsI64(ctx, inputArgs.Value, flux.Map(in, transform.Int64.Decode)) + return flux.Map(response, transform.Int64.Encode) + } +} + +func myStreamerRequestChannelArgsF64Wrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsF64Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsF64(ctx, inputArgs.Value, flux.Map(in, transform.Float64.Decode)) + return flux.Map(response, transform.Float64.Encode) + } +} + +func myStreamerRequestChannelArgsTypeWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsTypeArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsType(ctx, &inputArgs.Value, flux.Map(in, transform.MsgPackDecode[MyType])) + return flux.Map(response, transform.MsgPackEncode[MyType]) + } +} + +func myStreamerRequestChannelArgsEnumWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsEnumArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsEnum(ctx, inputArgs.Value, flux.Map(in, transform.Int32Decode[MyEnum])) + return flux.Map(response, transform.Int32Encode[MyEnum]) + } +} + +func myStreamerRequestChannelArgsAliasWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsAliasArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsAlias(ctx, inputArgs.Value, flux.Map(in, transform.ToStringDecode(func(val string) (uuid.UUID, error) { + return uuid.Parse(val) + }))) + return flux.Map(response, transform.ToStringEncode( + func(v uuid.UUID) string { return v.String() })) + } +} + +func myStreamerRequestChannelArgsStringWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsStringArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsString(ctx, inputArgs.Value, flux.Map(in, transform.String.Decode)) + return flux.Map(response, transform.String.Encode) + } +} + +func myStreamerRequestChannelArgsBoolWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsBoolArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsBool(ctx, inputArgs.Value, flux.Map(in, transform.Bool.Decode)) + return flux.Map(response, transform.Bool.Encode) + } +} + +func myStreamerRequestChannelArgsDatetimeWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsDatetimeArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsDatetime(ctx, inputArgs.Value, flux.Map(in, transform.Time.Decode)) + return flux.Map(response, transform.Time.Encode) + } +} + +func myStreamerRequestChannelArgsListWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsListArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsList(ctx, inputArgs.Value, flux.Map(in, transform.SliceDecode(func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }))) + return flux.Map(response, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myStreamerRequestChannelArgsMapWrapper(svc MyStreamer) invoke.RequestChannelHandler { + return func(ctx context.Context, p payload.Payload, in flux.Flux[payload.Payload]) flux.Flux[payload.Payload] { + inputArgs := DefaultMyStreamerRequestChannelArgsMapArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return flux.Error[payload.Payload](err) + } + response := svc.RequestChannelArgsMap(ctx, inputArgs.Value, flux.Map(in, transform.MapDecode( + func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }))) + return flux.Map(response, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myServiceEmptyVoidWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + response := svc.EmptyVoid(ctx) + return mono.Map(response, transform.Void.Encode) + } +} + +func myServiceUnaryTypeWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + var request MyType + if err := transform.CodecDecode(p, &request); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryType(ctx, &request) + return mono.Map(response, transform.MsgPackEncode[MyType]) + } +} + +func myServiceUnaryEnumWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + enumVal, err := transform.Int32.Decode(p) + if err != nil { + return mono.Error[payload.Payload](err) + } + request := MyEnum(enumVal) + response := svc.UnaryEnum(ctx, request) + return mono.Map(response, transform.Int32Encode[MyEnum]) + } +} + +func myServiceUnaryUUIDWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + aliasVal, err := transform.String.Decode(p) + if err != nil { + return mono.Error[payload.Payload](err) + } + request, err := uuid.Parse(aliasVal) + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryUUID(ctx, request) + return mono.Map(response, transform.ToStringEncode( + func(v uuid.UUID) string { return v.String() })) + } +} + +func myServiceUnaryAliasWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + aliasVal, err := transform.String.Decode(p) + if err != nil { + return mono.Error[payload.Payload](err) + } + request := MyAlias(aliasVal) + response := svc.UnaryAlias(ctx, request) + return mono.Map(response, transform.StringEncode[MyAlias]) + } +} + +func myServiceUnaryStringWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadString() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryString(ctx, request) + return mono.Map(response, transform.String.Encode) + } +} + +func myServiceUnaryI64Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadInt64() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryI64(ctx, request) + return mono.Map(response, transform.Int64.Encode) + } +} + +func myServiceUnaryI32Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadInt32() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryI32(ctx, request) + return mono.Map(response, transform.Int32.Encode) + } +} + +func myServiceUnaryI16Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadInt16() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryI16(ctx, request) + return mono.Map(response, transform.Int16.Encode) + } +} + +func myServiceUnaryI8Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadInt8() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryI8(ctx, request) + return mono.Map(response, transform.Int8.Encode) + } +} + +func myServiceUnaryU64Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadUint64() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryU64(ctx, request) + return mono.Map(response, transform.Uint64.Encode) + } +} + +func myServiceUnaryU32Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadUint32() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryU32(ctx, request) + return mono.Map(response, transform.Uint32.Encode) + } +} + +func myServiceUnaryU16Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadUint16() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryU16(ctx, request) + return mono.Map(response, transform.Uint16.Encode) + } +} + +func myServiceUnaryU8Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadUint8() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryU8(ctx, request) + return mono.Map(response, transform.Uint8.Encode) + } +} + +func myServiceUnaryF64Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadFloat64() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryF64(ctx, request) + return mono.Map(response, transform.Float64.Encode) + } +} + +func myServiceUnaryF32Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadFloat32() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryF32(ctx, request) + return mono.Map(response, transform.Float32.Encode) + } +} + +func myServiceUnaryBytesWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadByteArray() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryBytes(ctx, request) + return mono.Map(response, transform.Bytes.Encode) + } +} + +func myServiceUnaryDatetimeWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := decoder.ReadTime() + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryDatetime(ctx, request) + return mono.Map(response, transform.Time.Encode) + } +} + +func myServiceUnaryListWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := msgpack.ReadSlice(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryList(ctx, request) + return mono.Map(response, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myServiceUnaryMapWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + d := msgpack.NewDecoder(p.Data()) + decoder := &d + request, err := msgpack.ReadMap(decoder, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }, func(decoder msgpack.Reader) (string, error) { + return decoder.ReadString() + }) + if err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.UnaryMap(ctx, request) + return mono.Map(response, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myServiceFuncTypeWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncTypeArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncType(ctx, &inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.MsgPackEncode[MyType]) + } +} + +func myServiceFuncEnumWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncEnumArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncEnum(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Int32Encode[MyEnum]) + } +} + +func myServiceFuncUUIDWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncUUIDArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncUUID(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.ToStringEncode( + func(v uuid.UUID) string { return v.String() })) + } +} + +func myServiceFuncAliasWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncAliasArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncAlias(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.StringEncode[MyAlias]) + } +} + +func myServiceFuncStringWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncStringArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncString(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.String.Encode) + } +} + +func myServiceFuncI64Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncI64Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncI64(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Int64.Encode) + } +} + +func myServiceFuncI32Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncI32Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncI32(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Int32.Encode) + } +} + +func myServiceFuncI16Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncI16Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncI16(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Int16.Encode) + } +} + +func myServiceFuncI8Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncI8Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncI8(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Int8.Encode) + } +} + +func myServiceFuncU64Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncU64Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncU64(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Uint64.Encode) + } +} + +func myServiceFuncU32Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncU32Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncU32(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Uint32.Encode) + } +} + +func myServiceFuncU16Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncU16Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncU16(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Uint16.Encode) + } +} + +func myServiceFuncU8Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncU8Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncU8(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Uint8.Encode) + } +} + +func myServiceFuncF64Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncF64Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncF64(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Float64.Encode) + } +} + +func myServiceFuncF32Wrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncF32Args() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncF32(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Float32.Encode) + } +} + +func myServiceFuncBytesWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncBytesArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncBytes(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Bytes.Encode) + } +} + +func myServiceFuncDatetimeWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncDatetimeArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncDatetime(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.Time.Encode) + } +} + +func myServiceFuncListWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncListArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncList(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.SliceEncode(func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +func myServiceFuncMapWrapper(svc MyService) invoke.RequestResponseHandler { + return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { + inputArgs := DefaultMyServiceFuncMapArgs() + if err := transform.CodecDecode(p, &inputArgs); err != nil { + return mono.Error[payload.Payload](err) + } + response := svc.FuncMap(ctx, inputArgs.Value, inputArgs.Optional) + return mono.Map(response, transform.MapEncode(func(writer msgpack.Writer, key string) { + writer.WriteString(key) + }, func(writer msgpack.Writer, val string) { + writer.WriteString(val) + })) + } +} + +type Dependencies struct { + Repository Repository +} + +type Client struct { + caller invoke.Caller + _opRepositoryGetData uint32 +} + +func New(caller invoke.Caller) *Client { + return &Client{ + caller: caller, + _opRepositoryGetData: invoke.ImportRequestResponse("iota.testing.Repository", "getData"), + } +} +func (c *Client) Dependencies() Dependencies { + return Dependencies{ + Repository: c.Repository(), + } +} + +func GetDependencies(caller invoke.Caller) Dependencies { + c := New(caller) + return c.Dependencies() +} + +type RepositoryClient struct { + c *Client + instanceID uint64 +} + +func (c *Client) Repository() Repository { + return &RepositoryClient{ + c: c, + } +} + +func (r *RepositoryClient) GetData(ctx context.Context) mono.Mono[MyType] { + payloadData := []byte{} + var metadata [16]byte + stream, ok := proxy.FromContext(ctx) + binary.BigEndian.PutUint32(metadata[0:4], r.c._opRepositoryGetData) + if ok { + binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) + } + pl := payload.New(payloadData, metadata[:]) + future := r.c.caller.RequestResponse(ctx, pl) + return mono.Map(future, transform.MsgPackDecode[MyType]) +} diff --git a/codegen/testdata/tinygo/expected/pkg/iotatest/services.go b/codegen/testdata/tinygo/expected/pkg/iotatest/services.go new file mode 100644 index 0000000..1dd576b --- /dev/null +++ b/codegen/testdata/tinygo/expected/pkg/iotatest/services.go @@ -0,0 +1,453 @@ +package iotatest + +import ( + "context" + "errors" + "time" + + "github.com/google/uuid" + "github.com/nanobus/iota/go/rx/flux" + "github.com/nanobus/iota/go/rx/mono" +) + +func SomeCalc(ctx context.Context, rhs int64, lhs int64) mono.Mono[int64] { + // TODO: Provide implementation. + return mono.Error[int64](errors.New("not_implemented")) +} + +type MyStreamerImpl struct { +} + +func NewMyStreamer(deps Dependencies) *MyStreamerImpl { + return &MyStreamerImpl{} +} + +func (m *MyStreamerImpl) RequestStreamI64(ctx context.Context) flux.Flux[int64] { + // TODO: Provide implementation. + return flux.Error[int64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamF64(ctx context.Context) flux.Flux[float64] { + // TODO: Provide implementation. + return flux.Error[float64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamType(ctx context.Context) flux.Flux[MyType] { + // TODO: Provide implementation. + return flux.Error[MyType](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamEnum(ctx context.Context) flux.Flux[MyEnum] { + // TODO: Provide implementation. + return flux.Error[MyEnum](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamUUID(ctx context.Context) flux.Flux[uuid.UUID] { + // TODO: Provide implementation. + return flux.Error[uuid.UUID](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamAlias(ctx context.Context) flux.Flux[MyAlias] { + // TODO: Provide implementation. + return flux.Error[MyAlias](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamString(ctx context.Context) flux.Flux[string] { + // TODO: Provide implementation. + return flux.Error[string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamBool(ctx context.Context) flux.Flux[bool] { + // TODO: Provide implementation. + return flux.Error[bool](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamDatetime(ctx context.Context) flux.Flux[time.Time] { + // TODO: Provide implementation. + return flux.Error[time.Time](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamList(ctx context.Context) flux.Flux[[]string] { + // TODO: Provide implementation. + return flux.Error[[]string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamMap(ctx context.Context) flux.Flux[map[string]string] { + // TODO: Provide implementation. + return flux.Error[map[string]string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsI64(ctx context.Context, value int64) flux.Flux[int64] { + // TODO: Provide implementation. + return flux.Error[int64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsF64(ctx context.Context, value float64) flux.Flux[float64] { + // TODO: Provide implementation. + return flux.Error[float64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsType(ctx context.Context, value *MyType) flux.Flux[MyType] { + // TODO: Provide implementation. + return flux.Error[MyType](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsEnum(ctx context.Context, value MyEnum) flux.Flux[MyEnum] { + // TODO: Provide implementation. + return flux.Error[MyEnum](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsUUID(ctx context.Context, value uuid.UUID) flux.Flux[uuid.UUID] { + // TODO: Provide implementation. + return flux.Error[uuid.UUID](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsAlias(ctx context.Context, value MyAlias) flux.Flux[MyAlias] { + // TODO: Provide implementation. + return flux.Error[MyAlias](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsString(ctx context.Context, value string) flux.Flux[string] { + // TODO: Provide implementation. + return flux.Error[string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsBool(ctx context.Context, value bool) flux.Flux[bool] { + // TODO: Provide implementation. + return flux.Error[bool](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsDatetime(ctx context.Context, value time.Time) flux.Flux[time.Time] { + // TODO: Provide implementation. + return flux.Error[time.Time](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsList(ctx context.Context, value []string) flux.Flux[[]string] { + // TODO: Provide implementation. + return flux.Error[[]string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestStreamArgsMap(ctx context.Context, value map[string]string) flux.Flux[map[string]string] { + // TODO: Provide implementation. + return flux.Error[map[string]string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelVoid(ctx context.Context, in flux.Flux[int64]) mono.Void { + // TODO: Provide implementation. + return mono.Error[struct{}](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelSingle(ctx context.Context, in flux.Flux[int64]) mono.Mono[int64] { + // TODO: Provide implementation. + return mono.Error[int64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelI64(ctx context.Context, in flux.Flux[int64]) flux.Flux[int64] { + // TODO: Provide implementation. + return flux.Error[int64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelF64(ctx context.Context, in flux.Flux[float64]) flux.Flux[float64] { + // TODO: Provide implementation. + return flux.Error[float64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelType(ctx context.Context, in flux.Flux[MyType]) flux.Flux[MyType] { + // TODO: Provide implementation. + return flux.Error[MyType](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelEnum(ctx context.Context, in flux.Flux[MyEnum]) flux.Flux[MyEnum] { + // TODO: Provide implementation. + return flux.Error[MyEnum](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelAlias(ctx context.Context, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] { + // TODO: Provide implementation. + return flux.Error[uuid.UUID](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelString(ctx context.Context, in flux.Flux[string]) flux.Flux[string] { + // TODO: Provide implementation. + return flux.Error[string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelBool(ctx context.Context, in flux.Flux[bool]) flux.Flux[bool] { + // TODO: Provide implementation. + return flux.Error[bool](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelDatetime(ctx context.Context, in flux.Flux[time.Time]) flux.Flux[time.Time] { + // TODO: Provide implementation. + return flux.Error[time.Time](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelList(ctx context.Context, in flux.Flux[[]string]) flux.Flux[[]string] { + // TODO: Provide implementation. + return flux.Error[[]string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelMap(ctx context.Context, in flux.Flux[map[string]string]) flux.Flux[map[string]string] { + // TODO: Provide implementation. + return flux.Error[map[string]string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsSingle(ctx context.Context, value int64, in flux.Flux[int64]) mono.Mono[int64] { + // TODO: Provide implementation. + return mono.Error[int64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsI64(ctx context.Context, value int64, in flux.Flux[int64]) flux.Flux[int64] { + // TODO: Provide implementation. + return flux.Error[int64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsF64(ctx context.Context, value float64, in flux.Flux[float64]) flux.Flux[float64] { + // TODO: Provide implementation. + return flux.Error[float64](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsType(ctx context.Context, value *MyType, in flux.Flux[MyType]) flux.Flux[MyType] { + // TODO: Provide implementation. + return flux.Error[MyType](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsEnum(ctx context.Context, value MyEnum, in flux.Flux[MyEnum]) flux.Flux[MyEnum] { + // TODO: Provide implementation. + return flux.Error[MyEnum](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsAlias(ctx context.Context, value uuid.UUID, in flux.Flux[uuid.UUID]) flux.Flux[uuid.UUID] { + // TODO: Provide implementation. + return flux.Error[uuid.UUID](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsString(ctx context.Context, value string, in flux.Flux[string]) flux.Flux[string] { + // TODO: Provide implementation. + return flux.Error[string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsBool(ctx context.Context, value bool, in flux.Flux[bool]) flux.Flux[bool] { + // TODO: Provide implementation. + return flux.Error[bool](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsDatetime(ctx context.Context, value time.Time, in flux.Flux[time.Time]) flux.Flux[time.Time] { + // TODO: Provide implementation. + return flux.Error[time.Time](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsList(ctx context.Context, value []string, in flux.Flux[[]string]) flux.Flux[[]string] { + // TODO: Provide implementation. + return flux.Error[[]string](errors.New("not_implemented")) +} + +func (m *MyStreamerImpl) RequestChannelArgsMap(ctx context.Context, value map[string]string, in flux.Flux[map[string]string]) flux.Flux[map[string]string] { + // TODO: Provide implementation. + return flux.Error[map[string]string](errors.New("not_implemented")) +} + +type MyServiceImpl struct { + repository Repository +} + +func NewMyService(deps Dependencies) *MyServiceImpl { + return &MyServiceImpl{ + repository: deps.Repository, + } +} + +func (m *MyServiceImpl) EmptyVoid(ctx context.Context) mono.Void { + // TODO: Provide implementation. + return mono.Error[struct{}](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryType(ctx context.Context, value *MyType) mono.Mono[MyType] { + // TODO: Provide implementation. + return mono.Error[MyType](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryEnum(ctx context.Context, value MyEnum) mono.Mono[MyEnum] { + // TODO: Provide implementation. + return mono.Error[MyEnum](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryUUID(ctx context.Context, value uuid.UUID) mono.Mono[uuid.UUID] { + // TODO: Provide implementation. + return mono.Error[uuid.UUID](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryAlias(ctx context.Context, value MyAlias) mono.Mono[MyAlias] { + // TODO: Provide implementation. + return mono.Error[MyAlias](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryString(ctx context.Context, value string) mono.Mono[string] { + // TODO: Provide implementation. + return mono.Error[string](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryI64(ctx context.Context, value int64) mono.Mono[int64] { + // TODO: Provide implementation. + return mono.Error[int64](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryI32(ctx context.Context, value int32) mono.Mono[int32] { + // TODO: Provide implementation. + return mono.Error[int32](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryI16(ctx context.Context, value int16) mono.Mono[int16] { + // TODO: Provide implementation. + return mono.Error[int16](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryI8(ctx context.Context, value int8) mono.Mono[int8] { + // TODO: Provide implementation. + return mono.Error[int8](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryU64(ctx context.Context, value uint64) mono.Mono[uint64] { + // TODO: Provide implementation. + return mono.Error[uint64](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryU32(ctx context.Context, value uint32) mono.Mono[uint32] { + // TODO: Provide implementation. + return mono.Error[uint32](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryU16(ctx context.Context, value uint16) mono.Mono[uint16] { + // TODO: Provide implementation. + return mono.Error[uint16](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryU8(ctx context.Context, value uint8) mono.Mono[uint8] { + // TODO: Provide implementation. + return mono.Error[uint8](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryF64(ctx context.Context, value float64) mono.Mono[float64] { + // TODO: Provide implementation. + return mono.Error[float64](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryF32(ctx context.Context, value float32) mono.Mono[float32] { + // TODO: Provide implementation. + return mono.Error[float32](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryBytes(ctx context.Context, value []byte) mono.Mono[[]byte] { + // TODO: Provide implementation. + return mono.Error[[]byte](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryDatetime(ctx context.Context, value time.Time) mono.Mono[time.Time] { + // TODO: Provide implementation. + return mono.Error[time.Time](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryList(ctx context.Context, value []string) mono.Mono[[]string] { + // TODO: Provide implementation. + return mono.Error[[]string](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) UnaryMap(ctx context.Context, value map[string]string) mono.Mono[map[string]string] { + // TODO: Provide implementation. + return mono.Error[map[string]string](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncType(ctx context.Context, value *MyType, optional *MyType) mono.Mono[MyType] { + // TODO: Provide implementation. + return mono.Error[MyType](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncEnum(ctx context.Context, value MyEnum, optional *MyEnum) mono.Mono[MyEnum] { + // TODO: Provide implementation. + return mono.Error[MyEnum](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncUUID(ctx context.Context, value uuid.UUID, optional *uuid.UUID) mono.Mono[uuid.UUID] { + // TODO: Provide implementation. + return mono.Error[uuid.UUID](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncAlias(ctx context.Context, value MyAlias, optional *MyAlias) mono.Mono[MyAlias] { + // TODO: Provide implementation. + return mono.Error[MyAlias](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncString(ctx context.Context, value string, optional *string) mono.Mono[string] { + // TODO: Provide implementation. + return mono.Error[string](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncI64(ctx context.Context, value int64, optional *int64) mono.Mono[int64] { + // TODO: Provide implementation. + return mono.Error[int64](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncI32(ctx context.Context, value int32, optional *int32) mono.Mono[int32] { + // TODO: Provide implementation. + return mono.Error[int32](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncI16(ctx context.Context, value int16, optional *int16) mono.Mono[int16] { + // TODO: Provide implementation. + return mono.Error[int16](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncI8(ctx context.Context, value int8, optional *int8) mono.Mono[int8] { + // TODO: Provide implementation. + return mono.Error[int8](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncU64(ctx context.Context, value uint64, optional *uint64) mono.Mono[uint64] { + // TODO: Provide implementation. + return mono.Error[uint64](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncU32(ctx context.Context, value uint32, optional *uint32) mono.Mono[uint32] { + // TODO: Provide implementation. + return mono.Error[uint32](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncU16(ctx context.Context, value uint16, optional *uint16) mono.Mono[uint16] { + // TODO: Provide implementation. + return mono.Error[uint16](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncU8(ctx context.Context, value uint8, optional *uint8) mono.Mono[uint8] { + // TODO: Provide implementation. + return mono.Error[uint8](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncF64(ctx context.Context, value float64, optional *float64) mono.Mono[float64] { + // TODO: Provide implementation. + return mono.Error[float64](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncF32(ctx context.Context, value float32, optional *float32) mono.Mono[float32] { + // TODO: Provide implementation. + return mono.Error[float32](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncBytes(ctx context.Context, value []byte, optional []byte) mono.Mono[[]byte] { + // TODO: Provide implementation. + return mono.Error[[]byte](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncDatetime(ctx context.Context, value time.Time, optional *time.Time) mono.Mono[time.Time] { + // TODO: Provide implementation. + return mono.Error[time.Time](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncList(ctx context.Context, value []string, optional []string) mono.Mono[[]string] { + // TODO: Provide implementation. + return mono.Error[[]string](errors.New("not_implemented")) +} + +func (m *MyServiceImpl) FuncMap(ctx context.Context, value map[string]string, optional map[string]string) mono.Mono[map[string]string] { + // TODO: Provide implementation. + return mono.Error[map[string]string](errors.New("not_implemented")) +} diff --git a/codegen/testdata/tinygo/expected/pkg/urlshortener/export.go b/codegen/testdata/tinygo/expected/pkg/urlshortener/export.go deleted file mode 100644 index a5f8850..0000000 --- a/codegen/testdata/tinygo/expected/pkg/urlshortener/export.go +++ /dev/null @@ -1,27 +0,0 @@ -// Code generated by @apexlang/codegen. DO NOT EDIT. - -package urlshortener - -import ( - "context" - - "github.com/nanobus/iota/go/invoke" - "github.com/nanobus/iota/go/payload" - "github.com/nanobus/iota/go/rx/mono" - "github.com/nanobus/iota/go/transform" -) - -func RegisterShortener(svc Shortener) { - invoke.ExportRequestResponse("urlshortener.v1.Shortener", "shorten", shortenerShortenWrapper(svc)) -} - -func shortenerShortenWrapper(svc Shortener) invoke.RequestResponseHandler { - return func(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { - var inputArgs ShortenerShortenArgs - if err := transform.CodecDecode(p, &inputArgs); err != nil { - return mono.Error[payload.Payload](err) - } - response := svc.Shorten(ctx, inputArgs.URL) - return mono.Map(response, transform.MsgPackEncode[URL]) - } -} diff --git a/codegen/testdata/tinygo/expected/pkg/urlshortener/interfaces.go b/codegen/testdata/tinygo/expected/pkg/urlshortener/interfaces.go deleted file mode 100644 index 87b6c1b..0000000 --- a/codegen/testdata/tinygo/expected/pkg/urlshortener/interfaces.go +++ /dev/null @@ -1,44 +0,0 @@ -// Code generated by @apexlang/codegen. DO NOT EDIT. - -package urlshortener - -import ( - "context" - - "github.com/nanobus/iota/go/rx/mono" -) - -type ns struct{} - -func (n *ns) Namespace() string { - return "urlshortener.v1" -} - -// The URL shortening service. -type Shortener interface { - // Shorten a URL and return a generated identifier. - Shorten(ctx context.Context, url string) mono.Mono[URL] -} - -// Repository handles loading and storing shortened URLs. -type Repository interface { - // Load the URL by its identifier. - LoadByID(ctx context.Context, id string) mono.Mono[URL] - // Load the ID by its URL. - LoadByURL(ctx context.Context, url string) mono.Mono[URL] - // Store a URL and its identifier. - StoreURL(ctx context.Context, url *URL) mono.Void -} - -// URL encapsulates the dynamic identifier and the URL it points to. -type URL struct { - ns - // The dynamically generated URL identifier. - ID string `json:"id" yaml:"id" msgpack:"id"` - // The original URL that was shortened. - URL string `json:"url" yaml:"url" msgpack:"url"` -} - -func (u *URL) Type() string { - return "URL" -} diff --git a/codegen/testdata/tinygo/expected/pkg/urlshortener/msgpack.go b/codegen/testdata/tinygo/expected/pkg/urlshortener/msgpack.go deleted file mode 100644 index 9404044..0000000 --- a/codegen/testdata/tinygo/expected/pkg/urlshortener/msgpack.go +++ /dev/null @@ -1,217 +0,0 @@ -// Code generated by @apexlang/codegen. DO NOT EDIT. - -package urlshortener - -import ( - "github.com/nanobus/iota/go/msgpack" -) - -type ShortenerShortenArgs struct { - URL string `json:"url" yaml:"url" msgpack:"url"` -} - -func (o *ShortenerShortenArgs) Decode(decoder msgpack.Reader) error { - numFields, err := decoder.ReadMapSize() - if err != nil { - return err - } - - for numFields > 0 { - numFields-- - field, err := decoder.ReadString() - if err != nil { - return err - } - switch field { - case "url": - o.URL, err = decoder.ReadString() - default: - err = decoder.Skip() - } - if err != nil { - return err - } - } - - return nil -} - -func (o *ShortenerShortenArgs) Encode(encoder msgpack.Writer) error { - if o == nil { - encoder.WriteNil() - return nil - } - encoder.WriteMapSize(1) - encoder.WriteString("url") - encoder.WriteString(o.URL) - - return nil -} - -type ShortenerLookupArgs struct { - ID string `json:"id" yaml:"id" msgpack:"id"` -} - -func (o *ShortenerLookupArgs) Decode(decoder msgpack.Reader) error { - numFields, err := decoder.ReadMapSize() - if err != nil { - return err - } - - for numFields > 0 { - numFields-- - field, err := decoder.ReadString() - if err != nil { - return err - } - switch field { - case "id": - o.ID, err = decoder.ReadString() - default: - err = decoder.Skip() - } - if err != nil { - return err - } - } - - return nil -} - -func (o *ShortenerLookupArgs) Encode(encoder msgpack.Writer) error { - if o == nil { - encoder.WriteNil() - return nil - } - encoder.WriteMapSize(1) - encoder.WriteString("id") - encoder.WriteString(o.ID) - - return nil -} - -type RepositoryLoadByIdArgs struct { - ID string `json:"id" yaml:"id" msgpack:"id"` -} - -func (o *RepositoryLoadByIdArgs) Decode(decoder msgpack.Reader) error { - numFields, err := decoder.ReadMapSize() - if err != nil { - return err - } - - for numFields > 0 { - numFields-- - field, err := decoder.ReadString() - if err != nil { - return err - } - switch field { - case "id": - o.ID, err = decoder.ReadString() - default: - err = decoder.Skip() - } - if err != nil { - return err - } - } - - return nil -} - -func (o *RepositoryLoadByIdArgs) Encode(encoder msgpack.Writer) error { - if o == nil { - encoder.WriteNil() - return nil - } - encoder.WriteMapSize(1) - encoder.WriteString("id") - encoder.WriteString(o.ID) - - return nil -} - -type RepositoryLoadByURLArgs struct { - URL string `json:"url" yaml:"url" msgpack:"url"` -} - -func (o *RepositoryLoadByURLArgs) Decode(decoder msgpack.Reader) error { - numFields, err := decoder.ReadMapSize() - if err != nil { - return err - } - - for numFields > 0 { - numFields-- - field, err := decoder.ReadString() - if err != nil { - return err - } - switch field { - case "url": - o.URL, err = decoder.ReadString() - default: - err = decoder.Skip() - } - if err != nil { - return err - } - } - - return nil -} - -func (o *RepositoryLoadByURLArgs) Encode(encoder msgpack.Writer) error { - if o == nil { - encoder.WriteNil() - return nil - } - encoder.WriteMapSize(1) - encoder.WriteString("url") - encoder.WriteString(o.URL) - - return nil -} - -func (o *URL) Decode(decoder msgpack.Reader) error { - numFields, err := decoder.ReadMapSize() - if err != nil { - return err - } - - for numFields > 0 { - numFields-- - field, err := decoder.ReadString() - if err != nil { - return err - } - switch field { - case "id": - o.ID, err = decoder.ReadString() - case "url": - o.URL, err = decoder.ReadString() - default: - err = decoder.Skip() - } - if err != nil { - return err - } - } - - return nil -} - -func (o *URL) Encode(encoder msgpack.Writer) error { - if o == nil { - encoder.WriteNil() - return nil - } - encoder.WriteMapSize(2) - encoder.WriteString("id") - encoder.WriteString(o.ID) - encoder.WriteString("url") - encoder.WriteString(o.URL) - - return nil -} diff --git a/codegen/testdata/tinygo/expected/pkg/urlshortener/providers.go b/codegen/testdata/tinygo/expected/pkg/urlshortener/providers.go deleted file mode 100644 index 9230b65..0000000 --- a/codegen/testdata/tinygo/expected/pkg/urlshortener/providers.go +++ /dev/null @@ -1,91 +0,0 @@ -// Code generated by @apexlang/codegen. DO NOT EDIT. - -package urlshortener - -import ( - "context" - "encoding/binary" - - "github.com/nanobus/iota/go/invoke" - "github.com/nanobus/iota/go/msgpack" - "github.com/nanobus/iota/go/payload" - "github.com/nanobus/iota/go/proxy" - "github.com/nanobus/iota/go/rx/mono" - "github.com/nanobus/iota/go/transform" -) - -var ( - gCaller invoke.Caller -) - -func Initialize(caller invoke.Caller) { - gCaller = caller -} - -type RepositoryImpl struct { - opLoadByID uint32 - opLoadByURL uint32 - opStoreURL uint32 -} - -func NewRepository() *RepositoryImpl { - return &RepositoryImpl{ - opLoadByID: invoke.ImportRequestResponse("urlshortener.v1.Repository", "loadById"), - opLoadByURL: invoke.ImportRequestResponse("urlshortener.v1.Repository", "loadByURL"), - opStoreURL: invoke.ImportRequestResponse("urlshortener.v1.Repository", "storeURL"), - } -} - -func (r *RepositoryImpl) LoadByID(ctx context.Context, id string) mono.Mono[URL] { - request := RepositoryLoadByIdArgs{ - ID: id, - } - payloadData, err := msgpack.ToBytes(&request) - if err != nil { - return mono.Error[URL](err) - } - var metadata [8]byte - stream, ok := proxy.FromContext(ctx) - binary.BigEndian.PutUint32(metadata[0:4], r.opLoadByID) - if ok { - binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) - } - pl := payload.New(payloadData, metadata[:]) - future := gCaller.RequestResponse(ctx, pl) - return mono.Map(future, transform.MsgPackDecode[URL]) -} - -func (r *RepositoryImpl) LoadByURL(ctx context.Context, url string) mono.Mono[URL] { - request := RepositoryLoadByURLArgs{ - URL: url, - } - payloadData, err := msgpack.ToBytes(&request) - if err != nil { - return mono.Error[URL](err) - } - var metadata [8]byte - stream, ok := proxy.FromContext(ctx) - binary.BigEndian.PutUint32(metadata[0:4], r.opLoadByURL) - if ok { - binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) - } - pl := payload.New(payloadData, metadata[:]) - future := gCaller.RequestResponse(ctx, pl) - return mono.Map(future, transform.MsgPackDecode[URL]) -} - -func (r *RepositoryImpl) StoreURL(ctx context.Context, url *URL) mono.Void { - payloadData, err := msgpack.ToBytes(url) - if err != nil { - return mono.Error[struct{}](err) - } - var metadata [8]byte - stream, ok := proxy.FromContext(ctx) - binary.BigEndian.PutUint32(metadata[0:4], r.opStoreURL) - if ok { - binary.BigEndian.PutUint32(metadata[4:8], stream.StreamID()) - } - pl := payload.New(payloadData, metadata[:]) - future := gCaller.RequestResponse(ctx, pl) - return mono.Map(future, transform.Void.Decode) -} diff --git a/codegen/testdata/tinygo/expected/pkg/urlshortener/services.go b/codegen/testdata/tinygo/expected/pkg/urlshortener/services.go deleted file mode 100644 index f13547a..0000000 --- a/codegen/testdata/tinygo/expected/pkg/urlshortener/services.go +++ /dev/null @@ -1,19 +0,0 @@ -package urlshortener - -import ( - "context" -) - -type ShortenerImpl struct { - repository Repository -} - -func NewShortener(repository Repository) *ShortenerImpl { - return &ShortenerImpl{ - repository: repository, - } -} - -func (s *ShortenerImpl) Shorten(ctx context.Context, url string) (*URL, error) { - return &URL{}, nil // TODO: Provide implementation. -} diff --git a/go/handler/caller.go b/go/handler/caller.go index ffe3524..7a2eb92 100644 --- a/go/handler/caller.go +++ b/go/handler/caller.go @@ -5,6 +5,7 @@ import ( "github.com/nanobus/iota/go/internal/frames" "github.com/nanobus/iota/go/invoke" + "github.com/nanobus/iota/go/operations" "github.com/nanobus/iota/go/payload" "github.com/nanobus/iota/go/proxy" "github.com/nanobus/iota/go/rx" @@ -15,19 +16,51 @@ import ( var _ = (invoke.Caller)((*Handler)(nil)) func (i *Handler) ImportRequestResponse(namespace, operation string) uint32 { - return invoke.ImportRequestResponse(namespace, operation) + for _, op := range i.opTable { + if op.Direction == operations.Export && + op.Type == operations.RequestResponse && + op.Namespace == namespace && + op.Operation == operation { + return op.Index + } + } + return 0 } func (i *Handler) ImportFireAndForget(namespace, operation string) uint32 { - return invoke.ImportFireAndForget(namespace, operation) + for _, op := range i.opTable { + if op.Direction == operations.Export && + op.Type == operations.FireAndForget && + op.Namespace == namespace && + op.Operation == operation { + return op.Index + } + } + return 0 } func (i *Handler) ImportRequestStream(namespace, operation string) uint32 { - return invoke.ImportRequestStream(namespace, operation) + for _, op := range i.opTable { + if op.Direction == operations.Export && + op.Type == operations.RequestStream && + op.Namespace == namespace && + op.Operation == operation { + return op.Index + } + } + return 0 } func (i *Handler) ImportRequestChannel(namespace, operation string) uint32 { - return invoke.ImportRequestChannel(namespace, operation) + for _, op := range i.opTable { + if op.Direction == operations.Export && + op.Type == operations.RequestChannel && + op.Namespace == namespace && + op.Operation == operation { + return op.Index + } + } + return 0 } func (i *Handler) RequestResponse(ctx context.Context, p payload.Payload) mono.Mono[payload.Payload] { diff --git a/go/handler/handler.go b/go/handler/handler.go index d0ed8ea..73cb055 100644 --- a/go/handler/handler.go +++ b/go/handler/handler.go @@ -9,6 +9,7 @@ import ( "github.com/nanobus/iota/go/internal/frames" "github.com/nanobus/iota/go/internal/socket" "github.com/nanobus/iota/go/invoke" + "github.com/nanobus/iota/go/operations" "github.com/nanobus/iota/go/payload" "github.com/nanobus/iota/go/proxy" "github.com/nanobus/iota/go/rx" @@ -39,6 +40,8 @@ type Handler struct { importedRFNF []invoke.FireAndForgetHandler importedRS []invoke.RequestStreamHandler importedRC []invoke.RequestChannelHandler + + opTable operations.Table } // type fragmentedPayload struct { @@ -121,7 +124,14 @@ func (i *Handler) HandleFrame(f frames.Frame) (err error) { } switch v := f.(type) { - // case *frames.SetupFrame: + case *frames.Setup: + if i.opTable == nil { + opers, err := operations.FromBytes(v.Data) + if err != nil { + return errors.New("could not read operations list") + } + i.opTable = opers + } case *frames.RequestPayload: switch frameType { diff --git a/go/internal/frames/setup.go b/go/internal/frames/setup.go new file mode 100644 index 0000000..cc24bf7 --- /dev/null +++ b/go/internal/frames/setup.go @@ -0,0 +1,153 @@ +package frames + +import ( + "encoding/binary" + "time" +) + +// https://rsocket.io/about/protocol/#setup-frame-0x01 + +type Setup struct { + MajorVersion uint16 + MinorVersion uint16 + TimeBetweenKeepalive time.Duration + MaxLifetime time.Duration + Token []byte + MimeMetadata string + MimeData string + Metadata []byte + Data []byte + Lease bool +} + +func (f *Setup) GetStreamID() uint32 { + return 0 +} + +func (f *Setup) Type() FrameType { + return FrameTypeSetup +} + +func (f *Setup) Decode(header *FrameHeader, payload []byte) error { + flags := header.Flag() + hasMetadata := flags.Check(FlagMetadata) + resume := flags.Check(FlagResume) + lease := flags.Check(FlagLease) + var metadata []byte + + major := binary.BigEndian.Uint16(payload) + minor := binary.BigEndian.Uint16(payload[2:]) + timeBetweenKeepalive := time.Millisecond * time.Duration(binary.BigEndian.Uint32(payload[4:])) + maxLifetime := time.Millisecond * time.Duration(binary.BigEndian.Uint32(payload[8:])) + var token []byte + + data := payload[12:] + + if resume { + tokenLength := binary.BigEndian.Uint16(data) + token = data[2 : 2+tokenLength] + data = data[2+tokenLength:] + } + + metadataMimeLength := data[0] + mimeMetadata := string(data[1 : 1+metadataMimeLength]) + data = data[1+metadataMimeLength:] + + dataMimeLength := data[0] + mimeData := string(data[1 : 1+dataMimeLength]) + data = data[1+dataMimeLength:] + payload = data + + if hasMetadata { + var mdLengthBuf [4]byte + copy(mdLengthBuf[1:], data[0:3]) + mdLength := binary.BigEndian.Uint32(mdLengthBuf[:]) + data = data[3:] + metadata = data[:mdLength] + payload = data[mdLength:] + } + + *f = Setup{ + MajorVersion: major, + MinorVersion: minor, + TimeBetweenKeepalive: timeBetweenKeepalive, + MaxLifetime: maxLifetime, + Token: token, + MimeMetadata: mimeMetadata, + MimeData: mimeData, + Metadata: metadata, + Data: payload, + Lease: lease, + } + + return nil +} + +func (f *Setup) Encode(buf []byte) { + tokenLen := uint16(len(f.Token)) + metadataLen := uint32(len(f.Metadata)) + payload := buf + var flags FrameFlag + if f.Lease { + flags |= FlagLease + } + if tokenLen > 0 { + flags |= FlagResume + } + if metadataLen > 0 { + flags |= FlagMetadata + } + + ResetFrameHeader(payload, 0, FrameTypeSetup, flags) + payload = payload[FrameHeaderLen:] + + binary.BigEndian.PutUint16(payload, f.MajorVersion) + binary.BigEndian.PutUint16(payload[2:], f.MinorVersion) + binary.BigEndian.PutUint32(payload[4:], uint32(f.TimeBetweenKeepalive)/uint32(time.Millisecond)) + binary.BigEndian.PutUint32(payload[8:], uint32(f.MaxLifetime)/uint32(time.Millisecond)) + + payload = payload[12:] + + if tokenLen > 0 { + binary.BigEndian.PutUint16(payload[:], tokenLen) + payload = payload[2:] + copy(payload, f.Token) + payload = payload[tokenLen:] + } + + metadataMimeBytes := []byte(f.MimeMetadata) + payload[0] = byte(len(metadataMimeBytes)) + copy(payload[1:], metadataMimeBytes) + payload = payload[1+len(metadataMimeBytes):] + + dataMimeBytes := []byte(f.MimeData) + payload[0] = byte(len(dataMimeBytes)) + copy(payload[1:], dataMimeBytes) + payload = payload[1+len(dataMimeBytes):] + + if metadataLen > 0 { + var mdLengthBuf [4]byte + binary.BigEndian.PutUint32(mdLengthBuf[:], metadataLen) + copy(payload[0:3], mdLengthBuf[1:]) + payload = payload[3:] + copy(payload, f.Metadata) + payload = payload[metadataLen:] + } + + copy(payload, f.Data) +} + +func (f *Setup) Size() uint32 { + size := uint32(FrameHeaderLen) + 14 + + metadataLen := uint32(len(f.Metadata)) + tokenLen := uint32(len(f.Token)) + size += metadataLen + tokenLen + uint32(len(f.Data)+len(f.Token)+len(f.MimeMetadata)+len(f.MimeData)) + if tokenLen > 0 { + size += 2 + } + if metadataLen > 0 { + size += 3 + } + return size +} diff --git a/go/internal/frames/setup_test.go b/go/internal/frames/setup_test.go new file mode 100644 index 0000000..3d6eab4 --- /dev/null +++ b/go/internal/frames/setup_test.go @@ -0,0 +1,30 @@ +package frames_test + +import ( + "fmt" + "testing" + + "github.com/nanobus/iota/go/internal/frames" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestSetup(t *testing.T) { + s := frames.Setup{ + MajorVersion: 0, + MinorVersion: 2, + Data: []byte("testing1234"), + } + + size := s.Size() + buf := make([]byte, size) + s.Encode(buf) + + fmt.Println(buf[frames.FrameHeaderLen:]) + + var s2 frames.Setup + f := frames.ParseFrameHeader(buf) + require.NoError(t, s2.Decode(&f, buf[frames.FrameHeaderLen:])) + + assert.Equal(t, s2, s) +} diff --git a/go/invoke/handlers.go b/go/invoke/handlers.go index 8fb1f20..6e11f39 100644 --- a/go/invoke/handlers.go +++ b/go/invoke/handlers.go @@ -3,6 +3,7 @@ package invoke import ( "context" + "github.com/nanobus/iota/go/operations" "github.com/nanobus/iota/go/payload" "github.com/nanobus/iota/go/rx/flux" "github.com/nanobus/iota/go/rx/mono" @@ -68,6 +69,46 @@ func GetOperations() Operations { } } +func GetOperationsTable() operations.Table { + opers := GetOperations() + exports := opers.Exported + imports := opers.Imported + numOper := uint32(len(exports.RequestResponse) + + len(exports.FireAndForget) + + len(exports.RequestStream) + + len(exports.RequestChannel) + + len(imports.RequestResponse) + + len(imports.FireAndForget) + + len(imports.RequestStream) + + len(imports.RequestChannel)) + + list := make(operations.Table, 0, numOper) + list = append(list, convertOperations(exports.RequestResponse, operations.RequestResponse, operations.Export)...) + list = append(list, convertOperations(exports.FireAndForget, operations.FireAndForget, operations.Export)...) + list = append(list, convertOperations(exports.RequestStream, operations.RequestStream, operations.Export)...) + list = append(list, convertOperations(exports.RequestChannel, operations.RequestChannel, operations.Export)...) + list = append(list, convertOperations(imports.RequestResponse, operations.RequestResponse, operations.Import)...) + list = append(list, convertOperations(imports.FireAndForget, operations.FireAndForget, operations.Import)...) + list = append(list, convertOperations(imports.RequestStream, operations.RequestStream, operations.Import)...) + list = append(list, convertOperations(imports.RequestChannel, operations.RequestChannel, operations.Import)...) + + return list +} + +func convertOperations(handlers []HandlerInfo, requestType operations.RequestType, direction operations.Direction) operations.Table { + opers := make(operations.Table, len(handlers)) + for i, h := range handlers { + opers[i] = operations.Operation{ + Index: uint32(i), + Type: requestType, + Direction: direction, + Namespace: h.Namespace, + Operation: h.Operation, + } + } + return opers +} + func ExportRequestResponse(namespace, operation string, handler RequestResponseHandler) { requestResponseHandlers = append(requestResponseHandlers, handler) requestResponseHandlerInfo = append(requestResponseHandlerInfo, HandlerInfo{namespace, operation}) diff --git a/go/msgpack/codec.go b/go/msgpack/codec.go index 8e39093..245a220 100644 --- a/go/msgpack/codec.go +++ b/go/msgpack/codec.go @@ -1,5 +1,11 @@ package msgpack +import ( + "time" + + "golang.org/x/exp/constraints" +) + // Codec is the interface that applies to data structures that can // encode to and decode from the MessagPack format. type Codec interface { @@ -166,3 +172,39 @@ func BytesToBytes(value []byte) ([]byte, error) { encoder.WriteByteArray(value) return buffer, nil } + +// TimeToBytes creates a `[]byte` from `value`. +func TimeToBytes(value time.Time) ([]byte, error) { + sizer := NewSizer() + sizer.WriteTime(value) + buffer := make([]byte, sizer.Len()) + encoder := NewEncoder(buffer) + encoder.WriteTime(value) + return buffer, nil +} + +func SliceToBytes[T any](values []T, valF func(Writer, T)) ([]byte, error) { + sizer := NewSizer() + if err := WriteSlice(&sizer, values, valF); err != nil { + return nil, err + } + buffer := make([]byte, sizer.Len()) + encoder := NewEncoder(buffer) + if err := WriteSlice(&encoder, values, valF); err != nil { + return nil, err + } + return buffer, nil +} + +func MapToBytes[K constraints.Ordered, V any](values map[K]V, keyF func(Writer, K), valF func(Writer, V)) ([]byte, error) { + sizer := NewSizer() + if err := WriteMap(&sizer, values, keyF, valF); err != nil { + return nil, err + } + buffer := make([]byte, sizer.Len()) + encoder := NewEncoder(buffer) + if err := WriteMap(&encoder, values, keyF, valF); err != nil { + return nil, err + } + return buffer, nil +} diff --git a/go/msgpack/decoder.go b/go/msgpack/decoder.go index 85af61f..02b0b29 100644 --- a/go/msgpack/decoder.go +++ b/go/msgpack/decoder.go @@ -11,6 +11,9 @@ type Decoder struct { reader DataReader } +// Ensure `*Decoder` implements `Reader`. +var _ = (Reader)((*Decoder)(nil)) + func NewDecoder(buffer []byte) Decoder { return Decoder{ reader: NewDataReader(buffer), diff --git a/go/msgpack/encoder.go b/go/msgpack/encoder.go index 2fd74c0..634bf9c 100644 --- a/go/msgpack/encoder.go +++ b/go/msgpack/encoder.go @@ -10,6 +10,9 @@ type Encoder struct { reader DataReader } +// Ensure `*Encoder` implements `Writer`. +var _ = (Writer)((*Encoder)(nil)) + func NewEncoder(buffer []byte) Encoder { return Encoder{ reader: NewDataReader(buffer), diff --git a/go/msgpack/sizer.go b/go/msgpack/sizer.go index 0fc83c0..ad88b50 100644 --- a/go/msgpack/sizer.go +++ b/go/msgpack/sizer.go @@ -9,6 +9,9 @@ type Sizer struct { length uint32 } +// Ensure `*Sizer` implements `Writer`. +var _ = (Writer)((*Sizer)(nil)) + func NewSizer() Sizer { return Sizer{} } diff --git a/go/msgpack/utils.go b/go/msgpack/utils.go new file mode 100644 index 0000000..e553ab7 --- /dev/null +++ b/go/msgpack/utils.go @@ -0,0 +1,68 @@ +package msgpack + +import ( + "golang.org/x/exp/constraints" +) + +func WriteSlice[T any](encoder Writer, values []T, valF func(Writer, T)) error { + encoder.WriteArraySize(uint32(len(values))) + for _, item := range values { + valF(encoder, item) + } + + return encoder.Err() +} + +func ReadSlice[T any](reader Reader, valF func(reader Reader) (T, error)) ([]T, error) { + listSize, err := reader.ReadArraySize() + if err != nil { + return nil, err + } + request := make([]T, 0, listSize) + for listSize > 0 { + listSize-- + item, err := valF(reader) + if err != nil { + return nil, err + } + request = append(request, item) + } + + return request, nil +} + +func WriteMap[K constraints.Ordered, V any](writer Writer, + m map[K]V, keyF func(Writer, K), + valF func(Writer, V)) error { + writer.WriteMapSize(uint32(len(m))) + for key, val := range m { + keyF(writer, key) + valF(writer, val) + } + + return writer.Err() +} + +func ReadMap[K constraints.Ordered, V any](reader Reader, + keyF func(reader Reader) (K, error), + valF func(reader Reader) (V, error)) (map[K]V, error) { + mapSize, err := reader.ReadMapSize() + if err != nil { + return nil, err + } + m := make(map[K]V, mapSize) + for mapSize > 0 { + mapSize-- + key, err := keyF(reader) + if err != nil { + return nil, err + } + value, err := valF(reader) + if err != nil { + return nil, err + } + m[key] = value + } + + return m, nil +} diff --git a/go/transform/transform.go b/go/transform/transform.go index 9549985..886125c 100644 --- a/go/transform/transform.go +++ b/go/transform/transform.go @@ -3,6 +3,8 @@ package transform import ( "time" + "golang.org/x/exp/constraints" + "github.com/nanobus/iota/go/invoke" "github.com/nanobus/iota/go/msgpack" "github.com/nanobus/iota/go/payload" @@ -276,6 +278,21 @@ var Time = Transform[time.Time]{ }, } +var Any = Transform[any]{ + Decode: func(raw payload.Payload) (any, error) { + decoder := msgpack.NewDecoder(raw.Data()) + val, err := decoder.ReadAny() + return val, err + }, + Encode: func(value any) (payload.Payload, error) { + buf, err := msgpack.AnyToBytes(value) + if err != nil { + return nil, err + } + return payload.New(buf), nil + }, +} + var Void = Transform[struct{}]{ Decode: func(raw payload.Payload) (struct{}, error) { return struct{}{}, nil @@ -360,6 +377,36 @@ func Uint64Encode[T ~uint64](val T) (payload.Payload, error) { return payload.New(buf), nil } +func Float32Decode[T ~float32](raw payload.Payload) (T, error) { + decoder := msgpack.NewDecoder(raw.Data()) + val, err := decoder.ReadFloat32() + return T(val), err +} + +func Float32Encode[T ~float32](val T) (payload.Payload, error) { + sizer := msgpack.NewSizer() + sizer.WriteFloat32(float32(val)) + buf := make([]byte, sizer.Len()) + encoder := msgpack.NewEncoder(buf) + encoder.WriteFloat32(float32(val)) + return payload.New(buf), nil +} + +func Float64Decode[T ~float64](raw payload.Payload) (T, error) { + decoder := msgpack.NewDecoder(raw.Data()) + val, err := decoder.ReadFloat64() + return T(val), err +} + +func Float64Encode[T ~float64](val T) (payload.Payload, error) { + sizer := msgpack.NewSizer() + sizer.WriteFloat64(float64(val)) + buf := make([]byte, sizer.Len()) + encoder := msgpack.NewEncoder(buf) + encoder.WriteFloat64(float64(val)) + return payload.New(buf), nil +} + func StringDecode[T ~string](raw payload.Payload) (T, error) { decoder := msgpack.NewDecoder(raw.Data()) val, err := decoder.ReadString() @@ -375,37 +422,67 @@ func StringEncode[T ~string](val T) (payload.Payload, error) { return payload.New(buf), nil } -func SliceDecode[T any, P MsgPackCodecPtr[T]](raw payload.Payload) ([]T, error) { - decoder := msgpack.NewDecoder(raw.Data()) - size, _ := decoder.ReadArraySize() - items := make([]T, size) - i := 0 - for size > 0 { - size-- - var item T - p := (P)(&item) - p.Decode(&decoder) - items[i] = item - i++ +func ToStringDecode[T any](f func(string) (T, error)) func(raw payload.Payload) (T, error) { + return func(raw payload.Payload) (empty T, _ error) { + val, err := StringDecode[string](raw) + if err != nil { + return empty, err + } + return f(val) } - return items, nil } -func SliceEncode[T any, P MsgPackCodecPtr[T]](items []T) (payload.Payload, error) { - sizer := msgpack.NewSizer() - sizer.WriteArraySize(uint32(len(items))) - for _, v := range items { - p := P(&v) - p.Encode(&sizer) +func ToStringEncode[T any](f func(T) string) func(value T) (payload.Payload, error) { + return func(val T) (payload.Payload, error) { + str := f(val) + return StringEncode(str) } - buf := make([]byte, sizer.Len()) - encoder := msgpack.NewEncoder(buf) - encoder.WriteArraySize(uint32(len(items))) - for _, v := range items { - p := P(&v) - p.Encode(&encoder) +} + +func SliceDecode[V any](valF func(msgpack.Reader) (V, error)) func(raw payload.Payload) ([]V, error) { + return func(raw payload.Payload) ([]V, error) { + decoder := msgpack.NewDecoder(raw.Data()) + return msgpack.ReadSlice(&decoder, valF) + } +} + +func SliceEncode[V any](valF func(msgpack.Writer, V)) func([]V) (payload.Payload, error) { + return func(m []V) (payload.Payload, error) { + sizer := msgpack.NewSizer() + if err := msgpack.WriteSlice(&sizer, m, valF); err != nil { + return nil, err + } + buf := make([]byte, sizer.Len()) + encoder := msgpack.NewEncoder(buf) + if err := msgpack.WriteSlice(&encoder, m, valF); err != nil { + return nil, err + } + + return payload.New(buf), nil + } +} + +func MapDecode[K constraints.Ordered, V any](keyF func(msgpack.Reader) (K, error), valF func(msgpack.Reader) (V, error)) func(raw payload.Payload) (map[K]V, error) { + return func(raw payload.Payload) (map[K]V, error) { + decoder := msgpack.NewDecoder(raw.Data()) + return msgpack.ReadMap(&decoder, keyF, valF) + } +} + +func MapEncode[K constraints.Ordered, V any](keyF func(msgpack.Writer, K), valF func(msgpack.Writer, V)) func(map[K]V) (payload.Payload, error) { + return func(m map[K]V) (payload.Payload, error) { + sizer := msgpack.NewSizer() + if err := msgpack.WriteMap(&sizer, m, keyF, valF); err != nil { + return nil, err + } + buf := make([]byte, sizer.Len()) + encoder := msgpack.NewEncoder(buf) + if err := msgpack.WriteMap(&encoder, m, keyF, valF); err != nil { + return nil, err + } + + return payload.New(buf), nil } - return payload.New(buf), nil } func InterfaceEncode[T any](tracker *invoke.LiveInstances[T]) rx.Transform[T, payload.Payload] { @@ -445,3 +522,17 @@ func FluxToMono[T any](f flux.Flux[T]) mono.Mono[T] { }) }) } + +func MonoToFlux[T any](f mono.Mono[T]) flux.Flux[T] { + return flux.Create(func(sink flux.Sink[T]) { + f.Subscribe(mono.Subscribe[T]{ + OnSuccess: func(val T) { + sink.Next(val) + sink.Complete() + }, + OnError: func(err error) { + sink.Error(err) + }, + }) + }) +} diff --git a/go/transport/rsocket/init.go b/go/transport/rsocket/init.go index 26ff62b..c7a5566 100644 --- a/go/transport/rsocket/init.go +++ b/go/transport/rsocket/init.go @@ -6,6 +6,7 @@ import ( "github.com/nanobus/iota/go/handler" "github.com/nanobus/iota/go/internal/frames" + "github.com/nanobus/iota/go/invoke" ) func NewServer(acceptor ServerTransportAcceptor) ServerTransport { @@ -20,8 +21,11 @@ func NewServer(acceptor ServerTransportAcceptor) ServerTransport { return server } -func NewClient(ctx context.Context) (*Transport, error) { - h := handler.New(ctx, handler.ClientMode) +func Handler(ctx context.Context) *handler.Handler { + return handler.New(ctx, handler.ClientMode) +} + +func NewClient(ctx context.Context, h *handler.Handler) (*Transport, error) { network := getEnvOrDefault("RSOCKET_NETWORK", "tcp") addr := getEnvOrDefault("RSOCKET_ADDRESS", "127.0.0.1:7878") conn, err := NewConnWithAddr(ctx, network, addr, nil) @@ -37,13 +41,22 @@ func NewClient(ctx context.Context) (*Transport, error) { return t, nil } -func Connect() error { +func Connect(h *handler.Handler) error { ctx := context.Background() - t, err := NewClient(ctx) + t, err := NewClient(ctx, h) if err != nil { return err } + // Send operation list in setup frame. + list := invoke.GetOperationsTable() + payload := list.ToBytes() + t.Send(&frames.Setup{ + MajorVersion: 0, + MinorVersion: 2, + Data: payload, + }, true) + return t.Start(ctx) } diff --git a/go/transport/rsocket/tcp_conn.go b/go/transport/rsocket/tcp_conn.go index 7d36c89..d414878 100644 --- a/go/transport/rsocket/tcp_conn.go +++ b/go/transport/rsocket/tcp_conn.go @@ -50,8 +50,12 @@ func (p *TCPConn) Read() (f frames.Frame, err error) { buffer := raw[frames.FrameHeaderLen:] switch header.Type() { - // case frames.FrameTypeSetup: - // // Not implemented + case frames.FrameTypeSetup: + var setup frames.Setup + if err := setup.Decode(&header, buffer); err != nil { + return nil, err + } + return &setup, nil case frames.FrameTypeRequestResponse, frames.FrameTypeRequestFNF, frames.FrameTypeRequestStream, frames.FrameTypeRequestChannel: diff --git a/go/transport/rsocket/tcp_transport.go b/go/transport/rsocket/tcp_transport.go index 20b9935..26dfd57 100644 --- a/go/transport/rsocket/tcp_transport.go +++ b/go/transport/rsocket/tcp_transport.go @@ -86,21 +86,24 @@ func (t *tcpServerTransport) Listen(ctx context.Context, notifier chan<- bool) ( } if err != nil { err = fmt.Errorf("accept next conn failed: %w", err) - break + continue } // Dispatch raw conn. h := handler.New(ctx, handler.ServerMode) - tp := NewTransport(NewTCPConn(c), h) + tp := NewTransport(NewTCPConn(c), h, true) h.SetFrameSender(func(f frames.Frame) error { return tp.Send(f, true) }) if t.putTransport(tp) { go tp.Start(ctx) - go t.acceptor(ctx, h, func(tp *Transport) { - t.removeTransport(tp) - }) + go func() { + tp.WaitUntilReady() + t.acceptor(ctx, h, func(tp *Transport) { + t.removeTransport(tp) + }) + }() } else { _ = t.Close() } @@ -158,7 +161,7 @@ func NewTCPListenerFactory(network, addr string, tlsConfig *tls.Config) Listener // NewTCPClientTransport creates new transport. func NewTCPClientTransport(c net.Conn, handler DuplexHandler) *Transport { - return NewTransport(NewTCPConn(c), handler) + return NewTransport(NewTCPConn(c), handler, false) } // NewConnWithAddr creates new connection. diff --git a/go/transport/rsocket/transport.go b/go/transport/rsocket/transport.go index e043506..c547611 100644 --- a/go/transport/rsocket/transport.go +++ b/go/transport/rsocket/transport.go @@ -53,14 +53,18 @@ type Transport struct { maxLifetime time.Duration once sync.Once handler DuplexHandler + isServer bool + ready chan struct{} } // NewTransport creates new transport. -func NewTransport(c Conn, handler DuplexHandler) *Transport { +func NewTransport(c Conn, handler DuplexHandler, isServer bool) *Transport { t := Transport{ conn: c, maxLifetime: DefaultKeepaliveMaxLifetime, handler: handler, + isServer: isServer, + ready: make(chan struct{}), } handler.SetFrameSender(t.handler.HandleFrame) return &t @@ -187,11 +191,26 @@ func (p *Transport) Start(ctx context.Context) error { framesBuffer.Dispose() <-done - // <-done }() go p.loopReadBuffer(ctx, framesBuffer, errChan, done) + if p.isServer { + first, err := p.ReadFirst(ctx) + if err != nil { + return fmt.Errorf("read first failed: %w", err) + } + if setup, ok := first.(*frames.Setup); ok { + if err := p.handler.HandleFrame(setup); err != nil { + return err + } + } else { + return errors.New("expected first frame to be a setup frame") + } + } + + close(p.ready) + for { select { case <-ctx.Done(): @@ -211,3 +230,7 @@ func (p *Transport) Start(ctx context.Context) error { } } } + +func (p *Transport) WaitUntilReady() { + <-p.ready +} diff --git a/go/transport/wasmrs/guest/guest.go b/go/transport/wasmrs/guest/guest.go index 92fffb0..6e7218a 100644 --- a/go/transport/wasmrs/guest/guest.go +++ b/go/transport/wasmrs/guest/guest.go @@ -10,7 +10,6 @@ import ( "github.com/nanobus/iota/go/internal/frames" "github.com/nanobus/iota/go/invoke" - "github.com/nanobus/iota/go/operations" "github.com/nanobus/iota/go/payload" "github.com/nanobus/iota/go/proxy" "github.com/nanobus/iota/go/rx" @@ -61,47 +60,12 @@ func Init(guestBufferSize uint32, hostBufferSize uint32, hostMaxFrameSize uint32 //go:export __wasmrs_op_list_request func OperationList() { - opers := invoke.GetOperations() - exports := opers.Exported - imports := opers.Imported - numOper := uint32(len(exports.RequestResponse) + - len(exports.FireAndForget) + - len(exports.RequestStream) + - len(exports.RequestChannel) + - len(imports.RequestResponse) + - len(imports.FireAndForget) + - len(imports.RequestStream) + - len(imports.RequestChannel)) - - list := make(operations.Table, 0, numOper) - list = append(list, convertOperations(exports.RequestResponse, operations.RequestResponse, operations.Export)...) - list = append(list, convertOperations(exports.FireAndForget, operations.FireAndForget, operations.Export)...) - list = append(list, convertOperations(exports.RequestStream, operations.RequestStream, operations.Export)...) - list = append(list, convertOperations(exports.RequestChannel, operations.RequestChannel, operations.Export)...) - list = append(list, convertOperations(imports.RequestResponse, operations.RequestResponse, operations.Import)...) - list = append(list, convertOperations(imports.FireAndForget, operations.FireAndForget, operations.Import)...) - list = append(list, convertOperations(imports.RequestStream, operations.RequestStream, operations.Import)...) - list = append(list, convertOperations(imports.RequestChannel, operations.RequestChannel, operations.Import)...) - + list := invoke.GetOperationsTable() payload := list.ToBytes() opList(bytesToPointer(payload), uint32(len(payload))) } -func convertOperations(handlers []invoke.HandlerInfo, requestType operations.RequestType, direction operations.Direction) operations.Table { - opers := make(operations.Table, len(handlers)) - for i, h := range handlers { - opers[i] = operations.Operation{ - Index: uint32(i), - Type: requestType, - Direction: direction, - Namespace: h.Namespace, - Operation: h.Operation, - } - } - return opers -} - //go:export __wasmrs_send func GuestSend(endPos uint32) { ctx := context.Background()