diff --git a/.github/workflows/ci-golang.yaml b/.github/workflows/ci-golang.yaml new file mode 100644 index 0000000000..4a28418d0b --- /dev/null +++ b/.github/workflows/ci-golang.yaml @@ -0,0 +1,45 @@ +name: CI-Golang + +on: + push: + branches: + - origin + - origin-dev + pull_request: + +jobs: + Test-Cli: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v2 + + - name: Read .nvmrc + run: echo ::set-output name=NVMRC::$(cat .nvmrc) + id: nvm + + - name: Setup Node.js + uses: actions/setup-node@master + with: + node-version: '${{ steps.nvm.outputs.NVMRC }}' + + - name: Get yarn cache directory path + id: yarn-cache-dir-path + run: echo "::set-output name=dir::$(yarn cache dir)" + + - uses: actions/cache@v2 + with: + path: ${{ steps.yarn-cache-dir-path.outputs.dir }} + key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }} + restore-keys: | + ${{ runner.os }}-yarn- + + - name: Install dependencies + run: yarn install --nonInteractive --frozen-lockfile --prefer-offline + + - name: Build + run: yarn build + + - name: Test + run: yarn test:golang + working-directory: ./packages/cli diff --git a/packages/cli/jest.config.js b/packages/cli/jest.config.js index aef0111dbf..57c9519473 100644 --- a/packages/cli/jest.config.js +++ b/packages/cli/jest.config.js @@ -11,7 +11,8 @@ module.exports = { modulePathIgnorePatterns: [ "/build", "/src/__tests__/project/.polywrap", - "/src/__tests__/e2e/build-rs.spec.ts" + "/src/__tests__/e2e/build-rs.spec.ts", + "/src/__tests__/e2e/build-go.spec.ts" ], testPathIgnorePatterns: [ "/src/__tests__/project/.polywrap" diff --git a/packages/cli/jest.go.config.js b/packages/cli/jest.go.config.js new file mode 100644 index 0000000000..7465b45559 --- /dev/null +++ b/packages/cli/jest.go.config.js @@ -0,0 +1,22 @@ +module.exports = { + collectCoverage: true, + preset: "ts-jest", + testEnvironment: "node", + globals: { + "ts-jest": { + diagnostics: false + }, + }, + modulePathIgnorePatterns: [ + "/build", + "/src/__tests__/project/.polywrap" + ], + testPathIgnorePatterns: [ + "/src/__tests__/project/.polywrap" + ], + transformIgnorePatterns: [ + "/src/__tests__/project/.polywrap" + ], + setupFilesAfterEnv: ["./jest.setup.js"], + testMatch: ["**/build-go.spec.ts"] +}; diff --git a/packages/cli/lang/en.json b/packages/cli/lang/en.json index 84a566036e..4f1ebb374a 100644 --- a/packages/cli/lang/en.json +++ b/packages/cli/lang/en.json @@ -9,6 +9,7 @@ "commands_build_description": "Build Polywrap Projects (type: interface, wasm)", "commands_build_error_manifestPathMissing": "{option} option missing {argument} argument", "commands_build_error_manifestNotFound": "Manifest not found. Search paths used: {paths}", + "commands_build_error_goModNotFound": "go.mod file not found. Search paths used: {paths}", "commands_build_error_outputDirMissingPath": "{option} option missing {argument} argument", "commands_build_error_unsupportedProjectType": "Unsupported project type. You can only build the following project types: {supportedTypes}", "commands_build_keypressListener_exit": "Exit: [CTRL + C], [ESC], or [Q]", @@ -233,6 +234,8 @@ "lib_helpers_deployManifestExt_loadError": "Failed to load deploy manifest extension from {path}", "lib_helpers_deployManifestExt_loadText": "Load manifest extension from {path}", "lib_helpers_deployManifestExt_loadWarning": "No manifest extension found in {path}", + "lib_helpers_gomod_unableToLoad": "Unable to load go.mod: {path}", + "lib_helpers_gomod_invalid": "Invalid format of go.mod: {path}", "lib_helpers_manifest_outputError": "Failed to output manifest to {path}", "lib_helpers_manifest_outputText": "Manifest written to {path}", "lib_helpers_manifest_outputWarning": "Warnings writing manifest to {path}", @@ -272,6 +275,7 @@ "lib_typescript_tsNodeNotInstalled": "Your project uses typescript, but ts-node is not installed", "lib_watcher_alreadyWatching": "Watcher session is already in progress. Directory: {dir}", "lib_wasm_rust_invalidModule": "Module paths must point to Cargo.toml files. Found: {path}", + "lib_wasm_golang_invalidModule": "Module paths must point to go.mod file. Found: {path}", "lib_docker_invalidImageId": "Invalid docker image ID returned: {imageId}", "lib_docker_noInstall": "Docker executable not found in PATH", "lib_infra_unrecognizedModule": "Unrecognized modules: {modules}. Default modules: {defaultModules}", diff --git a/packages/cli/lang/es.json b/packages/cli/lang/es.json index 84a566036e..4f1ebb374a 100644 --- a/packages/cli/lang/es.json +++ b/packages/cli/lang/es.json @@ -9,6 +9,7 @@ "commands_build_description": "Build Polywrap Projects (type: interface, wasm)", "commands_build_error_manifestPathMissing": "{option} option missing {argument} argument", "commands_build_error_manifestNotFound": "Manifest not found. Search paths used: {paths}", + "commands_build_error_goModNotFound": "go.mod file not found. Search paths used: {paths}", "commands_build_error_outputDirMissingPath": "{option} option missing {argument} argument", "commands_build_error_unsupportedProjectType": "Unsupported project type. You can only build the following project types: {supportedTypes}", "commands_build_keypressListener_exit": "Exit: [CTRL + C], [ESC], or [Q]", @@ -233,6 +234,8 @@ "lib_helpers_deployManifestExt_loadError": "Failed to load deploy manifest extension from {path}", "lib_helpers_deployManifestExt_loadText": "Load manifest extension from {path}", "lib_helpers_deployManifestExt_loadWarning": "No manifest extension found in {path}", + "lib_helpers_gomod_unableToLoad": "Unable to load go.mod: {path}", + "lib_helpers_gomod_invalid": "Invalid format of go.mod: {path}", "lib_helpers_manifest_outputError": "Failed to output manifest to {path}", "lib_helpers_manifest_outputText": "Manifest written to {path}", "lib_helpers_manifest_outputWarning": "Warnings writing manifest to {path}", @@ -272,6 +275,7 @@ "lib_typescript_tsNodeNotInstalled": "Your project uses typescript, but ts-node is not installed", "lib_watcher_alreadyWatching": "Watcher session is already in progress. Directory: {dir}", "lib_wasm_rust_invalidModule": "Module paths must point to Cargo.toml files. Found: {path}", + "lib_wasm_golang_invalidModule": "Module paths must point to go.mod file. Found: {path}", "lib_docker_invalidImageId": "Invalid docker image ID returned: {imageId}", "lib_docker_noInstall": "Docker executable not found in PATH", "lib_infra_unrecognizedModule": "Unrecognized modules: {modules}. Default modules: {defaultModules}", diff --git a/packages/cli/package.json b/packages/cli/package.json index a3b0853acb..7802dbe68b 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -32,6 +32,7 @@ "test:e2e:p1": "yarn test:cmd -- ./src/__tests__/e2e/p1/*.spec.ts", "test:e2e:p2": "yarn test:cmd -- ./src/__tests__/e2e/p2/*.spec.ts", "test:rust": "yarn test:cmd -- --config ./jest.rs.config.js", + "test:golang": "yarn test:cmd -- --config ./jest.go.config.js", "test:watch": "yarn test -- --watch" }, "resolutions": { diff --git a/packages/cli/src/__tests__/e2e/build-go.spec.ts b/packages/cli/src/__tests__/e2e/build-go.spec.ts new file mode 100644 index 0000000000..8c9606fe0f --- /dev/null +++ b/packages/cli/src/__tests__/e2e/build-go.spec.ts @@ -0,0 +1,72 @@ +import { polywrapCli } from "./utils"; +import { Commands } from "@polywrap/cli-js"; +import { GetPathToCliTestFiles } from "@polywrap/test-cases"; +import fs from "fs"; +import path from "path"; + +jest.setTimeout(1500000); + +describe("e2e tests for build command", () => { + const testCaseRoot = path.join(GetPathToCliTestFiles(), "build-cmd/wasm/golang"); + const testCases = fs + .readdirSync(testCaseRoot, { withFileTypes: true }) + .filter((dirent) => dirent.isDirectory()) + .map((dirent) => dirent.name); + + const getTestCaseDir = (index: number) => + path.join(testCaseRoot, testCases[index]); + + describe("Image strategy", () => { + it("Builds for go", async () => { + const { exitCode: code, stdout: output } = await Commands.build({ + strategy: "image", + verbose: true + }, { + cwd: getTestCaseDir(0), + cli: polywrapCli, + }); + const buildDir = `./build`; + + expect(code).toEqual(0); + expect(output).toContain(`Artifacts written to ${buildDir}`); + expect(output).toContain(`WRAP manifest written in ${buildDir}/wrap.info`); + }); + }) + + // NOTE: Skipped because CI needs system prequisites: golang + describe.skip("Local strategy", () => { + it("Builds for rust", async () => { + const { exitCode: code, stdout: output } = await Commands.build({ + strategy: "local", + verbose: true + }, { + cwd: getTestCaseDir(0), + cli: polywrapCli, + }); + + const buildDir = `./build`; + + expect(code).toEqual(0); + expect(output).toContain(`Artifacts written to ${buildDir}`); + expect(output).toContain(`WRAP manifest written in ${buildDir}/wrap.info`); + }); + }) + + describe("VM strategy", () => { + it("Builds for go", async () => { + const { exitCode: code, stdout: output } = await Commands.build({ + strategy: "vm", + verbose: true + }, { + cwd: getTestCaseDir(0), + cli: polywrapCli, + }); + + const buildDir = `./build`; + + expect(code).toEqual(0); + expect(output).toContain(`Artifacts written to ${buildDir}`); + expect(output).toContain(`WRAP manifest written in ${buildDir}/wrap.info`); + }); + }) +}); diff --git a/packages/cli/src/__tests__/e2e/p1/help.spec.ts b/packages/cli/src/__tests__/e2e/p1/help.spec.ts index 34e883a3a6..f8d71a857d 100644 --- a/packages/cli/src/__tests__/e2e/p1/help.spec.ts +++ b/packages/cli/src/__tests__/e2e/p1/help.spec.ts @@ -13,7 +13,6 @@ Commands: codegen|g [options] Generate Code For Polywrap Projects create|c Create New Projects deploy|d [options] Deploys Polywrap Projects - docgen|o [options] Generate wrapper documentation infra|i [options] Modular Infrastructure-As-Code Orchestrator manifest|m Inspect & Migrade Polywrap Manifests test|t [options] Execute Tests diff --git a/packages/cli/src/__tests__/e2e/p1/no-command.spec.ts b/packages/cli/src/__tests__/e2e/p1/no-command.spec.ts index 785821b0b4..3db13b855d 100644 --- a/packages/cli/src/__tests__/e2e/p1/no-command.spec.ts +++ b/packages/cli/src/__tests__/e2e/p1/no-command.spec.ts @@ -13,7 +13,6 @@ Commands: codegen|g [options] Generate Code For Polywrap Projects create|c Create New Projects deploy|d [options] Deploys Polywrap Projects - docgen|o [options] Generate wrapper documentation infra|i [options] Modular Infrastructure-As-Code Orchestrator manifest|m Inspect & Migrade Polywrap Manifests test|t [options] Execute Tests diff --git a/packages/cli/src/commands/build.ts b/packages/cli/src/commands/build.ts index 4fd735e068..695e132aee 100644 --- a/packages/cli/src/commands/build.ts +++ b/packages/cli/src/commands/build.ts @@ -15,6 +15,7 @@ import { polywrapManifestLanguages, pluginManifestLanguages, parseWrapperEnvsOption, + parseDirOptionNoDefault, } from "../lib"; import { CodeGenerator } from "../lib/codegen"; import { @@ -48,7 +49,7 @@ export interface BuildCommandOptions extends BaseCommandOptions { clientConfig: string | false; wrapperEnvs: string | false; noCodegen: boolean; - codegenDir: string; + codegenDir: string | false; watch: boolean; strategy: `${SupportedStrategies}`; } @@ -112,7 +113,7 @@ export const build: Command = { wrapperEnvs: options.wrapperEnvs || false, outputDir: parseDirOption(options.outputDir, defaultOutputDir), noCodegen: !options.codegen || false, - codegenDir: parseDirOption(options.codegenDir, DEFAULT_CODEGEN_DIR), + codegenDir: parseDirOptionNoDefault(options.codegenDir), strategy: options.strategy || defaultStrategy, watch: options.watch || false, verbose: options.verbose || false, @@ -241,7 +242,7 @@ async function run(options: Required) { const codeGenerator = new CodeGenerator({ project, schemaComposer, - codegenDirAbs: codegenDir, + codegenDirAbs: codegenDir || undefined, }); const codegenSuccess = await codeGenerator.generate(); diff --git a/packages/cli/src/lib/Compiler.ts b/packages/cli/src/lib/Compiler.ts index 6946f6ee3b..8700f74b19 100644 --- a/packages/cli/src/lib/Compiler.ts +++ b/packages/cli/src/lib/Compiler.ts @@ -43,7 +43,7 @@ export class Compiler { await this._outputWrapManifest(); if (await this._isWasm()) { - // Build & Output: wasm.wrap + // Build & Output: wrap.wasm await this._buildModules(); // Copy: Resources folder diff --git a/packages/cli/src/lib/build-strategies/BuildOverrides.ts b/packages/cli/src/lib/build-strategies/BuildOverrides.ts new file mode 100644 index 0000000000..8ba5de7c82 --- /dev/null +++ b/packages/cli/src/lib/build-strategies/BuildOverrides.ts @@ -0,0 +1,36 @@ +import { PolywrapManifestLanguage } from "../"; + +import { PolywrapManifest } from "@polywrap/polywrap-manifest-types-js"; +import path from "path"; +import fs from "fs"; + +export interface BuildOverrides { + validateManifest?: (manifest: PolywrapManifest) => Promise; + + sourcesSubDirectory?: string; +} + +export async function tryGetBuildOverrides( + language: PolywrapManifestLanguage +): Promise { + const modulePath = path.join( + __dirname, + "..", + "defaults", + "language-overrides", + language, + "index.js" + ); + let overrides: BuildOverrides | undefined; + + if (fs.existsSync(modulePath)) { + const module = await import(modulePath); + + // Get any build overrides for the given build-image + if (module.getBuildOverrides) { + overrides = module.getBuildOverrides() as BuildOverrides; + } + } + + return Promise.resolve(overrides); +} diff --git a/packages/cli/src/lib/build-strategies/BuildStrategy.ts b/packages/cli/src/lib/build-strategies/BuildStrategy.ts index 9b0086903c..3792cddc5c 100644 --- a/packages/cli/src/lib/build-strategies/BuildStrategy.ts +++ b/packages/cli/src/lib/build-strategies/BuildStrategy.ts @@ -1,9 +1,10 @@ +import { BuildOverrides, tryGetBuildOverrides } from "./BuildOverrides"; import { PolywrapProject } from "../project"; import fse from "fs-extra"; import path from "path"; -export interface BuildStrategyArgs { +export interface BuildStrategyConfig { project: PolywrapProject; outputDir: string; } @@ -11,8 +12,9 @@ export interface BuildStrategyArgs { export abstract class BuildStrategy { protected project: PolywrapProject; protected outputDir: string; + protected overrides?: BuildOverrides; - constructor({ project, outputDir }: BuildStrategyArgs) { + constructor({ project, outputDir }: BuildStrategyConfig) { this.project = project; this.outputDir = outputDir; } @@ -23,7 +25,7 @@ export abstract class BuildStrategy { async build(): Promise { const language = await this.project.getManifestLanguage(); - const defaultsOfStrategyUsed = path.join( + const buildStrategyDir = path.join( __dirname, "..", "defaults", @@ -31,17 +33,25 @@ export abstract class BuildStrategy { language, this.getStrategyName() ); + + // Cache all build strategy files const strategyUsedCacheDir = this.project.getCachePath( PolywrapProject.cacheLayout.buildStrategyUsed ); - if (fse.existsSync(strategyUsedCacheDir)) { fse.removeSync(strategyUsedCacheDir); } - fse.mkdirSync(strategyUsedCacheDir, { recursive: true }); + fse.copySync(buildStrategyDir, strategyUsedCacheDir); + + // Check if build overrides exist + this.overrides = await tryGetBuildOverrides(language); + + // If they do, ensure the manifest if valid before build starts + if (this.overrides && this.overrides.validateManifest) { + await this.overrides.validateManifest(await this.project.getManifest()); + } - fse.copySync(defaultsOfStrategyUsed, strategyUsedCacheDir); return this.buildSources(); } } diff --git a/packages/cli/src/lib/build-strategies/index.ts b/packages/cli/src/lib/build-strategies/index.ts index 6aa24c9e22..1daa4e6083 100644 --- a/packages/cli/src/lib/build-strategies/index.ts +++ b/packages/cli/src/lib/build-strategies/index.ts @@ -1,3 +1,4 @@ +export * from "./BuildOverrides"; export * from "./BuildStrategy"; export * from "./strategies"; diff --git a/packages/cli/src/lib/build-strategies/strategies/DockerImageStrategy.ts b/packages/cli/src/lib/build-strategies/strategies/DockerImageStrategy.ts index 0de8d4552a..d200659b5a 100644 --- a/packages/cli/src/lib/build-strategies/strategies/DockerImageStrategy.ts +++ b/packages/cli/src/lib/build-strategies/strategies/DockerImageStrategy.ts @@ -7,7 +7,7 @@ import { runCommand, runCommandSync, } from "../../system"; -import { BuildStrategyArgs, BuildStrategy } from "../BuildStrategy"; +import { BuildStrategyConfig, BuildStrategy } from "../BuildStrategy"; import { intlMsg } from "../../intl"; import { logActivity } from "../../logging"; @@ -21,8 +21,8 @@ type BuildImageId = string; export class DockerImageBuildStrategy extends BuildStrategy { private _dockerLock: FileLock; - constructor(args: BuildStrategyArgs) { - super(args); + constructor(config: BuildStrategyConfig) { + super(config); if (!isDockerInstalled(this.project.logger)) { throw new Error(intlMsg.lib_docker_noInstall()); diff --git a/packages/cli/src/lib/build-strategies/strategies/DockerVMStrategy.ts b/packages/cli/src/lib/build-strategies/strategies/DockerVMStrategy.ts index 35133ab8db..8f7df32b85 100644 --- a/packages/cli/src/lib/build-strategies/strategies/DockerVMStrategy.ts +++ b/packages/cli/src/lib/build-strategies/strategies/DockerVMStrategy.ts @@ -4,7 +4,7 @@ import { isDockerInstalled, runCommand, } from "../../system"; -import { BuildStrategyArgs, BuildStrategy } from "../BuildStrategy"; +import { BuildStrategyConfig, BuildStrategy } from "../BuildStrategy"; import { intlMsg } from "../../intl"; import { BuildManifestConfig, @@ -43,6 +43,11 @@ const CONFIGS: Record = { baseImage: "polywrap/vm-base-as", version: "0.2.0", }, + "wasm/golang": { + defaultIncludes: ["go.mod", "go.sum"], + baseImage: "polywrap/vm-base-go", + version: "0.1.5", + }, }; export class DockerVMBuildStrategy extends BuildStrategy { @@ -50,8 +55,8 @@ export class DockerVMBuildStrategy extends BuildStrategy { project: string; linkedPackages: string; }; - constructor(args: BuildStrategyArgs) { - super(args); + constructor(config: BuildStrategyConfig) { + super(config); if (!isDockerInstalled(this.project.logger)) { throw new Error(intlMsg.lib_docker_noInstall()); @@ -133,21 +138,14 @@ export class DockerVMBuildStrategy extends BuildStrategy { // Copy sources and build if (buildManifestConfig.polywrap_module) { - // HACK: moduleDir is path to Cargo.toml in Rust - if (language === "wasm/rust") { - fse.copySync( - path.join(manifestDir, "src"), - path.join(this._volumePaths.project, "src") - ); - } else { - fse.copySync( - path.join(manifestDir, buildManifestConfig.polywrap_module.dir), - path.join( - this._volumePaths.project, - buildManifestConfig.polywrap_module.dir - ) - ); - } + const sourcesSubDirectory = + this.overrides?.sourcesSubDirectory || + buildManifestConfig.polywrap_module.dir; + + fse.copySync( + path.join(manifestDir, sourcesSubDirectory), + path.join(this._volumePaths.project, sourcesSubDirectory) + ); const scriptTemplate = fse.readFileSync( path.join( diff --git a/packages/cli/src/lib/codegen/CodeGenerator.ts b/packages/cli/src/lib/codegen/CodeGenerator.ts index affc649213..46a16e8bf8 100644 --- a/packages/cli/src/lib/codegen/CodeGenerator.ts +++ b/packages/cli/src/lib/codegen/CodeGenerator.ts @@ -16,6 +16,7 @@ import { } from "../project"; import { resetDir } from "../system"; import { SchemaComposer } from "../SchemaComposer"; +import { CodegenOverrides, tryGetCodegenOverrides } from "./CodegenOverrides"; import path from "path"; import { BindLanguage } from "@polywrap/schema-bind"; @@ -48,13 +49,16 @@ export class CodeGenerator { ); } + // Get overrides if they exist + const overrides = await tryGetCodegenOverrides(language); + await logActivity( this._config.project.logger, intlMsg.lib_codeGenerator_genCodeText(), intlMsg.lib_codeGenerator_genCodeError(), intlMsg.lib_codeGenerator_genCodeWarning(), async () => { - return this.runCodegen(bindLanguage); + return this.runCodegen(bindLanguage, overrides); } ); @@ -65,7 +69,11 @@ export class CodeGenerator { } } - protected async runCodegen(_: BindLanguage): Promise { + protected async runCodegen( + _: BindLanguage, + overrides?: CodegenOverrides + ): Promise { + // TODO: move codegen dir overrides into the new "language-overrides" const codegenDir = this._config.codegenDirAbs ? path.relative( this._config.project.getManifestDir(), @@ -73,10 +81,15 @@ export class CodeGenerator { ) : undefined; + const bindConfig = overrides + ? await overrides.getSchemaBindConfig(this._config.project) + : {}; + const abi = await this._config.schemaComposer.getComposedAbis(); const binding = await this._config.project.generateSchemaBindings( abi, - codegenDir + codegenDir, + bindConfig ); resetDir(binding.outputDirAbs); diff --git a/packages/cli/src/lib/codegen/CodegenOverrides.ts b/packages/cli/src/lib/codegen/CodegenOverrides.ts new file mode 100644 index 0000000000..dd224839b5 --- /dev/null +++ b/packages/cli/src/lib/codegen/CodegenOverrides.ts @@ -0,0 +1,35 @@ +import { Project, AnyProjectManifest, AnyProjectManifestLanguage } from "../"; + +import path from "path"; +import fs from "fs"; + +export interface CodegenOverrides { + getSchemaBindConfig: ( + project: Project + ) => Promise>; +} + +export async function tryGetCodegenOverrides( + language: AnyProjectManifestLanguage +): Promise { + const modulePath = path.join( + __dirname, + "..", + "defaults", + "language-overrides", + language, + "index.js" + ); + let overrides: CodegenOverrides | undefined; + + if (fs.existsSync(modulePath)) { + const module = await import(modulePath); + + // Get any build overrides for the given build-image + if (module.getCodegenOverrides) { + overrides = module.getCodegenOverrides() as CodegenOverrides; + } + } + + return Promise.resolve(overrides); +} diff --git a/packages/cli/src/lib/codegen/index.ts b/packages/cli/src/lib/codegen/index.ts index fb9b3a2ef5..cd95e5446c 100644 --- a/packages/cli/src/lib/codegen/index.ts +++ b/packages/cli/src/lib/codegen/index.ts @@ -1,2 +1,3 @@ export * from "./CodeGenerator"; +export * from "./CodegenOverrides"; export * from "./ScriptCodeGenerator"; diff --git a/packages/cli/src/lib/defaults/build-strategies/wasm/golang/default.build.yaml b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/default.build.yaml new file mode 100644 index 0000000000..2d69edd896 --- /dev/null +++ b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/default.build.yaml @@ -0,0 +1,4 @@ +format: 0.2.0 +strategies: + image: + dockerfile: ./Dockerfile.mustache diff --git a/packages/cli/src/lib/defaults/build-strategies/wasm/golang/image/Dockerfile.mustache b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/image/Dockerfile.mustache new file mode 100644 index 0000000000..08c0ade400 --- /dev/null +++ b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/image/Dockerfile.mustache @@ -0,0 +1,15 @@ +FROM polywrap/vm-base-go:0.1.5 + +WORKDIR /project + +COPY . . + +RUN go mod tidy + +RUN tinygo build -o main.wasm -target wasm-target ./module/wrap/main/main.go + +# Make the build directory +RUN rm -rf ./build +RUN mkdir ./build + +RUN wasm-snip ./main.wasm -o ./build/wrap.wasm -p fd_write clock_time_get args_sizes_get args_get diff --git a/packages/cli/src/lib/defaults/build-strategies/wasm/golang/local/local.sh b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/local/local.sh new file mode 100644 index 0000000000..00b41f6bad --- /dev/null +++ b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/local/local.sh @@ -0,0 +1,7 @@ +go mod tidy + +tinygo build -o ./build/main.wasm -target ./.polywrap/wasm/build/strategy-used/wasm-target.json ./module/wrap/main/main.go + +wasm-snip -o ./build/wrap.wasm ./build/main.wasm -p fd_write clock_time_get args_sizes_get args_get + +rm ./build/main.wasm diff --git a/packages/cli/src/lib/defaults/build-strategies/wasm/golang/local/wasm-target.json b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/local/wasm-target.json new file mode 100644 index 0000000000..2e45a55999 --- /dev/null +++ b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/local/wasm-target.json @@ -0,0 +1,27 @@ +{ + "llvm-target": "wasm32-unknown-wasi", + "cpu": "generic", + "features": "+bulk-memory,+nontrapping-fptoint,+sign-ext", + "build-tags": ["tinygo.wasm", "wasi"], + "goos": "linux", + "goarch": "arm", + "linker": "wasm-ld", + "libc": "wasi-libc", + "scheduler": "asyncify", + "default-stack-size": 24576, + "cflags": [ + "-mbulk-memory", + "-mnontrapping-fptoint", + "-msign-ext" + ], + "ldflags": [ + "--stack-first", + "--no-demangle", + "--import-memory" + ], + "extra-files": [ + "src/runtime/asm_tinygowasm.S" + ], + "emulator": "wasmtime --mapdir=/tmp::{tmpDir} {}", + "wasm-abi": "generic" +} diff --git a/packages/cli/src/lib/defaults/build-strategies/wasm/golang/manifest.ext.json b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/manifest.ext.json new file mode 100644 index 0000000000..6894091f3d --- /dev/null +++ b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/manifest.ext.json @@ -0,0 +1,22 @@ +{ + "properties": { + "strategies": { + "properties": { + "image": { + "type": "object", + "properties": { + "include": { + "description": "Files to include in docker image.", + "type": "array", + "items": { + "type": "string" + } + } + } + } + } + }, + "local": { }, + "vm": { } + } +} \ No newline at end of file diff --git a/packages/cli/src/lib/defaults/build-strategies/wasm/golang/vm/vm-script.mustache b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/vm/vm-script.mustache new file mode 100644 index 0000000000..715d7b3eb7 --- /dev/null +++ b/packages/cli/src/lib/defaults/build-strategies/wasm/golang/vm/vm-script.mustache @@ -0,0 +1,11 @@ +set -e + +go mod tidy + +tinygo build -o main.wasm -target wasm-target ./module/wrap/main/main.go + +# Make the build directory +rm -rf ./build +mkdir ./build + +wasm-snip ./main.wasm -o ./build/wrap.wasm -p fd_write clock_time_get args_sizes_get args_get diff --git a/packages/cli/src/lib/defaults/language-overrides/wasm/golang/index.ts b/packages/cli/src/lib/defaults/language-overrides/wasm/golang/index.ts new file mode 100644 index 0000000000..16f31636c1 --- /dev/null +++ b/packages/cli/src/lib/defaults/language-overrides/wasm/golang/index.ts @@ -0,0 +1,72 @@ +import { BuildOverrides } from "../../../../build-strategies"; +import { CodegenOverrides } from "../../../../codegen"; +import { PolywrapProject } from "../../../../project"; +import { resolvePathIfExists } from "../../../../system"; +import { intlMsg } from "../../../../intl"; + +import { PolywrapManifest } from "@polywrap/polywrap-manifest-types-js"; +import fs from "fs"; + +export function getBuildOverrides(): BuildOverrides { + return { + validateManifest: (manifest: PolywrapManifest) => { + getGoModulePath(manifest); + return Promise.resolve(); + }, + sourcesSubDirectory: "module", + }; +} + +export function getCodegenOverrides(): CodegenOverrides { + return { + getSchemaBindConfig: async (project: PolywrapProject) => { + const manifest = await project.getManifest(); + const goModpath = getGoModulePath(manifest); + const goModuleName = readGoModuleName(goModpath); + return { + goModuleName, + }; + }, + }; +} + +function getGoModulePath(manifest: PolywrapManifest): string { + // Ensure `module: ...` is pointing to a `go.mod` file + const module = manifest.source.module; + if (!module || module.indexOf("go.mod") === -1) { + throw Error( + intlMsg.lib_wasm_golang_invalidModule({ path: module || "N/A" }) + ); + } + + // Ensure the `go.mod` file exists + const goModFile = resolvePathIfExists([module]); + if (!goModFile) { + throw Error( + intlMsg.commands_build_error_goModNotFound({ + paths: module, + }) + ); + } + + return goModFile; +} + +function readGoModuleName(filePath: string): string { + const goMod = fs.readFileSync(filePath, "utf-8"); + + if (!goMod) { + const noLoadMessage = intlMsg.lib_helpers_gomod_unableToLoad({ + path: filePath, + }); + throw Error(noLoadMessage); + } + + const regex = /module (.+)/m; + const module = goMod.match(regex); + if (!module || module.length != 2) { + throw Error(intlMsg.lib_helpers_gomod_invalid({ path: filePath })); + } + + return module[1]; +} diff --git a/packages/cli/src/lib/defaults/language-overrides/wasm/rust/index.ts b/packages/cli/src/lib/defaults/language-overrides/wasm/rust/index.ts new file mode 100644 index 0000000000..948da95d1a --- /dev/null +++ b/packages/cli/src/lib/defaults/language-overrides/wasm/rust/index.ts @@ -0,0 +1,19 @@ +import { BuildOverrides } from "../../../../build-strategies"; +import { intlMsg } from "../../../../intl"; + +import { PolywrapManifest } from "@polywrap/polywrap-manifest-types-js"; + +export function getBuildOverrides(): BuildOverrides { + return { + validateManifest: (manifest: PolywrapManifest) => { + const module = manifest.source.module; + + if (module && module.indexOf("Cargo.toml") === -1) { + throw Error(intlMsg.lib_wasm_rust_invalidModule({ path: module })); + } + + return Promise.resolve(); + }, + sourcesSubDirectory: "src", + }; +} diff --git a/packages/cli/src/lib/project/PolywrapProject.ts b/packages/cli/src/lib/project/PolywrapProject.ts index 465a6fc2d3..8aed37043b 100644 --- a/packages/cli/src/lib/project/PolywrapProject.ts +++ b/packages/cli/src/lib/project/PolywrapProject.ts @@ -146,7 +146,8 @@ export class PolywrapProject extends Project { public async generateSchemaBindings( abi: WrapAbi, - generationSubPath?: string + generationSubPath?: string, + bindConfig?: Record ): Promise { const manifest = await this.getManifest(); const codegenDirectory = await this.getGenerationDirectory( @@ -165,6 +166,7 @@ export class PolywrapProject extends Project { abi, outputDirAbs: codegenDirectory, bindLanguage, + config: bindConfig, }; return bindSchema(options); diff --git a/packages/cli/src/lib/project/Project.ts b/packages/cli/src/lib/project/Project.ts index 75a6a945a6..03cc4b7b24 100644 --- a/packages/cli/src/lib/project/Project.ts +++ b/packages/cli/src/lib/project/Project.ts @@ -72,7 +72,8 @@ export abstract class Project { public abstract generateSchemaBindings( abi: Abi, - generationSubPath?: string + generationSubPath?: string, + bindConfig?: Record ): Promise; public get logger(): Logger { diff --git a/packages/cli/src/lib/project/manifests/polywrap/languages.ts b/packages/cli/src/lib/project/manifests/polywrap/languages.ts index d12c067c01..d4c49fdc2d 100644 --- a/packages/cli/src/lib/project/manifests/polywrap/languages.ts +++ b/packages/cli/src/lib/project/manifests/polywrap/languages.ts @@ -5,6 +5,7 @@ import { BindLanguage } from "@polywrap/schema-bind"; export const polywrapManifestLanguages = { "wasm/assemblyscript": "wasm/assemblyscript", "wasm/rust": "wasm/rust", + "wasm/golang": "wasm/golang", interface: "interface", }; @@ -26,6 +27,8 @@ export function polywrapManifestLanguageToBindLanguage( return "wasm-as"; case "wasm/rust": return "wasm-rs"; + case "wasm/golang": + return "wasm-go"; case "interface": throw Error(intlMsg.lib_language_noInterfaceCodegen()); default: @@ -48,6 +51,8 @@ export function polywrapManifestOverrideCodegenDir( // the codegen directory to be `./src/wrap` case "wasm/rust": return "./src/wrap"; + case "wasm/golang": + return "./module/wrap"; default: return undefined; } diff --git a/packages/schema/bind/src/__tests__/test-cases.spec.ts b/packages/schema/bind/src/__tests__/test-cases.spec.ts index 7f3af50937..6fd98b00d7 100644 --- a/packages/schema/bind/src/__tests__/test-cases.spec.ts +++ b/packages/schema/bind/src/__tests__/test-cases.spec.ts @@ -2,7 +2,8 @@ import { fetchTestCases } from "./index"; import { bindSchema, BindLanguage, - BindOutput + BindOutput, + BindOptions } from "../"; import { @@ -12,7 +13,7 @@ import { OutputEntry } from "@polywrap/os-js"; -import fs from "fs"; +import fs, {existsSync, mkdirSync} from "fs"; import path from "path"; import { deepCopy } from "./utils"; @@ -39,10 +40,19 @@ describe("Polywrap Binding Test Suite", () => { outputDirAbs: testCase.input.outputDirAbs, }; - const output = bindSchema({ + const bindOptions: BindOptions = { ...deepCopy(testCase.input), - bindLanguage: language as BindLanguage, - }); + bindLanguage: language as BindLanguage + }; + + if (language == "wasm-go") { + if (!bindOptions.config) { + bindOptions.config = {}; + } + bindOptions.config.goModuleName = "github.com/testorg/testrepo"; + } + + const output = bindSchema(bindOptions); const sort = (array: OutputEntry[]): OutputEntry[] => { array.forEach((entry) => { @@ -76,6 +86,42 @@ describe("Polywrap Binding Test Suite", () => { JSON.stringify(expectedOutput, null, 2), ); + const paths: string[] = []; + + + const outputDirectoryEntry = (root: string, entry: OutputEntry) => { + const entryPath = path.join(root, entry.name); + paths.push(entryPath); + + switch (entry.type) { + case "File": { + writeFileSync(entryPath, entry.data); + break; + } + case "Directory": { + for (const subEntry of entry.data) { + if (!existsSync(entryPath)) { + mkdirSync(entryPath, { recursive: true }); + } + outputDirectoryEntry(entryPath, subEntry); + } + break; + } + default: { + throw Error( + `outputDirectoryEntry: Unknown entry type. Entry: ${JSON.stringify( + entry + )}` + ); + } + } + }; + + for (const entry of output.output.entries) { + outputDirectoryEntry(testResultDir, entry); + } + + expect(output).toMatchObject(expectedOutput); } }); diff --git a/packages/schema/bind/src/bindings/golang/functions.ts b/packages/schema/bind/src/bindings/golang/functions.ts new file mode 100644 index 0000000000..11d2d8e32b --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/functions.ts @@ -0,0 +1,374 @@ +import { reservedWordsAS } from "./reservedWords"; +import { MustacheFn } from "../types"; + +let num = -1; + +export const startIter: MustacheFn = () => { + return (): string => { + num = -1; + return ""; + }; +}; + +export const stopIter: MustacheFn = () => { + return (): string => { + num = -1; + return ""; + }; +}; + +export const currIter: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const rendered: string = render(text); + return `${rendered}${num}`; + }; +}; + +export const nextIter: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const rendered: string = render(text); + return `${rendered}${++num}`; + }; +}; + +export const prevFullIter: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const rendered: string = render(text); + if (rendered == "stop") { + return ""; + } + return Array(num) + .fill(0) + .map((_, i) => `[${rendered}${i}]`) + .join(""); + }; +}; + +export const lastFullIter: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const rendered: string = render(text); + if (rendered == "stop") { + return ""; + } + return Array(num + 1) + .fill(0) + .map((_, i) => `[${rendered}${i}]`) + .join(""); + }; +}; + +export const writePointer: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const [type, value] = render(text).split(" - "); + let pointer = "*"; + switch (type) { + case "BigInt": + case "Json": + case "Bytes": + pointer = ""; + break; + } + return `writer.Write${type}(${pointer}${value})`; + }; +}; + +export const readPointer: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const [type, value] = render(text).split(" - "); + let pointer = "&"; + switch (type) { + case "BigInt": + case "Json": + case "Bytes": + pointer = ""; + break; + } + return `${pointer}${value}`; + }; +}; + +export const toSnakeCase: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + text = render(text).replace(/([A-Z])/g, "_$1"); + text = text.startsWith("_") ? text.slice(1) : text; + return text.toLowerCase(); + }; +}; + +export const makeImports: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const types = render(text).split(","); + const exist: { [key: string]: boolean } = {}; + for (let t of types) { + t = t.trim(); + if (t.endsWith("big.Int")) { + exist["github.com/polywrap/go-wrap/msgpack/big"] = true; + } else if (t.endsWith("fastjson.Value")) { + exist["github.com/valyala/fastjson"] = true; + } else if (/([^/\s]+\/)(.*)/.test(t)) { + exist[t] = true; + } + } + const imports: Array = []; + imports.push(...Object.keys(exist)); + const txt = imports + .sort() + .map((imp) => { + let res = ""; + if (imp.startsWith(". ")) { + res = `. "${imp.slice(2)}"`; + } else { + const parts = imp.split(" as "); + if (parts.length > 1) { + res = `${parts[1]} "${parts[0]}"`; + } else { + res = `"${imp}"`; + } + } + return `\t${res}`; + }) + .join("\n"); + return txt !== "" ? `\nimport (\n${txt}\n)\n\n` : "\n"; + }; +}; + +export const stuctProps: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const props: [string, string][] = render(text) + .split("\n") + .map((line) => line.trimEnd()) + .filter((line) => line !== "") + .map((line) => line.split(" ") as [string, string]); + let maxPropNameLn = 0; + for (const [propName] of props) { + if (propName.length > maxPropNameLn) { + maxPropNameLn = propName.length; + } + } + for (let i = 0; i < props.length; i++) { + if (props[i][0].length < maxPropNameLn) { + props[i][0] += Array(maxPropNameLn - props[i][0].length) + .fill(" ") + .join(""); + } + props[i][0] = "\t" + props[i][0]; + } + return props.map((v) => v.join(" ")).join("\n") + "\n"; + }; +}; + +export const handleKeywords: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const rendered: string = render(text); + if (reservedWordsAS.has(rendered)) { + return "m_" + rendered; + } + return rendered; + }; +}; + +export const toMsgPack: MustacheFn = () => { + return (value: string, render: (template: string) => string) => { + let type = render(value); + if (type[type.length - 1] === "!") { + type = type.substring(0, type.length - 1); + } + let t = type; + if (type.startsWith("[")) { + t = "Array"; + } else if (type.startsWith("Map")) { + t = "Map"; + } else if (type.startsWith("Int8")) { + t = "I8"; + } else if (type.startsWith("Int16")) { + t = "I16"; + } else if (type.startsWith("Int32")) { + t = "I32"; + } else if (type.startsWith("Int64")) { + t = "I64"; + } else if (type.startsWith("Int")) { + t = "I32"; + } else if (type.startsWith("UInt8")) { + t = "U8"; + } else if (type.startsWith("UInt16")) { + t = "U16"; + } else if (type.startsWith("UInt32")) { + t = "U32"; + } else if (type.startsWith("UInt64")) { + t = "U64"; + } else if (type.startsWith("UInt")) { + t = "U32"; + } else if (type.startsWith("String")) { + t = "String"; + } else if (type.startsWith("Boolean")) { + t = "Bool"; + } else if (type.startsWith("Bytes")) { + t = "Bytes"; + } else if (type.startsWith("BigInt")) { + t = "BigInt"; + } else if (type.startsWith("BigNumber")) { + t = "BigInt"; + } else if (type.startsWith("JSON")) { + t = "Json"; + } + return t; + }; +}; + +export const toWasm: MustacheFn = () => { + return (value: string, render: (template: string) => string) => { + let type = render(value); + let isEnum = false; + + let optional = false; + if (type[type.length - 1] === "!") { + type = type.substring(0, type.length - 1); + } else { + optional = true; + } + + if (type[0] === "[") { + return toWasmArray(type, optional); + } + + if (type.startsWith("Map<")) { + return toWasmMap(type, optional); + } + + switch (type) { + case "Int": + type = "int32"; + break; + case "Int8": + type = "int8"; + break; + case "Int16": + type = "int16"; + break; + case "Int32": + type = "int32"; + break; + case "Int64": + type = "int64"; + break; + case "UInt": + type = "uint32"; + break; + case "UInt8": + type = "uint8"; + break; + case "UInt16": + type = "uint16"; + break; + case "UInt32": + type = "uint32"; + break; + case "UInt64": + type = "uint64"; + break; + case "String": + type = "string"; + break; + case "Boolean": + type = "bool"; + break; + case "Bytes": + type = "[]byte"; + break; + case "BigInt": + type = "*big.Int"; + break; + case "BigNumber": + type = "*big.Int"; + break; + case "JSON": + type = "*fastjson.Value"; + break; + default: + if (type.includes("Enum_")) { + type = `${type.replace("Enum_", "")}`; + isEnum = true; + } else { + type = type.charAt(0).toUpperCase() + type.slice(1); + } + } + + return applyOptional(type, optional, isEnum); + }; +}; + +const toWasmArray = (type: string, optional: boolean): string => { + const result = type.match(/(\[)([[\]A-Za-z0-9_.!]+)(\])/); + + if (!result || result.length !== 4) { + throw Error(`Invalid Array: ${type}`); + } + + const wasmType = toWasm()(result[2], (str) => str); + return applyOptional(`[]${wasmType}`, optional, false); +}; + +const toWasmMap = (type: string, optional: boolean): string => { + const firstOpenBracketIdx = type.indexOf("<"); + const lastCloseBracketIdx = type.lastIndexOf(">"); + + if (!(firstOpenBracketIdx !== -1 && lastCloseBracketIdx !== -1)) { + throw new Error(`Invalid Map: ${type}`); + } + + const keyValTypes = type + .substring(firstOpenBracketIdx + 1, lastCloseBracketIdx) + .split(","); + + if (keyValTypes.length < 2) { + throw new Error(`Invalid Map: ${type}`); + } + + const keyType = toWasm()(keyValTypes[0].trim(), (str) => str); + const valType = toWasm()(keyValTypes.slice(1).join(",").trim(), (str) => str); + + return applyOptional(`map[${keyType}]${valType}`, optional, false); +}; + +const applyOptional = (type: string, optional: boolean, _: boolean): string => { + if ( + optional && + !type.startsWith("*") && + !type.startsWith("[]") && + !type.startsWith("map") + ) { + return `*${type}`; + } else { + return type; + } +}; + +export const toLower: MustacheFn = () => { + return (value: string, render: (template: string) => string) => { + return render(value) + .split("") + .map((v) => v.toLowerCase()) + .join(""); + }; +}; + +export const toFirstLower: MustacheFn = () => { + return (value: string, render: (template: string) => string) => { + const type = render(value); + return type.charAt(0).toLowerCase() + type.slice(1); + }; +}; + +export const toUpper: MustacheFn = () => { + return (value: string, render: (template: string) => string) => { + const type = render(value); + return type.charAt(0).toUpperCase() + type.slice(1); + }; +}; + +export const pkgName: MustacheFn = () => { + return (text: string, render: (template: string) => string): string => { + const name = render(text); + return reservedWordsAS.has(name) ? `pkg${name}` : name; + }; +}; diff --git a/packages/schema/bind/src/bindings/golang/index.ts b/packages/schema/bind/src/bindings/golang/index.ts new file mode 100644 index 0000000000..a01310ad9e --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/index.ts @@ -0,0 +1,3 @@ +export * as Wasm from "./wasm"; +export * as Functions from "./functions"; +export * as Types from "./types"; diff --git a/packages/schema/bind/src/bindings/golang/reservedWords.ts b/packages/schema/bind/src/bindings/golang/reservedWords.ts new file mode 100644 index 0000000000..696a767cb4 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/reservedWords.ts @@ -0,0 +1,226 @@ +// based on: +// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#keywords +// - https://github.com/AssemblyScript/assemblyscript/blob/f54dbfb527842f3d68f18643bb614d104b4f0160/src/common.ts#L107 +// - https://github.com/AssemblyScript/assemblyscript/blob/f54dbfb527842f3d68f18643bb614d104b4f0160/src/tokenizer.ts#L181 +export const reservedWordsAS: Set = new Set([ + "async", + "await", + "arguments", + "abstract", + "as", + "break", + "const", + "class", + "catch", + "case", + "continue", + "constructor", + "default", + "declare", + "do", + "delete", + "debugger", + "else", + "enum", + "export", + "extends", + "for", + "from", + "function", + "finally", + "get", + "if", + "in", + "is", + "implements", + "import", + "instanceof", + "interface", + "keyof", + "let", + "module", + "new", + "namespace", + "of", + "private", + "package", + "public", + "protected", + "return", + "readonly", + "switch", + "static", + "set", + "super", + "this", + "type", + "try", + "throw", + "typeof", + "var", + "while", + "with", + "yield", + // types + "i8", + "i16", + "i32", + "i64", + "isize", + "u8", + "u16", + "u32", + "u64", + "usize", + "bool", + "f32", + "f64", + "v128", + "funcref", + "externref", + "anyref", + "eqref", + "i31ref", + "dataref", + "i8x16", + "u8x16", + "i16x8", + "u16x8", + "i32x4", + "u32x4", + "i64x2", + "u64x2", + "f32x4", + "f64x2", + "void", + "number", + "boolean", + "string", + "native", + "indexof", + "valueof", + "returnof", + "nonnull", + // aliases + "null", + "true", + "false", + // constants + "ASC_TARGET", + "ASC_RUNTIME", + "ASC_NO_ASSERT", + "ASC_MEMORY_BASE", + "ASC_TABLE_BASE", + "ASC_OPTIMIZE_LEVEL", + "ASC_SHRINK_LEVEL", + "ASC_LOW_MEMORY_LIMIT", + "ASC_EXPORT_RUNTIME", + "ASC_WASI", + "ASC_FEATURE_SIGN_EXTENSION", + "ASC_FEATURE_MUTABLE_GLOBALS", + "ASC_FEATURE_NONTRAPPING_F2I", + "ASC_FEATURE_BULK_MEMORY", + "ASC_FEATURE_SIMD", + "ASC_FEATURE_THREADS", + "ASC_FEATURE_EXCEPTION_HANDLING", + "ASC_FEATURE_TAIL_CALLS", + "ASC_FEATURE_REFERENCE_TYPES", + "ASC_FEATURE_MULTI_VALUE", + "ASC_FEATURE_GC", + "ASC_FEATURE_MEMORY64", + "ASC_VERSION_MAJOR", + "ASC_VERSION_MINOR", + "ASC_VERSION_PATCH", + // classes + "I8", + "I16", + "I32", + "I64", + "Isize", + "U8", + "U16", + "U32", + "U64", + "Usize", + "Bool", + "F32", + "F64", + "V128", + "Funcref", + "Externref", + "Anyref", + "Eqref", + "I31ref", + "Dataref", + "String", + "Object", + "Array", + "StaticArray", + "Set", + "Map", + "Function", + "ArrayBufferView", + "ArrayBuffer", + "Math", + "Mathf", + "NativeMath", + "NativeMathf", + "Int8Array", + "Int16Array", + "Int32Array", + "Int64Array", + "Uint8Array", + "Uint8ClampedArray", + "Uint16Array", + "Uint32Array", + "Uint64Array", + "Float32Array", + "Float64Array", + "TemplateStringsArray", + "Error", + // runtime + "abort", + "trace", + "seed", + "pow", + "ipow32", + "ipow64", + "mod", + "__alloc", + "__realloc", + "__free", + "__new", + "__renew", + "__link", + "__collect", + "__typeinfo", + "__instanceof", + "__visit", + "__newBuffer", + "__newArray", + "break", + "default", + "func", + "interface", + "select", + "case", + "defer", + "go", + "map", + "struct", + "chan", + "else", + "goto", + "package", + "switch", + "const", + "fallthrough", + "if", + "range", + "type", + "continue", + "for", + "import", + "return", + "var", +]); diff --git a/packages/schema/bind/src/bindings/golang/transforms/index.ts b/packages/schema/bind/src/bindings/golang/transforms/index.ts new file mode 100644 index 0000000000..7533ca0186 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/transforms/index.ts @@ -0,0 +1 @@ +export * from "./moduleNeedsTypes"; diff --git a/packages/schema/bind/src/bindings/golang/transforms/moduleNeedsTypes.ts b/packages/schema/bind/src/bindings/golang/transforms/moduleNeedsTypes.ts new file mode 100644 index 0000000000..060a8f9936 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/transforms/moduleNeedsTypes.ts @@ -0,0 +1,51 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { isBaseType, isBuiltInType } from "../types"; + +import { + MethodDefinition, + ModuleDefinition, +} from "@polywrap/wrap-manifest-types-js"; +import { AbiTransforms } from "@polywrap/schema-parse"; + +interface ModuleNeedsTypesState { + moduleDefinition?: ModuleDefinition; + needsTypes?: boolean; +} + +export function moduleNeedsTypes(): AbiTransforms { + const state: ModuleNeedsTypesState = {}; + + return { + enter: { + ModuleDefinition: (def: ModuleDefinition) => { + state.moduleDefinition = def; + state.needsTypes = false; + return def; + }, + MethodDefinition: (def: MethodDefinition) => { + if (def.arguments && def.arguments.length > 0) { + state.needsTypes = true; + } + + if (def.return) { + const returnType = def.return.type; + if (!isBaseType(returnType) && !isBuiltInType(returnType)) { + state.needsTypes = true; + } + } + return def; + }, + }, + leave: { + ModuleDefinition: (def: ModuleDefinition) => { + const needsTypes = state.needsTypes; + state.moduleDefinition = undefined; + state.needsTypes = undefined; + return { + ...def, + needsTypes, + }; + }, + }, + }; +} diff --git a/packages/schema/bind/src/bindings/golang/types.ts b/packages/schema/bind/src/bindings/golang/types.ts new file mode 100644 index 0000000000..8c2087252d --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/types.ts @@ -0,0 +1,38 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +const baseTypes = { + UInt: "UInt", + UInt8: "UInt8", + UInt16: "UInt16", + UInt32: "UInt32", + UInt64: "UInt64", + Int: "Int", + Int8: "Int8", + Int16: "Int16", + Int32: "Int32", + Int64: "Int64", + String: "String", + Boolean: "Boolean", + Bytes: "Bytes", +}; + +export type BaseTypes = typeof baseTypes; + +export type BaseType = keyof BaseTypes; + +export function isBaseType(type: string): type is BaseType { + return type in baseTypes; +} + +const builtInTypes = { + BigInt: "BigInt", + BigNumber: "BigNumber", + JSON: "JSON", +}; + +export type BuiltInTypes = typeof builtInTypes; + +export type BuiltInType = keyof BuiltInTypes; + +export function isBuiltInType(type: string): type is BuiltInType { + return type in builtInTypes; +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/index.ts b/packages/schema/bind/src/bindings/golang/wasm/index.ts new file mode 100644 index 0000000000..5aee1e7ebf --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/index.ts @@ -0,0 +1,281 @@ +import { Functions } from "../"; +import { GenerateBindingFn } from "../.."; +import { renderTemplates } from "../.."; +import { loadSubTemplates } from "../../utils"; +import { BindOptions, BindOutput } from "../../.."; +import { reservedWordsAS } from "../reservedWords"; +import * as Transforms from "../transforms"; + +import { + Abi, + transformAbi, + addFirstLast, + extendType, + toPrefixedGraphQLType, +} from "@polywrap/schema-parse"; +import { OutputEntry, readDirectorySync } from "@polywrap/os-js"; +import path from "path"; + +const templatesDir = readDirectorySync(path.join(__dirname, "./templates")); +const subTemplates = loadSubTemplates(templatesDir.entries); +const templatePath = (subpath: string) => + path.join(__dirname, "./templates", subpath); + +function pkgName(str: string): string { + return reservedWordsAS.has(str) ? `pkg${str}` : str; +} + +function camel2snake(str: string): string { + str = str.replace(/([A-Z])/g, "_$1"); + str = str.startsWith("_") ? str.slice(1) : str; + return str.toLowerCase(); +} + +export const generateBinding: GenerateBindingFn = ( + options: BindOptions +): BindOutput => { + const result: BindOutput = { + output: { + entries: [], + }, + outputDirAbs: options.outputDirAbs, + }; + const output = result.output; + const abi = applyTransforms(options.abi); + const goImport = options.config?.goModuleName; + + if (!goImport) { + throw Error( + "wasm/golang bindings requires the config property 'goModuleName' to be set" + ); + } + + // Generate object type folders + if (abi.objectTypes) { + for (const objectType of abi.objectTypes) { + output.entries.push({ + type: "Directory", + name: "types", + data: renderTemplates( + templatePath("object-type"), + objectType, + subTemplates + ), + }); + } + } + + // Generate imported folder + const importEntries: OutputEntry[] = []; + + // Generate imported module type folders + if (abi.importedModuleTypes) { + for (const importedModuleType of abi.importedModuleTypes) { + importEntries.push({ + type: "Directory", + name: `${pkgName(camel2snake(importedModuleType.namespace))}`, + data: renderTemplates( + templatePath("imported/module-type"), + importedModuleType, + subTemplates + ), + }); + } + } + + // // Generate imported env type folders + if (abi.importedEnvTypes) { + for (const importedEnvType of abi.importedEnvTypes) { + importEntries.push({ + type: "Directory", + name: `${pkgName(camel2snake(importedEnvType.namespace))}`, + data: renderTemplates( + templatePath("imported/env-type"), + importedEnvType, + subTemplates + ), + }); + } + } + + // Generate imported enum type folders + if (abi.importedEnumTypes) { + for (const importedEnumType of abi.importedEnumTypes) { + importEntries.push({ + type: "Directory", + name: `${pkgName(camel2snake(importedEnumType.namespace))}`, + data: renderTemplates( + templatePath("imported/enum-type"), + importedEnumType, + subTemplates + ), + }); + } + } + + // Generate imported object type folders + if (abi.importedObjectTypes) { + for (const importedObectType of abi.importedObjectTypes) { + importEntries.push({ + type: "Directory", + name: `${pkgName(camel2snake(importedObectType.namespace))}`, + data: renderTemplates( + templatePath("imported/object-type"), + importedObectType, + subTemplates + ), + }); + } + } + + if (importEntries.length) { + output.entries.push({ + type: "Directory", + name: "imported", + data: [ + ...importEntries, + ...renderTemplates(templatePath("imported"), abi, subTemplates), + ], + }); + } + + // Generate interface type folders + if (abi.interfaceTypes) { + for (const interfaceType of abi.interfaceTypes) { + output.entries.push({ + type: "Directory", + name: "interfaces", + data: renderTemplates( + templatePath("interface-type"), + interfaceType, + subTemplates + ), + }); + } + } + + // Generate module type folders + if (abi.moduleType) { + const imports: { [key: string]: boolean } = {}; + abi.moduleType.methods?.forEach(function (method) { + method.arguments?.forEach(function (arg) { + const tp = abi.importedObjectTypes?.find(function (mt) { + return mt.type === arg.type; + }); + if (tp) { + imports[tp.namespace] = true; + } + }); + }); + const importedTypes = Object.keys(imports).map((namespace) => ({ + namespace, + })); + output.entries.push({ + type: "Directory", + name: "types", + data: renderTemplates( + templatePath("module-type/types"), + { importedTypes, goImport, ...abi.moduleType }, + subTemplates + ), + }); + output.entries.push({ + type: "Directory", + name: "module_wrapped", + data: renderTemplates( + templatePath("module-type/module_wrapped"), + { importedTypes, goImport, ...abi.moduleType }, + subTemplates + ), + }); + } + + // Generate enum type folders + if (abi.enumTypes) { + for (const enumType of abi.enumTypes) { + output.entries.push({ + type: "Directory", + name: "types", + data: renderTemplates( + templatePath("enum-type"), + enumType, + subTemplates + ), + }); + } + } + + // Generate env type folders + if (abi.envType) { + output.entries.push({ + type: "Directory", + name: "types", + data: renderTemplates( + templatePath("object-type"), + abi.envType, + subTemplates + ), + }); + } + + // Generate root entry file + output.entries.push({ + type: "Directory", + name: "main", + data: renderTemplates( + templatePath("main"), + { goImport, ...abi }, + subTemplates + ), + }); + + // Render the root directory + output.entries.push( + ...renderTemplates(templatePath(""), { goImport, ...abi }, subTemplates) + ); + + output.entries = mergePaths(output.entries); + + return result; +}; + +function mergePaths(array: OutputEntry[]): OutputEntry[] { + const tmp: { [key: string]: OutputEntry } = {}; + for (let i = 0; i < array.length; i++) { + switch (array[i].type) { + case "File": + tmp[array[i].name] = array[i]; + break; + case "Directory": + if (!tmp[array[i].name]) { + tmp[array[i].name] = array[i]; + } else { + (tmp[array[i].name].data as OutputEntry[]).push( + ...(array[i].data as OutputEntry[]) + ); + } + break; + } + } + array = Object.values(tmp); + for (let i = 0; i < array.length; i++) { + if (array[i].type === "Directory") { + array[i].data = mergePaths(array[i].data as OutputEntry[]); + } + } + return array; +} + +function applyTransforms(abi: Abi): Abi { + const transforms = [ + extendType(Functions), + addFirstLast, + toPrefixedGraphQLType, + Transforms.moduleNeedsTypes(), + ]; + + for (const transform of transforms) { + abi = transformAbi(abi, transform); + } + return abi; +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_array.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_array.mustache new file mode 100644 index 0000000000..c66ee906d9 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_array.mustache @@ -0,0 +1,23 @@ +if reader.IsNil() { + _{{name}}{{#lastFullIter}}i{{/lastFullIter}} = nil +} else { + {{#nextIter}}ln{{/nextIter}} := reader.ReadArrayLength() + _{{name}}{{#prevFullIter}}i{{/prevFullIter}} = make({{#toWasm}}{{toGraphQLType}}{{/toWasm}}, {{#currIter}}ln{{/currIter}}) + for {{#currIter}}i{{/currIter}} := uint32(0); {{#currIter}}i{{/currIter}} < {{#currIter}}ln{{/currIter}}; {{#currIter}}i{{/currIter}}++ { + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{> deserialize_array}} + {{/array}} + {{#map}} + {{> deserialize_map}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_enum.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_enum.mustache new file mode 100644 index 0000000000..b5ac1f35bb --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_enum.mustache @@ -0,0 +1,11 @@ +{{#required}} +_{{name}}{{#lastFullIter}}i{{/lastFullIter}} = {{#toUpper}}{{type}}{{/toUpper}}(reader.ReadI32()) +Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(int32(_{{name}}{{#lastFullIter}}i{{/lastFullIter}})) +{{/required}} +{{^required}} +if !reader.IsNil() { + v := {{#toUpper}}{{type}}{{/toUpper}}(reader.ReadI32()) + Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(int32(v)) + _{{name}}{{#lastFullIter}}i{{/lastFullIter}} = &v +} +{{/required}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_map.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_map.mustache new file mode 100644 index 0000000000..409d6c97db --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_map.mustache @@ -0,0 +1,24 @@ +if reader.IsNil() { + _{{name}}{{#lastFullIter}}i{{/lastFullIter}} = nil +} else { + {{#nextIter}}ln{{/nextIter}} := reader.ReadMapLength() + _{{name}}{{#prevFullIter}}i{{/prevFullIter}} = make({{#toWasm}}{{toGraphQLType}}{{/toWasm}}) + for {{#currIter}}j{{/currIter}} := uint32(0); {{#currIter}}j{{/currIter}} < {{#currIter}}ln{{/currIter}}; {{#currIter}}j{{/currIter}}++ { + {{#currIter}}i{{/currIter}} := reader.Read{{#key}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}{{/key}}() + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{> deserialize_array}} + {{/array}} + {{#map}} + {{> deserialize_map}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_object.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_object.mustache new file mode 100644 index 0000000000..6fc0c5ba2f --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_object.mustache @@ -0,0 +1,8 @@ +if v := {{#toUpper}}{{type}}{{/toUpper}}Read(reader); v != nil { + {{#required}} + _{{name}}{{#lastFullIter}}i{{/lastFullIter}} = *v + {{/required}} + {{^required}} + _{{name}}{{#lastFullIter}}i{{/lastFullIter}} = v + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_scalar.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_scalar.mustache new file mode 100644 index 0000000000..2c65dc5c0e --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$deserialize_scalar.mustache @@ -0,0 +1,9 @@ +{{#required}} +_{{name}}{{#lastFullIter}}i{{/lastFullIter}} = reader.Read{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}() +{{/required}} +{{^required}} +if !reader.IsNil() { + v := reader.Read{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}() + _{{name}}{{#lastFullIter}}i{{/lastFullIter}} = {{#readPointer}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}} - v{{/readPointer}} +} +{{/required}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_array.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_array.mustache new file mode 100644 index 0000000000..0607326928 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_array.mustache @@ -0,0 +1,24 @@ +if value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#lastFullIter}}i{{/lastFullIter}} == nil { + writer.WriteNil() +} else if len(value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#lastFullIter}}i{{/lastFullIter}}) == 0 { + writer.WriteNil() +} else { + writer.WriteArrayLength(uint32(len(value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#lastFullIter}}i{{/lastFullIter}}))) + for {{#nextIter}}i{{/nextIter}} := range value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#prevFullIter}}i{{/prevFullIter}} { + {{#scalar}} + {{> serialize_scalar}} + {{/scalar}} + {{#enum}} + {{> serialize_enum}} + {{/enum}} + {{#array}} + {{> serialize_array}} + {{/array}} + {{#map}} + {{> serialize_map_value}} + {{/map}} + {{#object}} + {{> serialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_enum.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_enum.mustache new file mode 100644 index 0000000000..cf2d5be270 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_enum.mustache @@ -0,0 +1,13 @@ +{ + v := value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#lastFullIter}}i{{/lastFullIter}} + {{#required}} + writer.WriteI32(int32(v)) + {{/required}} + {{^required}} + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_map.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_map.mustache new file mode 100644 index 0000000000..3191f3ad83 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_map.mustache @@ -0,0 +1,24 @@ +if value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}} == nil { + writer.WriteNil() +} else if len(value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}) == 0 { + writer.WriteNil() +} else { + for {{#nextIter}}i{{/nextIter}} := range value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#getPrevIter}}i{{/getPrevIter}} { + writer.Write{{#key}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}{{/key}}({{#currIter}}i{{/currIter}}) + {{#scalar}} + {{> serialize_scalar}} + {{/scalar}} + {{#enum}} + {{> serialize_enum}} + {{/enum}} + {{#array}} + {{> serialize_array}} + {{/array}} + {{#map}} + {{> serialize_map}} + {{/map}} + {{#object}} + {{> serialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_object.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_object.mustache new file mode 100644 index 0000000000..62c6d07eeb --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_object.mustache @@ -0,0 +1,9 @@ +{ + v := value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#lastFullIter}}i{{/lastFullIter}} + {{#required}} + {{#toUpper}}{{type}}{{/toUpper}}Write(writer, &v) + {{/required}} + {{^required}} + {{#toUpper}}{{type}}{{/toUpper}}Write(writer, v) + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_scalar.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_scalar.mustache new file mode 100644 index 0000000000..322a1867ce --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$serialize_scalar.mustache @@ -0,0 +1,13 @@ +{ + v := value.{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}{{#lastFullIter}}i{{/lastFullIter}} + {{#required}} + writer.Write{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}(v) + {{/required}} + {{^required}} + if v == nil { + writer.WriteNil() + } else { + {{#writePointer}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}} - v{{/writePointer}} + } + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_array.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_array.mustache new file mode 100644 index 0000000000..808965046e --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_array.mustache @@ -0,0 +1,23 @@ +if reader.IsNil() { + value{{#lastFullIter}}i{{/lastFullIter}} = nil +} else { + {{#nextIter}}ln{{/nextIter}} := reader.ReadArrayLength() + value{{#prevFullIter}}i{{/prevFullIter}} = make({{#toWasm}}{{toGraphQLType}}{{/toWasm}}, {{#currIter}}ln{{/currIter}}) + for {{#currIter}}i{{/currIter}} := uint32(0); {{#currIter}}i{{/currIter}} < {{#currIter}}ln{{/currIter}}; {{#currIter}}i{{/currIter}}++ { + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{> deserialize_array}} + {{/array}} + {{#map}} + {{> deserialize_map}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_enum.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_enum.mustache new file mode 100644 index 0000000000..b498c3d4f5 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_enum.mustache @@ -0,0 +1,11 @@ +{{#required}} +value{{#lastFullIter}}i{{/lastFullIter}} = {{#toUpper}}{{type}}{{/toUpper}}(reader.ReadI32()) +Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(int32(_{{name}}{{#lastFullIter}}i{{/lastFullIter}})) +{{/required}} +{{^required}} +if !reader.IsNil() { + v := {{#toUpper}}{{type}}{{/toUpper}}(reader.ReadI32()) + Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(int32(v)) + value{{#lastFullIter}}i{{/lastFullIter}} = &v +} +{{/required}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_map.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_map.mustache new file mode 100644 index 0000000000..c0eeaa66d6 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_map.mustache @@ -0,0 +1,24 @@ +if reader.IsNil() { + value{{#lastFullIter}}i{{/lastFullIter}} = nil +} else { + {{#nextIter}}ln{{/nextIter}} := reader.ReadMapLength() + value{{#prevFullIter}}i{{/prevFullIter}} = make({{#toWasm}}{{toGraphQLType}}{{/toWasm}}) + for {{#currIter}}j{{/currIter}} := uint32(0); {{#currIter}}j{{/currIter}} < {{#currIter}}ln{{/currIter}}; {{#currIter}}j{{/currIter}}++ { + {{#currIter}}i{{/currIter}} := reader.Read{{#key}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}{{/key}}() + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{> deserialize_array}} + {{/array}} + {{#map}} + {{> deserialize_map}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_object.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_object.mustache new file mode 100644 index 0000000000..2a7c26cd0c --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_object.mustache @@ -0,0 +1,8 @@ +if v := {{#toUpper}}{{type}}{{/toUpper}}Read(reader); v != nil { + {{#required}} + value{{#lastFullIter}}i{{/lastFullIter}} = *v + {{/required}} + {{^required}} + value{{#lastFullIter}}i{{/lastFullIter}} = v + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_scalar.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_scalar.mustache new file mode 100644 index 0000000000..09966bd026 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_deserialize_scalar.mustache @@ -0,0 +1,9 @@ +{{#required}} +value{{#lastFullIter}}i{{/lastFullIter}} = reader.Read{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}() +{{/required}} +{{^required}} +if !reader.IsNil() { + v := reader.Read{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}() + value{{#lastFullIter}}i{{/lastFullIter}} = {{#readPointer}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}} - v{{/readPointer}} +} +{{/required}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_array.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_array.mustache new file mode 100644 index 0000000000..e70e40e7cf --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_array.mustache @@ -0,0 +1,24 @@ +if value{{#lastFullIter}}i{{/lastFullIter}} == nil { + writer.WriteNil() +} else if len(value{{#lastFullIter}}i{{/lastFullIter}}) == 0 { + writer.WriteNil() +} else { + writer.WriteArrayLength(uint32(len(value{{#lastFullIter}}i{{/lastFullIter}}))) + for {{#nextIter}}i{{/nextIter}} := range value{{#prevFullIter}}i{{/prevFullIter}} { + {{#scalar}} + {{> value_serialize_scalar}} + {{/scalar}} + {{#enum}} + {{> value_serialize_enum}} + {{/enum}} + {{#array}} + {{> value_serialize_array}} + {{/array}} + {{#map}} + {{> value_serialize_map}} + {{/map}} + {{#object}} + {{> value_serialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_enum.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_enum.mustache new file mode 100644 index 0000000000..590702b638 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_enum.mustache @@ -0,0 +1,13 @@ +{ + v := value{{#lastFullIter}}i{{/lastFullIter}} + {{#required}} + writer.WriteI32(int32(v)) + {{/required}} + {{^required}} + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_map.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_map.mustache new file mode 100644 index 0000000000..41b00f5949 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_map.mustache @@ -0,0 +1,24 @@ +if value == nil { + writer.WriteNil() +} else if len(value) == 0 { + writer.WriteNil() +} else { + for {{#nextIter}}i{{/nextIter}} := range value{{#getPrevIter}}i{{/getPrevIter}} { + writer.Write{{#key}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}{{/key}}({{#currIter}}i{{/currIter}}) + {{#scalar}} + {{> value_serialize_scalar}} + {{/scalar}} + {{#enum}} + {{> value_serialize_enum}} + {{/enum}} + {{#array}} + {{> value_serialize_array}} + {{/array}} + {{#map}} + {{> value_serialize_map}} + {{/map}} + {{#object}} + {{> value_serialize_object}} + {{/object}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_object.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_object.mustache new file mode 100644 index 0000000000..3b6ae4d7c6 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_object.mustache @@ -0,0 +1,9 @@ +{ + v := value{{#lastFullIter}}i{{/lastFullIter}} + {{#required}} + {{#toUpper}}{{type}}{{/toUpper}}Write(writer, &v) + {{/required}} + {{^required}} + {{#toUpper}}{{type}}{{/toUpper}}Write(writer, v) + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_scalar.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_scalar.mustache new file mode 100644 index 0000000000..440c44f87c --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/$value_serialize_scalar.mustache @@ -0,0 +1,13 @@ +{ + v := value{{#lastFullIter}}i{{/lastFullIter}} + {{#required}} + writer.Write{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}}(v) + {{/required}} + {{^required}} + if v == nil { + writer.WriteNil() + } else { + {{#writePointer}}{{#toMsgPack}}{{toGraphQLType}}{{/toMsgPack}} - v{{/writePointer}} + } + {{/required}} +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/enum-type/Enum%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/enum-type/Enum%type%-go.mustache new file mode 100644 index 0000000000..f88d287c1b --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/enum-type/Enum%type%-go.mustache @@ -0,0 +1,41 @@ +package types + +type {{#toUpper}}{{type}}{{/toUpper}} int32 + +const ( +{{#stuctProps}} +{{#constants}} +{{#toUpper}}{{type}}{{/toUpper}}{{.}} = iota +{{/constants}} +{{#toFirstLower}}{{type}}{{/toFirstLower}}Max = iota +{{/stuctProps}} +) + +func Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(value int32) { + if !(value >= 0 && value < int32({{#toFirstLower}}{{type}}{{/toFirstLower}}Max)) { + panic("Invalid value for enum '{{#toUpper}}{{type}}{{/toUpper}}'") + } +} + +func Get{{#toUpper}}{{type}}{{/toUpper}}Value(key string) {{#toUpper}}{{type}}{{/toUpper}} { + switch key { + {{#constants}} + case "{{.}}": + return {{#toUpper}}{{type}}{{/toUpper}}{{.}} + {{/constants}} + default: + panic("Invalid key for enum '{{#toUpper}}{{type}}{{/toUpper}}'") + } +} + +func Get{{#toUpper}}{{type}}{{/toUpper}}Key(value {{#toUpper}}{{type}}{{/toUpper}}) string { + Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(int32(value)) + switch value { + {{#constants}} + case {{#toUpper}}{{type}}{{/toUpper}}{{.}}: + return "{{.}}" + {{/constants}} + default: + panic("Invalid value for enum '{{#toUpper}}{{type}}{{/toUpper}}'") + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/env-type/Env%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/env-type/Env%type%-go.mustache new file mode 100644 index 0000000000..a64e346848 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/env-type/Env%type%-go.mustache @@ -0,0 +1,27 @@ +package types + +{{#makeImports}}github.com/polywrap/go-wrap/msgpack,{{#properties}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}}{{/properties}}{{/makeImports}} + +type {{#toUpper}}{{type}}{{/toUpper}} struct { + {{#stuctProps}} + {{#properties}} + {{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} `json:"{{name}}"` + {{/properties}} + {{/stuctProps}} +} + +func {{#toUpper}}{{type}}{{/toUpper}}ToBuffer(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + return serialize{{#toUpper}}{{type}}{{/toUpper}}(value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}FromBuffer(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + return deserialize{{#toUpper}}{{type}}{{/toUpper}}(data) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Write(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + write{{#toUpper}}{{type}}{{/toUpper}}(writer, value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Read(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/env-type/Env%type%Serialization-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/env-type/Env%type%Serialization-go.mustache new file mode 100644 index 0000000000..03f0b548fa --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/env-type/Env%type%Serialization-go.mustache @@ -0,0 +1,108 @@ +package types + +{{#makeImports}}github.com/polywrap/go-wrap/msgpack,{{#properties}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}}{{/properties}}{{/makeImports}} + +func serialize{{#toUpper}}{{type}}{{/toUpper}}(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + encoder := msgpack.NewWriteEncoder(ctx) + write{{#toUpper}}{{type}}{{/toUpper}}(encoder, value) + return encoder.Buffer() +} + +func write{{#toUpper}}{{type}}{{/toUpper}}(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + writer.WriteMapLength({{properties.length}}) + {{#properties}} + writer.Context().Push("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}", "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "writing property") + writer.WriteString("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}") + {{#scalar}} + {{> serialize_scalar}} + {{/scalar}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> serialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> serialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> serialize_object}} + {{/object}} + {{#enum}} + {{> serialize_enum}} + {{/enum}} + writer.Context().Pop() + {{/properties}} +} + +func deserialize{{#toUpper}}{{type}}{{/toUpper}}(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + reader := msgpack.NewReadDecoder(ctx, data) + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} + +func read{{#toUpper}}{{type}}{{/toUpper}}(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + var ( + {{#stuctProps}} + {{#properties}} + _{{name}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} + {{#required}} + _{{name}}Set bool + {{/required}} + {{/properties}} + {{/stuctProps}} + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + {{#properties}} + case "{{name}}": + reader.Context().Push(field, "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "type found, reading property") + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> deserialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> deserialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + {{#required}} + _{{name}}Set = true + {{/required}} + reader.Context().Pop() + {{/properties}} + } + reader.Context().Pop() + } + + {{#properties}} + {{#required}} + if !_{{name}}Set { + panic(reader.Context().PrintWithContext("Missing required property: '{{name}}: {{type}}'")) + } + {{/required}} + {{/properties}} + + return &{{#toUpper}}{{type}}{{/toUpper}}{ + {{#stuctProps}} + {{#properties}} + {{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}: _{{name}}, + {{/properties}} + {{/stuctProps}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/enum-type/Enum%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/enum-type/Enum%type%-go.mustache new file mode 100644 index 0000000000..72cd7bfeb6 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/enum-type/Enum%type%-go.mustache @@ -0,0 +1,41 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} + +type {{#toUpper}}{{type}}{{/toUpper}} int32 + +const ( +{{#stuctProps}} +{{#constants}} +{{#toUpper}}{{type}}{{/toUpper}}{{.}} = iota +{{/constants}} +{{#toFirstLower}}{{type}}{{/toFirstLower}}Max = iota +{{/stuctProps}} +) + +func Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(value int32) { + if !(value >= 0 && value < int32({{#toFirstLower}}{{type}}{{/toFirstLower}}Max)) { + panic("Invalid value for enum '{{#toUpper}}{{type}}{{/toUpper}}'") + } +} + +func Get{{#toUpper}}{{type}}{{/toUpper}}Value(key string) {{#toUpper}}{{type}}{{/toUpper}} { + switch key { + {{#constants}} + case "{{.}}": + return {{#toUpper}}{{type}}{{/toUpper}}{{.}} + {{/constants}} + default: + panic("Invalid key for enum '{{#toUpper}}{{type}}{{/toUpper}}'") + } +} + +func Get{{#toUpper}}{{type}}{{/toUpper}}Key(value {{#toUpper}}{{type}}{{/toUpper}}) string { + Sanitize{{#toUpper}}{{type}}{{/toUpper}}Value(int32(value)) + switch value { + {{#constants}} + case {{#toUpper}}{{type}}{{/toUpper}}{{.}}: + return "{{.}}" + {{/constants}} + default: + panic("Invalid value for enum '{{#toUpper}}{{type}}{{/toUpper}}'") + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/env-type/Env%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/env-type/Env%type%-go.mustache new file mode 100644 index 0000000000..70cc14ba31 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/env-type/Env%type%-go.mustache @@ -0,0 +1,30 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#properties}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}} + {{/properties}} +{{/makeImports}} +type {{#toUpper}}{{type}}{{/toUpper}} struct { +{{#stuctProps}} +{{#properties}} +{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} `json:"{{name}}"` +{{/properties}} +{{/stuctProps}} +} + +func {{#toUpper}}{{type}}{{/toUpper}}ToBuffer(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + return serialize{{#toUpper}}{{type}}{{/toUpper}}(value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}FromBuffer(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + return deserialize{{#toUpper}}{{type}}{{/toUpper}}(data) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Write(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + write{{#toUpper}}{{type}}{{/toUpper}}(writer, value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Read(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/env-type/Env%type%Serialization-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/env-type/Env%type%Serialization-go.mustache new file mode 100644 index 0000000000..0b03fc04e1 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/env-type/Env%type%Serialization-go.mustache @@ -0,0 +1,111 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#properties}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}} + {{/properties}} +{{/makeImports}} +func serialize{{#toUpper}}{{type}}{{/toUpper}}(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + encoder := msgpack.NewWriteEncoder(ctx) + write{{#toUpper}}{{type}}{{/toUpper}}(encoder, value) + return encoder.Buffer() +} + +func write{{#toUpper}}{{type}}{{/toUpper}}(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + writer.WriteMapLength({{properties.length}}) + {{#properties}} + writer.Context().Push("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}", "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "writing property") + writer.WriteString("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}") + {{#scalar}} + {{> serialize_scalar}} + {{/scalar}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> serialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> serialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> serialize_object}} + {{/object}} + {{#enum}} + {{> serialize_enum}} + {{/enum}} + writer.Context().Pop() + {{/properties}} +} + +func deserialize{{#toUpper}}{{type}}{{/toUpper}}(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + reader := msgpack.NewReadDecoder(ctx, data) + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} + +func read{{#toUpper}}{{type}}{{/toUpper}}(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + var ( + {{#stuctProps}} + {{#properties}} + _{{name}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} + {{#required}} + _{{name}}Set bool + {{/required}} + {{/properties}} + {{/stuctProps}} + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + {{#properties}} + case "{{name}}": + reader.Context().Push(field, "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "type found, reading property") + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> deserialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> deserialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + {{#required}} + _{{name}}Set = true + {{/required}} + reader.Context().Pop() + {{/properties}} + } + reader.Context().Pop() + } + + {{#properties}} + {{#required}} + if !_{{name}}Set { + panic(reader.Context().PrintWithContext("Missing required property: '{{name}}: {{type}}'")) + } + {{/required}} + {{/properties}} + + return &{{#toUpper}}{{type}}{{/toUpper}}{ + {{#stuctProps}} + {{#properties}} + {{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}: _{{name}}, + {{/properties}} + {{/stuctProps}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/interface-type/%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/interface-type/%type%-go.mustache new file mode 100644 index 0000000000..bc55d77962 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/interface-type/%type%-go.mustache @@ -0,0 +1,19 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} + +{{#capabilities}} +{{#getImplementations}} +{{#enabled}} +import "github.com/polywrap/go-wrap/wrap" +{{/enabled}} +{{/getImplementations}} +{{/capabilities}} + +{{#capabilities}} +{{#getImplementations}} +{{#enabled}} +func {{#toUpper}}{{namespace}}{{/toUpper}}Implementations() []string { + return wrap.WrapGetImplementations("{{uri}}") +} +{{/enabled}} +{{/getImplementations}} +{{/capabilities}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/module-type/%type%Serialization-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/module-type/%type%Serialization-go.mustache new file mode 100644 index 0000000000..24e8033ed4 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/module-type/%type%Serialization-go.mustache @@ -0,0 +1,90 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#arguments}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}} + {{/arguments}} +{{/makeImports}} +{{#methods}} +type Args{{#toUpper}}{{name}}{{/toUpper}} struct { +{{#stuctProps}} +{{#arguments}} +{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} `json:"{{name}}"` +{{/arguments}} +{{/stuctProps}} +} + +func Serialize{{#toUpper}}{{name}}{{/toUpper}}Args(value *Args{{#toUpper}}{{name}}{{/toUpper}}) []byte { + ctx := msgpack.NewContext("Serializing module-type: {{#toUpper}}{{name}}{{/toUpper}}") + encoder := msgpack.NewWriteEncoder(ctx) + Write{{#toUpper}}{{name}}{{/toUpper}}Args(encoder, value) + return encoder.Buffer() +} + +func Write{{#toUpper}}{{name}}{{/toUpper}}Args(writer msgpack.Write, value *Args{{#toUpper}}{{name}}{{/toUpper}}) { + {{#arguments.length}} + writer.WriteMapLength({{arguments.length}}) + {{/arguments.length}} + {{^arguments}} + writer.WriteMapLength(0) + {{/arguments}} + {{#arguments}} + writer.Context().Push("{{name}}", "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "writing property") + writer.WriteString("{{name}}") + {{#scalar}} + {{> serialize_scalar}} + {{/scalar}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> serialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> serialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> serialize_object}} + {{/object}} + {{#enum}} + {{> serialize_enum}} + {{/enum}} + writer.Context().Pop() + {{/arguments}} +} + +func Deserialize{{#toUpper}}{{name}}{{/toUpper}}Result(argsBuf []byte) {{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}} { + ctx := msgpack.NewContext("Deserializing module-type: {{#toUpper}}{{name}}{{/toUpper}}") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + {{#return}} + reader.Context().Push("{{name}}", "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "reading function output") + var value {{#toWasm}}{{toGraphQLType}}{{/toWasm}} + {{#scalar}} + {{> value_deserialize_scalar}} + {{/scalar}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> value_deserialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> value_deserialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> value_deserialize_object}} + {{/object}} + {{#enum}} + {{> value_deserialize_enum}} + {{/enum}} + reader.Context().Pop() + return value + {{/return}} +} +{{^last}} + +{{/last}} +{{/methods}} \ No newline at end of file diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/module-type/%type%Wrapped-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/module-type/%type%Wrapped-go.mustache new file mode 100644 index 0000000000..72c3adf3c3 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/module-type/%type%Wrapped-go.mustache @@ -0,0 +1,48 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} + +{{#methods.length}} +import ( + "github.com/polywrap/go-wrap/wrap" +) +{{/methods.length}} + +{{^isInterface}} +{{#methods}} +func {{#toUpper}}{{name}}{{/toUpper}}(args *Args{{#toUpper}}{{name}}{{/toUpper}}) ({{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}}, error) { + argsBuf := Serialize{{#toUpper}}{{name}}{{/toUpper}}Args(args) + var ( + err error + raw []byte + data {{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}} + ) + raw, err = wrap.WrapSubinvoke("{{uri}}", "{{name}}", argsBuf) + if err == nil { + data = Deserialize{{#toUpper}}{{name}}{{/toUpper}}Result(raw) + } + return data, err +} +{{^last}} + +{{/last}} +{{/methods}} +{{/isInterface}} +{{#isInterface}} +{{#methods}} +func {{#toUpper}}{{name}}{{/toUpper}}(uri string, args *Args{{#toUpper}}{{name}}{{/toUpper}}) ({{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}}, error) { + argsBuf := Serialize{{#toUpper}}{{name}}{{/toUpper}}Args(args) + var ( + err error + raw []byte + data {{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}} + ) + raw, err = wrap.WrapSubinvokeImplementation("{{uri}}", uri, "{{name}}", argsBuf) + if err == nil { + data = Deserialize{{#toUpper}}{{name}}{{/toUpper}}Result(raw) + } + return data, err +} +{{^last}} + +{{/last}} +{{/methods}} +{{/isInterface}} \ No newline at end of file diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/object-type/Object%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/object-type/Object%type%-go.mustache new file mode 100644 index 0000000000..70cc14ba31 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/object-type/Object%type%-go.mustache @@ -0,0 +1,30 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#properties}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}} + {{/properties}} +{{/makeImports}} +type {{#toUpper}}{{type}}{{/toUpper}} struct { +{{#stuctProps}} +{{#properties}} +{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} `json:"{{name}}"` +{{/properties}} +{{/stuctProps}} +} + +func {{#toUpper}}{{type}}{{/toUpper}}ToBuffer(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + return serialize{{#toUpper}}{{type}}{{/toUpper}}(value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}FromBuffer(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + return deserialize{{#toUpper}}{{type}}{{/toUpper}}(data) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Write(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + write{{#toUpper}}{{type}}{{/toUpper}}(writer, value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Read(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/imported/object-type/Object%type%Serialization-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/object-type/Object%type%Serialization-go.mustache new file mode 100644 index 0000000000..4620a8e956 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/imported/object-type/Object%type%Serialization-go.mustache @@ -0,0 +1,111 @@ +package {{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}} +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#properties}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}} + {{/properties}} +{{/makeImports}} +func serialize{{#toUpper}}{{type}}{{/toUpper}}(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + encoder := msgpack.NewWriteEncoder(ctx) + write{{#toUpper}}{{type}}{{/toUpper}}(encoder, value) + return encoder.Buffer() +} + +func write{{#toUpper}}{{type}}{{/toUpper}}(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + writer.WriteMapLength({{properties.length}}) + {{#properties}} + writer.Context().Push("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}", "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "writing property") + writer.WriteString("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}") + {{#scalar}} + {{> serialize_scalar}} + {{/scalar}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> serialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> serialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> serialize_object}} + {{/object}} + {{#enum}} + {{> serialize_enum}} + {{/enum}} + writer.Context().Pop() + {{/properties}} +} + +func deserialize{{#toUpper}}{{type}}{{/toUpper}}(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + reader := msgpack.NewReadDecoder(ctx, data) + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} + +func read{{#toUpper}}{{type}}{{/toUpper}}(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + var ( + {{#stuctProps}} + {{#properties}} + _{{name}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} + {{#required}} + _{{name}}Set bool + {{/required}} + {{/properties}} + {{/stuctProps}} + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + {{#properties}} + case "{{name}}": + reader.Context().Push(field, "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "type found, reading property") + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> deserialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> deserialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + {{#required}} + _{{name}}Set = true + {{/required}} + reader.Context().Pop() + {{/properties}} + } + reader.Context().Pop() + } + + {{#properties}} + {{#required}} + if !_{{name}}Set { + panic(reader.Context().PrintWithContext("Missing required property: '{{name}}: {{type}}'")) + } + {{/required}} + {{/properties}} + + return &{{#toUpper}}{{type}}{{/toUpper}}{ + {{#stuctProps}} + {{#properties}} + {{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}: _{{name}}, + {{/properties}} + {{/stuctProps}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/interface-type/%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/interface-type/%type%-go.mustache new file mode 100644 index 0000000000..a3fa1c1a68 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/interface-type/%type%-go.mustache @@ -0,0 +1,19 @@ +package interfaces + +{{#capabilities}} +{{#getImplementations}} +{{#enabled}} +import "github.com/polywrap/go-wrap/wrap" +{{/enabled}} +{{/getImplementations}} +{{/capabilities}} + +{{#capabilities}} +{{#getImplementations}} +{{#enabled}} +func {{#toUpper}}{{namespace}}{{/toUpper}}Implementations() []string { + return wrap.WrapGetImplementations("{{uri}}") +} +{{/enabled}} +{{/getImplementations}} +{{/capabilities}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/main/main-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/main/main-go.mustache new file mode 100644 index 0000000000..583f70dacd --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/main/main-go.mustache @@ -0,0 +1,24 @@ +package main + +import ( + "{{goImport}}/module/wrap/module_wrapped" + "github.com/polywrap/go-wrap/wrap" +) + +//export _wrap_invoke +func _wrap_invoke(methodSize, argsSize, envSize uint32) bool { + args := wrap.WrapInvokeArgs(methodSize, argsSize) + switch args.Method { + {{#moduleType}} + {{#methods}} + case "{{name}}": + return wrap.WrapInvoke(args, envSize, module_wrapped.{{#toUpper}}{{name}}{{/toUpper}}Wrapped) + {{/methods}} + {{/moduleType}} + default: + return wrap.WrapInvoke(args, envSize, nil) + } +} + +func main() { +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/module_wrapped/%type%Serialization-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/module_wrapped/%type%Serialization-go.mustache new file mode 100644 index 0000000000..9f6defac57 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/module_wrapped/%type%Serialization-go.mustache @@ -0,0 +1,119 @@ +package module_wrapped +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#needsTypes}} + . {{goImport}}/module/wrap/types, + {{/needsTypes}} + {{#importedTypes}} + . {{goImport}}/module/wrap/imported/{{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}}, + {{/importedTypes}} + {{#methods}} + {{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}}, + {{/methods}} +{{/makeImports}} +{{#methods}} +{{#arguments.length}} +func Deserialize{{#toUpper}}{{name}}{{/toUpper}}Args(argsBuf []byte) *Args{{#toUpper}}{{name}}{{/toUpper}} { + ctx := msgpack.NewContext("Deserializing module-type: {{#toUpper}}{{name}}{{/toUpper}}") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + var ( + {{#stuctProps}} + {{#arguments}} + _{{name}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} + {{#required}} + _{{name}}Set bool + {{/required}} + {{/arguments}} + {{/stuctProps}} + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + {{#arguments}} + case "{{name}}": + reader.Context().Push(field, "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "type found, reading property") + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> deserialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> deserialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + {{#required}} + _{{name}}Set = true + {{/required}} + reader.Context().Pop() + {{/arguments}} + } + reader.Context().Pop() + } + + {{#arguments}} + {{#required}} + if !_{{name}}Set { + panic(reader.Context().PrintWithContext("Missing required property: '{{name}}: {{type}}'")) + } + {{/required}} + {{/arguments}} + + return &Args{{#toUpper}}{{name}}{{/toUpper}}{ + {{#stuctProps}} + {{#arguments}} + {{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}: _{{name}}, + {{/arguments}} + {{/stuctProps}} + } +} +{{/arguments.length}} + +func Serialize{{#toUpper}}{{name}}{{/toUpper}}Result(value {{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}}) []byte { + ctx := msgpack.NewContext("Serializing module-type: {{#toUpper}}{{name}}{{/toUpper}}") + encoder := msgpack.NewWriteEncoder(ctx) + Write{{#toUpper}}{{name}}{{/toUpper}}Result(encoder, value); + return encoder.Buffer() +} + +func Write{{#toUpper}}{{name}}{{/toUpper}}Result(writer msgpack.Write, value {{#return}}{{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{/return}}) { + {{#return}} + writer.Context().Push("{{name}}", "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "writing property") + {{#scalar}} + {{> value_serialize_scalar}} + {{/scalar}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> value_serialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> value_serialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> value_serialize_object}} + {{/object}} + {{#enum}} + {{> value_serialize_enum}} + {{/enum}} + writer.Context().Pop() + {{/return}} +} +{{^last}} + +{{/last}} +{{/methods}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/module_wrapped/%type%Wrapped-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/module_wrapped/%type%Wrapped-go.mustache new file mode 100644 index 0000000000..cd6794431f --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/module_wrapped/%type%Wrapped-go.mustache @@ -0,0 +1,31 @@ +package module_wrapped +{{#makeImports}} + {{#methods}}{{#env}}github.com/polywrap/go-wrap/wrap,{{#needsTypes}}. {{goImport}}/module/wrap/types,{{/needsTypes}}{{/env}}{{/methods}} + {{goImport}}/module as methods, +{{/makeImports}} +{{#methods}} +func {{#toUpper}}{{name}}{{/toUpper}}Wrapped(argsBuf []byte, envSize uint32) []byte { + {{#env}} + var env *Env + {{#required}} + if envSize == 0 { + panic("Environment is not set, and it is required by method 'objectMethod'") + } + {{/required}} + if envSize > 0 { + envBuf := wrap.WrapLoadEnv(envSize) + env = EnvFromBuffer(envBuf) + } + {{/env}} + + {{#arguments.length}} + args := Deserialize{{#toUpper}}{{name}}{{/toUpper}}Args(argsBuf) + {{/arguments.length}} + + result := methods.{{#toUpper}}{{name}}{{/toUpper}}({{#arguments.length}}args{{#env}},{{/env}}{{/arguments.length}}{{#env}}env{{/env}}) + return Serialize{{#toUpper}}{{name}}{{/toUpper}}Result(result) +} +{{^last}} + +{{/last}} +{{/methods}} \ No newline at end of file diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/types/%type%Args-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/types/%type%Args-go.mustache new file mode 100644 index 0000000000..4d7a27be0f --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/module-type/types/%type%Args-go.mustache @@ -0,0 +1,25 @@ +package types +{{#makeImports}} + {{#importedTypes}} + . {{goImport}}/module/wrap/imported/{{#pkgName}}{{#toSnakeCase}}{{namespace}}{{/toSnakeCase}}{{/pkgName}}, + {{/importedTypes}} + {{#methods}} + {{#arguments}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}, + {{/arguments}} + {{/methods}} +{{/makeImports}} +{{#methods}} +{{#arguments.length}} +type Args{{#toUpper}}{{name}}{{/toUpper}} struct { +{{#stuctProps}} +{{#arguments}} +{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} `json:"{{name}}"` +{{/arguments}} +{{/stuctProps}} +} +{{/arguments.length}} +{{^last}} + +{{/last}} +{{/methods}} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/object-type/Object%type%-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/object-type/Object%type%-go.mustache new file mode 100644 index 0000000000..fbd7e01f18 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/object-type/Object%type%-go.mustache @@ -0,0 +1,30 @@ +package types +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#properties}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}} + {{/properties}} +{{/makeImports}} +type {{#toUpper}}{{type}}{{/toUpper}} struct { +{{#stuctProps}} +{{#properties}} +{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} `json:"{{name}}"` +{{/properties}} +{{/stuctProps}} +} + +func {{#toUpper}}{{type}}{{/toUpper}}ToBuffer(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + return serialize{{#toUpper}}{{type}}{{/toUpper}}(value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}FromBuffer(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + return deserialize{{#toUpper}}{{type}}{{/toUpper}}(data) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Write(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + write{{#toUpper}}{{type}}{{/toUpper}}(writer, value) +} + +func {{#toUpper}}{{type}}{{/toUpper}}Read(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/object-type/Object%type%Serialization-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/object-type/Object%type%Serialization-go.mustache new file mode 100644 index 0000000000..b858842c79 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/object-type/Object%type%Serialization-go.mustache @@ -0,0 +1,110 @@ +package types +{{#makeImports}} + github.com/polywrap/go-wrap/msgpack, + {{#properties}} + {{#toWasm}}{{toGraphQLType}}{{/toWasm}}{{^last}},{{/last}} + {{/properties}} +{{/makeImports}} +func serialize{{#toUpper}}{{type}}{{/toUpper}}(value *{{#toUpper}}{{type}}{{/toUpper}}) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + encoder := msgpack.NewWriteEncoder(ctx) + write{{#toUpper}}{{type}}{{/toUpper}}(encoder, value) + return encoder.Buffer() +} + +func write{{#toUpper}}{{type}}{{/toUpper}}(writer msgpack.Write, value *{{#toUpper}}{{type}}{{/toUpper}}) { + writer.WriteMapLength({{properties.length}}) + {{#properties}} + writer.Context().Push("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}", "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "writing property") + writer.WriteString("{{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}") + {{#scalar}} + {{> serialize_scalar}} + {{/scalar}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> serialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> serialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> serialize_object}} + {{/object}} + {{#enum}} + {{> serialize_enum}} + {{/enum}} + writer.Context().Pop() + {{/properties}} +} + +func deserialize{{#toUpper}}{{type}}{{/toUpper}}(data []byte) *{{#toUpper}}{{type}}{{/toUpper}} { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: {{#toUpper}}{{type}}{{/toUpper}}") + reader := msgpack.NewReadDecoder(ctx, data) + return read{{#toUpper}}{{type}}{{/toUpper}}(reader) +} + +func read{{#toUpper}}{{type}}{{/toUpper}}(reader msgpack.Read) *{{#toUpper}}{{type}}{{/toUpper}} { + var ( + {{#stuctProps}} + {{#properties}} + _{{name}} {{#toWasm}}{{toGraphQLType}}{{/toWasm}} + {{#required}} + _{{name}}Set bool + {{/required}} + {{/properties}} + {{/stuctProps}} + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + {{#properties}} + case "{{name}}": + reader.Context().Push(field, "{{#toWasm}}{{toGraphQLType}}{{/toWasm}}", "type found, reading property") + {{#scalar}} + {{> deserialize_scalar}} + {{/scalar}} + {{#enum}} + {{> deserialize_enum}} + {{/enum}} + {{#array}} + {{#startIter}}{{/startIter}} + {{> deserialize_array}} + {{#stopIter}}{{/stopIter}} + {{/array}} + {{#map}} + {{#startIter}}{{/startIter}} + {{> deserialize_map}} + {{#stopIter}}{{/stopIter}} + {{/map}} + {{#object}} + {{> deserialize_object}} + {{/object}} + {{#required}} + _{{name}}Set = true + {{/required}} + reader.Context().Pop() + {{/properties}} + } + reader.Context().Pop() + } + + {{#properties}} + {{#required}} + if !_{{name}}Set { + panic(reader.Context().PrintWithContext("Missing required property: '{{name}}: {{type}}'")) + } + {{/required}} + {{/properties}} + return &{{#toUpper}}{{type}}{{/toUpper}}{ + {{#stuctProps}} + {{#properties}} + {{#toUpper}}{{#handleKeywords}}{{name}}{{/handleKeywords}}{{/toUpper}}: _{{name}}, + {{/properties}} + {{/stuctProps}} + } +} diff --git a/packages/schema/bind/src/bindings/golang/wasm/templates/wrap-go.mustache b/packages/schema/bind/src/bindings/golang/wasm/templates/wrap-go.mustache new file mode 100644 index 0000000000..a1080fa322 --- /dev/null +++ b/packages/schema/bind/src/bindings/golang/wasm/templates/wrap-go.mustache @@ -0,0 +1 @@ +package wrap diff --git a/packages/schema/bind/src/bindings/index.ts b/packages/schema/bind/src/bindings/index.ts index c6913c970c..c84131e131 100644 --- a/packages/schema/bind/src/bindings/index.ts +++ b/packages/schema/bind/src/bindings/index.ts @@ -4,8 +4,9 @@ import * as AssemblyScript from "./assemblyscript"; import * as Rust from "./rust"; import * as Python from "./python"; import * as TypeScript from "./typescript"; +import * as Golang from "./golang"; -export { AssemblyScript, Rust, TypeScript }; +export { AssemblyScript, Rust, TypeScript, Golang }; export * from "./types"; export * from "./utils"; @@ -17,6 +18,8 @@ export function getGenerateBindingFn( return AssemblyScript.Wasm.generateBinding; case "wasm-rs": return Rust.Wasm.generateBinding; + case "wasm-go": + return Golang.Wasm.generateBinding; case "plugin-ts": return TypeScript.Plugin.generateBinding; case "plugin-rs": diff --git a/packages/schema/bind/src/bindings/utils.ts b/packages/schema/bind/src/bindings/utils.ts index fdcd426fe4..dc7256606a 100644 --- a/packages/schema/bind/src/bindings/utils.ts +++ b/packages/schema/bind/src/bindings/utils.ts @@ -1,7 +1,21 @@ import { OutputEntry, readDirectorySync } from "@polywrap/os-js"; +import { GenericDefinition } from "@polywrap/schema-parse"; import Mustache from "mustache"; import path from "path"; +function transformName(str: string, view: unknown): string { + str = str.replace("-", "."); + if (!str.endsWith(".go")) { + return str; + } + const def = view as GenericDefinition; + str = str + .replace("%type%", def.type) + .replace(/([A-Z])/g, "_$1") + .toLowerCase(); + return str.startsWith("_") ? str.slice(1) : str; +} + export function renderTemplates( templateDirAbs: string, view: unknown, @@ -27,7 +41,7 @@ export function renderTemplates( if (data) { output.push({ type: "File", - name: name.replace("-", "."), + name: transformName(name, view), data, }); } diff --git a/packages/schema/bind/src/types.ts b/packages/schema/bind/src/types.ts index 8ba900f272..5b3d9df6da 100644 --- a/packages/schema/bind/src/types.ts +++ b/packages/schema/bind/src/types.ts @@ -4,6 +4,7 @@ import { WrapAbi } from "@polywrap/schema-parse"; export type BindLanguage = | "wasm-as" | "wasm-rs" + | "wasm-go" | "plugin-ts" | "plugin-rs" | "plugin-py" diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/enum_test_import__enum.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/enum_test_import__enum.go new file mode 100644 index 0000000000..e70a6de407 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/enum_test_import__enum.go @@ -0,0 +1,38 @@ +package test_import + +type TestImport_Enum int32 + +const ( + TestImport_EnumSTRING = iota + TestImport_EnumBYTES = iota + testImport_EnumMax = iota +) + +func SanitizeTestImport_EnumValue(value int32) { + if !(value >= 0 && value < int32(testImport_EnumMax)) { + panic("Invalid value for enum 'TestImport_Enum'") + } +} + +func GetTestImport_EnumValue(key string) TestImport_Enum { + switch key { + case "STRING": + return TestImport_EnumSTRING + case "BYTES": + return TestImport_EnumBYTES + default: + panic("Invalid key for enum 'TestImport_Enum'") + } +} + +func GetTestImport_EnumKey(value TestImport_Enum) string { + SanitizeTestImport_EnumValue(int32(value)) + switch value { + case TestImport_EnumSTRING: + return "STRING" + case TestImport_EnumBYTES: + return "BYTES" + default: + panic("Invalid value for enum 'TestImport_Enum'") + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/enum_test_import__enum__return.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/enum_test_import__enum__return.go new file mode 100644 index 0000000000..893faccee3 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/enum_test_import__enum__return.go @@ -0,0 +1,38 @@ +package test_import + +type TestImport_Enum_Return int32 + +const ( + TestImport_Enum_ReturnSTRING = iota + TestImport_Enum_ReturnBYTES = iota + testImport_Enum_ReturnMax = iota +) + +func SanitizeTestImport_Enum_ReturnValue(value int32) { + if !(value >= 0 && value < int32(testImport_Enum_ReturnMax)) { + panic("Invalid value for enum 'TestImport_Enum_Return'") + } +} + +func GetTestImport_Enum_ReturnValue(key string) TestImport_Enum_Return { + switch key { + case "STRING": + return TestImport_Enum_ReturnSTRING + case "BYTES": + return TestImport_Enum_ReturnBYTES + default: + panic("Invalid key for enum 'TestImport_Enum_Return'") + } +} + +func GetTestImport_Enum_ReturnKey(value TestImport_Enum_Return) string { + SanitizeTestImport_Enum_ReturnValue(int32(value)) + switch value { + case TestImport_Enum_ReturnSTRING: + return "STRING" + case TestImport_Enum_ReturnBYTES: + return "BYTES" + default: + panic("Invalid value for enum 'TestImport_Enum_Return'") + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/env_test_import__env.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/env_test_import__env.go new file mode 100644 index 0000000000..5478dd8ab9 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/env_test_import__env.go @@ -0,0 +1,32 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type TestImport_Env struct { + Object TestImport_AnotherObject `json:"object"` + OptObject *TestImport_AnotherObject `json:"optObject"` + ObjectArray []TestImport_AnotherObject `json:"objectArray"` + OptObjectArray []*TestImport_AnotherObject `json:"optObjectArray"` + En TestImport_Enum `json:"en"` + OptEnum *TestImport_Enum `json:"optEnum"` + EnumArray []TestImport_Enum `json:"enumArray"` + OptEnumArray []*TestImport_Enum `json:"optEnumArray"` +} + +func TestImport_EnvToBuffer(value *TestImport_Env) []byte { + return serializeTestImport_Env(value) +} + +func TestImport_EnvFromBuffer(data []byte) *TestImport_Env { + return deserializeTestImport_Env(data) +} + +func TestImport_EnvWrite(writer msgpack.Write, value *TestImport_Env) { + writeTestImport_Env(writer, value) +} + +func TestImport_EnvRead(reader msgpack.Read) *TestImport_Env { + return readTestImport_Env(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/env_test_import__env_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/env_test_import__env_serialization.go new file mode 100644 index 0000000000..4d9e11029c --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/env_test_import__env_serialization.go @@ -0,0 +1,257 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +func serializeTestImport_Env(value *TestImport_Env) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: TestImport_Env") + encoder := msgpack.NewWriteEncoder(ctx) + writeTestImport_Env(encoder, value) + return encoder.Buffer() +} + +func writeTestImport_Env(writer msgpack.Write, value *TestImport_Env) { + writer.WriteMapLength(8) + writer.Context().Push("Object", "TestImport_AnotherObject", "writing property") + writer.WriteString("Object") + { + v := value.Object + TestImport_AnotherObjectWrite(writer, &v) + } + writer.Context().Pop() + writer.Context().Push("OptObject", "*TestImport_AnotherObject", "writing property") + writer.WriteString("OptObject") + { + v := value.OptObject + TestImport_AnotherObjectWrite(writer, v) + } + writer.Context().Pop() + writer.Context().Push("ObjectArray", "[]TestImport_AnotherObject", "writing property") + writer.WriteString("ObjectArray") + if value.ObjectArray == nil { + writer.WriteNil() + } else if len(value.ObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.ObjectArray))) + for i0 := range value.ObjectArray { + { + v := value.ObjectArray[i0] + TestImport_AnotherObjectWrite(writer, &v) + } + } + } + writer.Context().Pop() + writer.Context().Push("OptObjectArray", "[]*TestImport_AnotherObject", "writing property") + writer.WriteString("OptObjectArray") + if value.OptObjectArray == nil { + writer.WriteNil() + } else if len(value.OptObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptObjectArray))) + for i0 := range value.OptObjectArray { + { + v := value.OptObjectArray[i0] + TestImport_AnotherObjectWrite(writer, v) + } + } + } + writer.Context().Pop() + writer.Context().Push("En", "TestImport_Enum", "writing property") + writer.WriteString("En") + { + v := value.En + writer.WriteI32(int32(v)) + } + writer.Context().Pop() + writer.Context().Push("OptEnum", "*TestImport_Enum", "writing property") + writer.WriteString("OptEnum") + { + v := value.OptEnum + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + writer.Context().Pop() + writer.Context().Push("EnumArray", "[]TestImport_Enum", "writing property") + writer.WriteString("EnumArray") + if value.EnumArray == nil { + writer.WriteNil() + } else if len(value.EnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.EnumArray))) + for i0 := range value.EnumArray { + { + v := value.EnumArray[i0] + writer.WriteI32(int32(v)) + } + } + } + writer.Context().Pop() + writer.Context().Push("OptEnumArray", "[]*TestImport_Enum", "writing property") + writer.WriteString("OptEnumArray") + if value.OptEnumArray == nil { + writer.WriteNil() + } else if len(value.OptEnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptEnumArray))) + for i0 := range value.OptEnumArray { + { + v := value.OptEnumArray[i0] + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + } + } + writer.Context().Pop() +} + +func deserializeTestImport_Env(data []byte) *TestImport_Env { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: TestImport_Env") + reader := msgpack.NewReadDecoder(ctx, data) + return readTestImport_Env(reader) +} + +func readTestImport_Env(reader msgpack.Read) *TestImport_Env { + var ( + _object TestImport_AnotherObject + _objectSet bool + _optObject *TestImport_AnotherObject + _objectArray []TestImport_AnotherObject + _objectArraySet bool + _optObjectArray []*TestImport_AnotherObject + _en TestImport_Enum + _enSet bool + _optEnum *TestImport_Enum + _enumArray []TestImport_Enum + _enumArraySet bool + _optEnumArray []*TestImport_Enum + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "object": + reader.Context().Push(field, "TestImport_AnotherObject", "type found, reading property") + if v := TestImport_AnotherObjectRead(reader); v != nil { + _object = *v + } + _objectSet = true + reader.Context().Pop() + case "optObject": + reader.Context().Push(field, "*TestImport_AnotherObject", "type found, reading property") + if v := TestImport_AnotherObjectRead(reader); v != nil { + _optObject = v + } + reader.Context().Pop() + case "objectArray": + reader.Context().Push(field, "[]TestImport_AnotherObject", "type found, reading property") + if reader.IsNil() { + _objectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _objectArray = make([]TestImport_AnotherObject, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := TestImport_AnotherObjectRead(reader); v != nil { + _objectArray[i0] = *v + } + } + } + _objectArraySet = true + reader.Context().Pop() + case "optObjectArray": + reader.Context().Push(field, "[]*TestImport_AnotherObject", "type found, reading property") + if reader.IsNil() { + _optObjectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optObjectArray = make([]*TestImport_AnotherObject, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := TestImport_AnotherObjectRead(reader); v != nil { + _optObjectArray[i0] = v + } + } + } + reader.Context().Pop() + case "en": + reader.Context().Push(field, "TestImport_Enum", "type found, reading property") + _en = TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(_en)) + _enSet = true + reader.Context().Pop() + case "optEnum": + reader.Context().Push(field, "*TestImport_Enum", "type found, reading property") + if !reader.IsNil() { + v := TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(v)) + _optEnum = &v + } + reader.Context().Pop() + case "enumArray": + reader.Context().Push(field, "[]TestImport_Enum", "type found, reading property") + if reader.IsNil() { + _enumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _enumArray = make([]TestImport_Enum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + _enumArray[i0] = TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(_enumArray[i0])) + } + } + _enumArraySet = true + reader.Context().Pop() + case "optEnumArray": + reader.Context().Push(field, "[]*TestImport_Enum", "type found, reading property") + if reader.IsNil() { + _optEnumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optEnumArray = make([]*TestImport_Enum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if !reader.IsNil() { + v := TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(v)) + _optEnumArray[i0] = &v + } + } + } + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_objectSet { + panic(reader.Context().PrintWithContext("Missing required property: 'object: TestImport_AnotherObject'")) + } + if !_objectArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'objectArray: [TestImport_AnotherObject]'")) + } + if !_enSet { + panic(reader.Context().PrintWithContext("Missing required property: 'en: TestImport_Enum'")) + } + if !_enumArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'enumArray: [TestImport_Enum]'")) + } + + return &TestImport_Env{ + Object: _object, + OptObject: _optObject, + ObjectArray: _objectArray, + OptObjectArray: _optObjectArray, + En: _en, + OptEnum: _optEnum, + EnumArray: _enumArray, + OptEnumArray: _optEnumArray, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__another_object.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__another_object.go new file mode 100644 index 0000000000..f01380602e --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__another_object.go @@ -0,0 +1,25 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type TestImport_AnotherObject struct { + Prop string `json:"prop"` +} + +func TestImport_AnotherObjectToBuffer(value *TestImport_AnotherObject) []byte { + return serializeTestImport_AnotherObject(value) +} + +func TestImport_AnotherObjectFromBuffer(data []byte) *TestImport_AnotherObject { + return deserializeTestImport_AnotherObject(data) +} + +func TestImport_AnotherObjectWrite(writer msgpack.Write, value *TestImport_AnotherObject) { + writeTestImport_AnotherObject(writer, value) +} + +func TestImport_AnotherObjectRead(reader msgpack.Read) *TestImport_AnotherObject { + return readTestImport_AnotherObject(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__another_object_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__another_object_serialization.go new file mode 100644 index 0000000000..a92be912ea --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__another_object_serialization.go @@ -0,0 +1,57 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +func serializeTestImport_AnotherObject(value *TestImport_AnotherObject) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: TestImport_AnotherObject") + encoder := msgpack.NewWriteEncoder(ctx) + writeTestImport_AnotherObject(encoder, value) + return encoder.Buffer() +} + +func writeTestImport_AnotherObject(writer msgpack.Write, value *TestImport_AnotherObject) { + writer.WriteMapLength(1) + writer.Context().Push("Prop", "string", "writing property") + writer.WriteString("Prop") + { + v := value.Prop + writer.WriteString(v) + } + writer.Context().Pop() +} + +func deserializeTestImport_AnotherObject(data []byte) *TestImport_AnotherObject { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: TestImport_AnotherObject") + reader := msgpack.NewReadDecoder(ctx, data) + return readTestImport_AnotherObject(reader) +} + +func readTestImport_AnotherObject(reader msgpack.Read) *TestImport_AnotherObject { + var ( + _prop string + _propSet bool + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "prop": + reader.Context().Push(field, "string", "type found, reading property") + _prop = reader.ReadString() + _propSet = true + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_propSet { + panic(reader.Context().PrintWithContext("Missing required property: 'prop: String'")) + } + + return &TestImport_AnotherObject{ + Prop: _prop, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__object.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__object.go new file mode 100644 index 0000000000..1fc1c743a3 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__object.go @@ -0,0 +1,32 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type TestImport_Object struct { + Object TestImport_AnotherObject `json:"object"` + OptObject *TestImport_AnotherObject `json:"optObject"` + ObjectArray []TestImport_AnotherObject `json:"objectArray"` + OptObjectArray []*TestImport_AnotherObject `json:"optObjectArray"` + En TestImport_Enum `json:"en"` + OptEnum *TestImport_Enum `json:"optEnum"` + EnumArray []TestImport_Enum `json:"enumArray"` + OptEnumArray []*TestImport_Enum `json:"optEnumArray"` +} + +func TestImport_ObjectToBuffer(value *TestImport_Object) []byte { + return serializeTestImport_Object(value) +} + +func TestImport_ObjectFromBuffer(data []byte) *TestImport_Object { + return deserializeTestImport_Object(data) +} + +func TestImport_ObjectWrite(writer msgpack.Write, value *TestImport_Object) { + writeTestImport_Object(writer, value) +} + +func TestImport_ObjectRead(reader msgpack.Read) *TestImport_Object { + return readTestImport_Object(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__object_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__object_serialization.go new file mode 100644 index 0000000000..14a99ed24e --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/object_test_import__object_serialization.go @@ -0,0 +1,257 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +func serializeTestImport_Object(value *TestImport_Object) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: TestImport_Object") + encoder := msgpack.NewWriteEncoder(ctx) + writeTestImport_Object(encoder, value) + return encoder.Buffer() +} + +func writeTestImport_Object(writer msgpack.Write, value *TestImport_Object) { + writer.WriteMapLength(8) + writer.Context().Push("Object", "TestImport_AnotherObject", "writing property") + writer.WriteString("Object") + { + v := value.Object + TestImport_AnotherObjectWrite(writer, &v) + } + writer.Context().Pop() + writer.Context().Push("OptObject", "*TestImport_AnotherObject", "writing property") + writer.WriteString("OptObject") + { + v := value.OptObject + TestImport_AnotherObjectWrite(writer, v) + } + writer.Context().Pop() + writer.Context().Push("ObjectArray", "[]TestImport_AnotherObject", "writing property") + writer.WriteString("ObjectArray") + if value.ObjectArray == nil { + writer.WriteNil() + } else if len(value.ObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.ObjectArray))) + for i0 := range value.ObjectArray { + { + v := value.ObjectArray[i0] + TestImport_AnotherObjectWrite(writer, &v) + } + } + } + writer.Context().Pop() + writer.Context().Push("OptObjectArray", "[]*TestImport_AnotherObject", "writing property") + writer.WriteString("OptObjectArray") + if value.OptObjectArray == nil { + writer.WriteNil() + } else if len(value.OptObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptObjectArray))) + for i0 := range value.OptObjectArray { + { + v := value.OptObjectArray[i0] + TestImport_AnotherObjectWrite(writer, v) + } + } + } + writer.Context().Pop() + writer.Context().Push("En", "TestImport_Enum", "writing property") + writer.WriteString("En") + { + v := value.En + writer.WriteI32(int32(v)) + } + writer.Context().Pop() + writer.Context().Push("OptEnum", "*TestImport_Enum", "writing property") + writer.WriteString("OptEnum") + { + v := value.OptEnum + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + writer.Context().Pop() + writer.Context().Push("EnumArray", "[]TestImport_Enum", "writing property") + writer.WriteString("EnumArray") + if value.EnumArray == nil { + writer.WriteNil() + } else if len(value.EnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.EnumArray))) + for i0 := range value.EnumArray { + { + v := value.EnumArray[i0] + writer.WriteI32(int32(v)) + } + } + } + writer.Context().Pop() + writer.Context().Push("OptEnumArray", "[]*TestImport_Enum", "writing property") + writer.WriteString("OptEnumArray") + if value.OptEnumArray == nil { + writer.WriteNil() + } else if len(value.OptEnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptEnumArray))) + for i0 := range value.OptEnumArray { + { + v := value.OptEnumArray[i0] + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + } + } + writer.Context().Pop() +} + +func deserializeTestImport_Object(data []byte) *TestImport_Object { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: TestImport_Object") + reader := msgpack.NewReadDecoder(ctx, data) + return readTestImport_Object(reader) +} + +func readTestImport_Object(reader msgpack.Read) *TestImport_Object { + var ( + _object TestImport_AnotherObject + _objectSet bool + _optObject *TestImport_AnotherObject + _objectArray []TestImport_AnotherObject + _objectArraySet bool + _optObjectArray []*TestImport_AnotherObject + _en TestImport_Enum + _enSet bool + _optEnum *TestImport_Enum + _enumArray []TestImport_Enum + _enumArraySet bool + _optEnumArray []*TestImport_Enum + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "object": + reader.Context().Push(field, "TestImport_AnotherObject", "type found, reading property") + if v := TestImport_AnotherObjectRead(reader); v != nil { + _object = *v + } + _objectSet = true + reader.Context().Pop() + case "optObject": + reader.Context().Push(field, "*TestImport_AnotherObject", "type found, reading property") + if v := TestImport_AnotherObjectRead(reader); v != nil { + _optObject = v + } + reader.Context().Pop() + case "objectArray": + reader.Context().Push(field, "[]TestImport_AnotherObject", "type found, reading property") + if reader.IsNil() { + _objectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _objectArray = make([]TestImport_AnotherObject, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := TestImport_AnotherObjectRead(reader); v != nil { + _objectArray[i0] = *v + } + } + } + _objectArraySet = true + reader.Context().Pop() + case "optObjectArray": + reader.Context().Push(field, "[]*TestImport_AnotherObject", "type found, reading property") + if reader.IsNil() { + _optObjectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optObjectArray = make([]*TestImport_AnotherObject, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := TestImport_AnotherObjectRead(reader); v != nil { + _optObjectArray[i0] = v + } + } + } + reader.Context().Pop() + case "en": + reader.Context().Push(field, "TestImport_Enum", "type found, reading property") + _en = TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(_en)) + _enSet = true + reader.Context().Pop() + case "optEnum": + reader.Context().Push(field, "*TestImport_Enum", "type found, reading property") + if !reader.IsNil() { + v := TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(v)) + _optEnum = &v + } + reader.Context().Pop() + case "enumArray": + reader.Context().Push(field, "[]TestImport_Enum", "type found, reading property") + if reader.IsNil() { + _enumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _enumArray = make([]TestImport_Enum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + _enumArray[i0] = TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(_enumArray[i0])) + } + } + _enumArraySet = true + reader.Context().Pop() + case "optEnumArray": + reader.Context().Push(field, "[]*TestImport_Enum", "type found, reading property") + if reader.IsNil() { + _optEnumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optEnumArray = make([]*TestImport_Enum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if !reader.IsNil() { + v := TestImport_Enum(reader.ReadI32()) + SanitizeTestImport_EnumValue(int32(v)) + _optEnumArray[i0] = &v + } + } + } + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_objectSet { + panic(reader.Context().PrintWithContext("Missing required property: 'object: TestImport_AnotherObject'")) + } + if !_objectArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'objectArray: [TestImport_AnotherObject]'")) + } + if !_enSet { + panic(reader.Context().PrintWithContext("Missing required property: 'en: TestImport_Enum'")) + } + if !_enumArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'enumArray: [TestImport_Enum]'")) + } + + return &TestImport_Object{ + Object: _object, + OptObject: _optObject, + ObjectArray: _objectArray, + OptObjectArray: _optObjectArray, + En: _en, + OptEnum: _optEnum, + EnumArray: _enumArray, + OptEnumArray: _optEnumArray, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/test_import__module_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/test_import__module_serialization.go new file mode 100644 index 0000000000..461da72dff --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/test_import__module_serialization.go @@ -0,0 +1,297 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type ArgsImportedMethod struct { + Str string `json:"str"` + OptStr *string `json:"optStr"` + U uint32 `json:"u"` + OptU *uint32 `json:"optU"` + UArrayArray [][]*uint32 `json:"uArrayArray"` + Object TestImport_Object `json:"object"` + OptObject *TestImport_Object `json:"optObject"` + ObjectArray []TestImport_Object `json:"objectArray"` + OptObjectArray []*TestImport_Object `json:"optObjectArray"` + En TestImport_Enum `json:"en"` + OptEnum *TestImport_Enum `json:"optEnum"` + EnumArray []TestImport_Enum `json:"enumArray"` + OptEnumArray []*TestImport_Enum `json:"optEnumArray"` +} + +func SerializeImportedMethodArgs(value *ArgsImportedMethod) []byte { + ctx := msgpack.NewContext("Serializing module-type: ImportedMethod") + encoder := msgpack.NewWriteEncoder(ctx) + WriteImportedMethodArgs(encoder, value) + return encoder.Buffer() +} + +func WriteImportedMethodArgs(writer msgpack.Write, value *ArgsImportedMethod) { + writer.WriteMapLength(13) + writer.Context().Push("str", "string", "writing property") + writer.WriteString("str") + { + v := value.Str + writer.WriteString(v) + } + writer.Context().Pop() + writer.Context().Push("optStr", "*string", "writing property") + writer.WriteString("optStr") + { + v := value.OptStr + if v == nil { + writer.WriteNil() + } else { + writer.WriteString(*v) + } + } + writer.Context().Pop() + writer.Context().Push("u", "uint32", "writing property") + writer.WriteString("u") + { + v := value.U + writer.WriteU32(v) + } + writer.Context().Pop() + writer.Context().Push("optU", "*uint32", "writing property") + writer.WriteString("optU") + { + v := value.OptU + if v == nil { + writer.WriteNil() + } else { + writer.WriteU32(*v) + } + } + writer.Context().Pop() + writer.Context().Push("uArrayArray", "[][]*uint32", "writing property") + writer.WriteString("uArrayArray") + if value.UArrayArray == nil { + writer.WriteNil() + } else if len(value.UArrayArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UArrayArray))) + for i0 := range value.UArrayArray { + if value.UArrayArray[i0] == nil { + writer.WriteNil() + } else if len(value.UArrayArray[i0]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UArrayArray[i0]))) + for i1 := range value.UArrayArray[i0] { + { + v := value.UArrayArray[i0][i1] + if v == nil { + writer.WriteNil() + } else { + writer.WriteU32(*v) + } + } + } + } + } + } + writer.Context().Pop() + writer.Context().Push("object", "TestImport_Object", "writing property") + writer.WriteString("object") + { + v := value.Object + TestImport_ObjectWrite(writer, &v) + } + writer.Context().Pop() + writer.Context().Push("optObject", "*TestImport_Object", "writing property") + writer.WriteString("optObject") + { + v := value.OptObject + TestImport_ObjectWrite(writer, v) + } + writer.Context().Pop() + writer.Context().Push("objectArray", "[]TestImport_Object", "writing property") + writer.WriteString("objectArray") + if value.ObjectArray == nil { + writer.WriteNil() + } else if len(value.ObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.ObjectArray))) + for i0 := range value.ObjectArray { + { + v := value.ObjectArray[i0] + TestImport_ObjectWrite(writer, &v) + } + } + } + writer.Context().Pop() + writer.Context().Push("optObjectArray", "[]*TestImport_Object", "writing property") + writer.WriteString("optObjectArray") + if value.OptObjectArray == nil { + writer.WriteNil() + } else if len(value.OptObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptObjectArray))) + for i0 := range value.OptObjectArray { + { + v := value.OptObjectArray[i0] + TestImport_ObjectWrite(writer, v) + } + } + } + writer.Context().Pop() + writer.Context().Push("en", "TestImport_Enum", "writing property") + writer.WriteString("en") + { + v := value.En + writer.WriteI32(int32(v)) + } + writer.Context().Pop() + writer.Context().Push("optEnum", "*TestImport_Enum", "writing property") + writer.WriteString("optEnum") + { + v := value.OptEnum + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + writer.Context().Pop() + writer.Context().Push("enumArray", "[]TestImport_Enum", "writing property") + writer.WriteString("enumArray") + if value.EnumArray == nil { + writer.WriteNil() + } else if len(value.EnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.EnumArray))) + for i0 := range value.EnumArray { + { + v := value.EnumArray[i0] + writer.WriteI32(int32(v)) + } + } + } + writer.Context().Pop() + writer.Context().Push("optEnumArray", "[]*TestImport_Enum", "writing property") + writer.WriteString("optEnumArray") + if value.OptEnumArray == nil { + writer.WriteNil() + } else if len(value.OptEnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptEnumArray))) + for i0 := range value.OptEnumArray { + { + v := value.OptEnumArray[i0] + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + } + } + writer.Context().Pop() +} + +func DeserializeImportedMethodResult(argsBuf []byte) *TestImport_Object { + ctx := msgpack.NewContext("Deserializing module-type: ImportedMethod") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + reader.Context().Push("importedMethod", "*TestImport_Object", "reading function output") + var value *TestImport_Object + if v := TestImport_ObjectRead(reader); v != nil { + value = v + } + reader.Context().Pop() + return value +} + +type ArgsAnotherMethod struct { + Arg []string `json:"arg"` +} + +func SerializeAnotherMethodArgs(value *ArgsAnotherMethod) []byte { + ctx := msgpack.NewContext("Serializing module-type: AnotherMethod") + encoder := msgpack.NewWriteEncoder(ctx) + WriteAnotherMethodArgs(encoder, value) + return encoder.Buffer() +} + +func WriteAnotherMethodArgs(writer msgpack.Write, value *ArgsAnotherMethod) { + writer.WriteMapLength(1) + writer.Context().Push("arg", "[]string", "writing property") + writer.WriteString("arg") + if value.Arg == nil { + writer.WriteNil() + } else if len(value.Arg) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.Arg))) + for i0 := range value.Arg { + { + v := value.Arg[i0] + writer.WriteString(v) + } + } + } + writer.Context().Pop() +} + +func DeserializeAnotherMethodResult(argsBuf []byte) int32 { + ctx := msgpack.NewContext("Deserializing module-type: AnotherMethod") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + reader.Context().Push("anotherMethod", "int32", "reading function output") + var value int32 + value = reader.ReadI32() + reader.Context().Pop() + return value +} + +type ArgsReturnsArrayOfEnums struct { + Arg string `json:"arg"` +} + +func SerializeReturnsArrayOfEnumsArgs(value *ArgsReturnsArrayOfEnums) []byte { + ctx := msgpack.NewContext("Serializing module-type: ReturnsArrayOfEnums") + encoder := msgpack.NewWriteEncoder(ctx) + WriteReturnsArrayOfEnumsArgs(encoder, value) + return encoder.Buffer() +} + +func WriteReturnsArrayOfEnumsArgs(writer msgpack.Write, value *ArgsReturnsArrayOfEnums) { + writer.WriteMapLength(1) + writer.Context().Push("arg", "string", "writing property") + writer.WriteString("arg") + { + v := value.Arg + writer.WriteString(v) + } + writer.Context().Pop() +} + +func DeserializeReturnsArrayOfEnumsResult(argsBuf []byte) []*TestImport_Enum_Return { + ctx := msgpack.NewContext("Deserializing module-type: ReturnsArrayOfEnums") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + reader.Context().Push("returnsArrayOfEnums", "[]*TestImport_Enum_Return", "reading function output") + var value []*TestImport_Enum_Return + if reader.IsNil() { + value = nil + } else { + ln0 := reader.ReadArrayLength() + value = make([]*TestImport_Enum_Return, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if !reader.IsNil() { + v := TestImport_Enum_Return(reader.ReadI32()) + SanitizeTestImport_Enum_ReturnValue(int32(v)) + _returnsArrayOfEnums[i0] = &v + } + } + } + reader.Context().Pop() + return value +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/test_import__module_wrapped.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/test_import__module_wrapped.go new file mode 100644 index 0000000000..54e30e516a --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/imported/test_import/test_import__module_wrapped.go @@ -0,0 +1,47 @@ +package test_import + +import ( + "github.com/polywrap/go-wrap/wrap" +) + +func ImportedMethod(uri string, args *ArgsImportedMethod) (*TestImport_Object, error) { + argsBuf := SerializeImportedMethodArgs(args) + var ( + err error + raw []byte + data *TestImport_Object + ) + raw, err = wrap.WrapSubinvokeImplementation("testimport.uri.eth", uri, "importedMethod", argsBuf) + if err == nil { + data = DeserializeImportedMethodResult(raw) + } + return data, err +} + +func AnotherMethod(uri string, args *ArgsAnotherMethod) (int32, error) { + argsBuf := SerializeAnotherMethodArgs(args) + var ( + err error + raw []byte + data int32 + ) + raw, err = wrap.WrapSubinvokeImplementation("testimport.uri.eth", uri, "anotherMethod", argsBuf) + if err == nil { + data = DeserializeAnotherMethodResult(raw) + } + return data, err +} + +func ReturnsArrayOfEnums(uri string, args *ArgsReturnsArrayOfEnums) ([]*TestImport_Enum_Return, error) { + argsBuf := SerializeReturnsArrayOfEnumsArgs(args) + var ( + err error + raw []byte + data []*TestImport_Enum_Return + ) + raw, err = wrap.WrapSubinvokeImplementation("testimport.uri.eth", uri, "returnsArrayOfEnums", argsBuf) + if err == nil { + data = DeserializeReturnsArrayOfEnumsResult(raw) + } + return data, err +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/interfaces/test_import.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/interfaces/test_import.go new file mode 100644 index 0000000000..7ae06bfb28 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/interfaces/test_import.go @@ -0,0 +1,7 @@ +package interfaces + +import "github.com/polywrap/go-wrap/wrap" + +func TestImportImplementations() []string { + return wrap.WrapGetImplementations("testimport.uri.eth") +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/main/main.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/main/main.go new file mode 100644 index 0000000000..46bbee1c6d --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/main/main.go @@ -0,0 +1,26 @@ +package main + +import ( + "github.com/testorg/testrepo/module/wrap/module_wrapped" + "github.com/polywrap/go-wrap/wrap" +) + +//export _wrap_invoke +func _wrap_invoke(methodSize, argsSize, envSize uint32) bool { + args := wrap.WrapInvokeArgs(methodSize, argsSize) + switch args.Method { + case "moduleMethod": + return wrap.WrapInvoke(args, envSize, module_wrapped.ModuleMethodWrapped) + case "objectMethod": + return wrap.WrapInvoke(args, envSize, module_wrapped.ObjectMethodWrapped) + case "optionalEnvMethod": + return wrap.WrapInvoke(args, envSize, module_wrapped.OptionalEnvMethodWrapped) + case "if": + return wrap.WrapInvoke(args, envSize, module_wrapped.IfWrapped) + default: + return wrap.WrapInvoke(args, envSize, nil) + } +} + +func main() { +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/module_wrapped/module_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/module_wrapped/module_serialization.go new file mode 100644 index 0000000000..346056af85 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/module_wrapped/module_serialization.go @@ -0,0 +1,488 @@ +package module_wrapped + +import ( + . "github.com/testorg/testrepo/module/wrap/types" + "github.com/polywrap/go-wrap/msgpack" +) + +func DeserializeModuleMethodArgs(argsBuf []byte) *ArgsModuleMethod { + ctx := msgpack.NewContext("Deserializing module-type: ModuleMethod") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + var ( + _str string + _strSet bool + _optStr *string + _en CustomEnum + _enSet bool + _optEnum *CustomEnum + _enumArray []CustomEnum + _enumArraySet bool + _optEnumArray []*CustomEnum + _map map[string]int32 + _mapSet bool + _mapOfArr map[string][]int32 + _mapOfArrSet bool + _mapOfMap map[string]map[string]int32 + _mapOfMapSet bool + _mapOfObj map[string]AnotherType + _mapOfObjSet bool + _mapOfArrOfObj map[string][]AnotherType + _mapOfArrOfObjSet bool + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "str": + reader.Context().Push(field, "string", "type found, reading property") + _str = reader.ReadString() + _strSet = true + reader.Context().Pop() + case "optStr": + reader.Context().Push(field, "*string", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadString() + _optStr = &v + } + reader.Context().Pop() + case "en": + reader.Context().Push(field, "CustomEnum", "type found, reading property") + _en = CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(_en)) + _enSet = true + reader.Context().Pop() + case "optEnum": + reader.Context().Push(field, "*CustomEnum", "type found, reading property") + if !reader.IsNil() { + v := CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(v)) + _optEnum = &v + } + reader.Context().Pop() + case "enumArray": + reader.Context().Push(field, "[]CustomEnum", "type found, reading property") + if reader.IsNil() { + _enumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _enumArray = make([]CustomEnum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + _enumArray[i0] = CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(_enumArray[i0])) + } + } + _enumArraySet = true + reader.Context().Pop() + case "optEnumArray": + reader.Context().Push(field, "[]*CustomEnum", "type found, reading property") + if reader.IsNil() { + _optEnumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optEnumArray = make([]*CustomEnum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if !reader.IsNil() { + v := CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(v)) + _optEnumArray[i0] = &v + } + } + } + reader.Context().Pop() + case "map": + reader.Context().Push(field, "map[string]int32", "type found, reading property") + if reader.IsNil() { + _map = nil + } else { + ln0 := reader.ReadMapLength() + _map = make(map[string]int32) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + _map[i0] = reader.ReadI32() + } + } + _mapSet = true + reader.Context().Pop() + case "mapOfArr": + reader.Context().Push(field, "map[string][]int32", "type found, reading property") + if reader.IsNil() { + _mapOfArr = nil + } else { + ln0 := reader.ReadMapLength() + _mapOfArr = make(map[string][]int32) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if reader.IsNil() { + _mapOfArr[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _mapOfArr[i0] = make([]int32, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + _mapOfArr[i0][i1] = reader.ReadI32() + } + } + } + } + _mapOfArrSet = true + reader.Context().Pop() + case "mapOfMap": + reader.Context().Push(field, "map[string]map[string]int32", "type found, reading property") + if reader.IsNil() { + _mapOfMap = nil + } else { + ln0 := reader.ReadMapLength() + _mapOfMap = make(map[string]map[string]int32) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if reader.IsNil() { + _mapOfMap[i0] = nil + } else { + ln1 := reader.ReadMapLength() + _mapOfMap[i0] = make(map[string]int32) + for j1 := uint32(0); j1 < ln1; j1++ { + i1 := reader.ReadString() + _mapOfMap[i0][i1] = reader.ReadI32() + } + } + } + } + _mapOfMapSet = true + reader.Context().Pop() + case "mapOfObj": + reader.Context().Push(field, "map[string]AnotherType", "type found, reading property") + if reader.IsNil() { + _mapOfObj = nil + } else { + ln0 := reader.ReadMapLength() + _mapOfObj = make(map[string]AnotherType) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if v := AnotherTypeRead(reader); v != nil { + _mapOfObj[i0] = *v + } + } + } + _mapOfObjSet = true + reader.Context().Pop() + case "mapOfArrOfObj": + reader.Context().Push(field, "map[string][]AnotherType", "type found, reading property") + if reader.IsNil() { + _mapOfArrOfObj = nil + } else { + ln0 := reader.ReadMapLength() + _mapOfArrOfObj = make(map[string][]AnotherType) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if reader.IsNil() { + _mapOfArrOfObj[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _mapOfArrOfObj[i0] = make([]AnotherType, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + if v := AnotherTypeRead(reader); v != nil { + _mapOfArrOfObj[i0][i1] = *v + } + } + } + } + } + _mapOfArrOfObjSet = true + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_strSet { + panic(reader.Context().PrintWithContext("Missing required property: 'str: String'")) + } + if !_enSet { + panic(reader.Context().PrintWithContext("Missing required property: 'en: CustomEnum'")) + } + if !_enumArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'enumArray: [CustomEnum]'")) + } + if !_mapSet { + panic(reader.Context().PrintWithContext("Missing required property: 'map: Map'")) + } + if !_mapOfArrSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapOfArr: Map'")) + } + if !_mapOfMapSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapOfMap: Map>'")) + } + if !_mapOfObjSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapOfObj: Map'")) + } + if !_mapOfArrOfObjSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapOfArrOfObj: Map'")) + } + + return &ArgsModuleMethod{ + Str: _str, + OptStr: _optStr, + En: _en, + OptEnum: _optEnum, + EnumArray: _enumArray, + OptEnumArray: _optEnumArray, + M_map: _map, + MapOfArr: _mapOfArr, + MapOfMap: _mapOfMap, + MapOfObj: _mapOfObj, + MapOfArrOfObj: _mapOfArrOfObj, + } +} + +func SerializeModuleMethodResult(value int32) []byte { + ctx := msgpack.NewContext("Serializing module-type: ModuleMethod") + encoder := msgpack.NewWriteEncoder(ctx) + WriteModuleMethodResult(encoder, value); + return encoder.Buffer() +} + +func WriteModuleMethodResult(writer msgpack.Write, value int32) { + writer.Context().Push("moduleMethod", "int32", "writing property") + { + v := value + writer.WriteI32(v) + } + writer.Context().Pop() +} + +func DeserializeObjectMethodArgs(argsBuf []byte) *ArgsObjectMethod { + ctx := msgpack.NewContext("Deserializing module-type: ObjectMethod") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + var ( + _object AnotherType + _objectSet bool + _optObject *AnotherType + _objectArray []AnotherType + _objectArraySet bool + _optObjectArray []*AnotherType + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "object": + reader.Context().Push(field, "AnotherType", "type found, reading property") + if v := AnotherTypeRead(reader); v != nil { + _object = *v + } + _objectSet = true + reader.Context().Pop() + case "optObject": + reader.Context().Push(field, "*AnotherType", "type found, reading property") + if v := AnotherTypeRead(reader); v != nil { + _optObject = v + } + reader.Context().Pop() + case "objectArray": + reader.Context().Push(field, "[]AnotherType", "type found, reading property") + if reader.IsNil() { + _objectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _objectArray = make([]AnotherType, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := AnotherTypeRead(reader); v != nil { + _objectArray[i0] = *v + } + } + } + _objectArraySet = true + reader.Context().Pop() + case "optObjectArray": + reader.Context().Push(field, "[]*AnotherType", "type found, reading property") + if reader.IsNil() { + _optObjectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optObjectArray = make([]*AnotherType, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := AnotherTypeRead(reader); v != nil { + _optObjectArray[i0] = v + } + } + } + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_objectSet { + panic(reader.Context().PrintWithContext("Missing required property: 'object: AnotherType'")) + } + if !_objectArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'objectArray: [AnotherType]'")) + } + + return &ArgsObjectMethod{ + Object: _object, + OptObject: _optObject, + ObjectArray: _objectArray, + OptObjectArray: _optObjectArray, + } +} + +func SerializeObjectMethodResult(value *AnotherType) []byte { + ctx := msgpack.NewContext("Serializing module-type: ObjectMethod") + encoder := msgpack.NewWriteEncoder(ctx) + WriteObjectMethodResult(encoder, value); + return encoder.Buffer() +} + +func WriteObjectMethodResult(writer msgpack.Write, value *AnotherType) { + writer.Context().Push("objectMethod", "*AnotherType", "writing property") + { + v := value + AnotherTypeWrite(writer, v) + } + writer.Context().Pop() +} + +func DeserializeOptionalEnvMethodArgs(argsBuf []byte) *ArgsOptionalEnvMethod { + ctx := msgpack.NewContext("Deserializing module-type: OptionalEnvMethod") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + var ( + _object AnotherType + _objectSet bool + _optObject *AnotherType + _objectArray []AnotherType + _objectArraySet bool + _optObjectArray []*AnotherType + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "object": + reader.Context().Push(field, "AnotherType", "type found, reading property") + if v := AnotherTypeRead(reader); v != nil { + _object = *v + } + _objectSet = true + reader.Context().Pop() + case "optObject": + reader.Context().Push(field, "*AnotherType", "type found, reading property") + if v := AnotherTypeRead(reader); v != nil { + _optObject = v + } + reader.Context().Pop() + case "objectArray": + reader.Context().Push(field, "[]AnotherType", "type found, reading property") + if reader.IsNil() { + _objectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _objectArray = make([]AnotherType, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := AnotherTypeRead(reader); v != nil { + _objectArray[i0] = *v + } + } + } + _objectArraySet = true + reader.Context().Pop() + case "optObjectArray": + reader.Context().Push(field, "[]*AnotherType", "type found, reading property") + if reader.IsNil() { + _optObjectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optObjectArray = make([]*AnotherType, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := AnotherTypeRead(reader); v != nil { + _optObjectArray[i0] = v + } + } + } + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_objectSet { + panic(reader.Context().PrintWithContext("Missing required property: 'object: AnotherType'")) + } + if !_objectArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'objectArray: [AnotherType]'")) + } + + return &ArgsOptionalEnvMethod{ + Object: _object, + OptObject: _optObject, + ObjectArray: _objectArray, + OptObjectArray: _optObjectArray, + } +} + +func SerializeOptionalEnvMethodResult(value *AnotherType) []byte { + ctx := msgpack.NewContext("Serializing module-type: OptionalEnvMethod") + encoder := msgpack.NewWriteEncoder(ctx) + WriteOptionalEnvMethodResult(encoder, value); + return encoder.Buffer() +} + +func WriteOptionalEnvMethodResult(writer msgpack.Write, value *AnotherType) { + writer.Context().Push("optionalEnvMethod", "*AnotherType", "writing property") + { + v := value + AnotherTypeWrite(writer, v) + } + writer.Context().Pop() +} + +func DeserializeIfArgs(argsBuf []byte) *ArgsIf { + ctx := msgpack.NewContext("Deserializing module-type: If") + reader := msgpack.NewReadDecoder(ctx, argsBuf) + + var ( + _if Else + _ifSet bool + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "if": + reader.Context().Push(field, "Else", "type found, reading property") + if v := ElseRead(reader); v != nil { + _if = *v + } + _ifSet = true + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_ifSet { + panic(reader.Context().PrintWithContext("Missing required property: 'if: else'")) + } + + return &ArgsIf{ + M_if: _if, + } +} + +func SerializeIfResult(value Else) []byte { + ctx := msgpack.NewContext("Serializing module-type: If") + encoder := msgpack.NewWriteEncoder(ctx) + WriteIfResult(encoder, value); + return encoder.Buffer() +} + +func WriteIfResult(writer msgpack.Write, value Else) { + writer.Context().Push("if", "Else", "writing property") + { + v := value + ElseWrite(writer, &v) + } + writer.Context().Pop() +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/module_wrapped/module_wrapped.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/module_wrapped/module_wrapped.go new file mode 100644 index 0000000000..037cab3ab6 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/module_wrapped/module_wrapped.go @@ -0,0 +1,52 @@ +package module_wrapped + +import ( + . "github.com/testorg/testrepo/module/wrap/types" + "github.com/polywrap/go-wrap/wrap" + methods "github.com/testorg/testrepo/module" +) + +func ModuleMethodWrapped(argsBuf []byte, envSize uint32) []byte { + + args := DeserializeModuleMethodArgs(argsBuf) + + result := methods.ModuleMethod(args) + return SerializeModuleMethodResult(result) +} + +func ObjectMethodWrapped(argsBuf []byte, envSize uint32) []byte { + var env *Env + if envSize == 0 { + panic("Environment is not set, and it is required by method 'objectMethod'") + } + if envSize > 0 { + envBuf := wrap.WrapLoadEnv(envSize) + env = EnvFromBuffer(envBuf) + } + + args := DeserializeObjectMethodArgs(argsBuf) + + result := methods.ObjectMethod(args,env) + return SerializeObjectMethodResult(result) +} + +func OptionalEnvMethodWrapped(argsBuf []byte, envSize uint32) []byte { + var env *Env + if envSize > 0 { + envBuf := wrap.WrapLoadEnv(envSize) + env = EnvFromBuffer(envBuf) + } + + args := DeserializeOptionalEnvMethodArgs(argsBuf) + + result := methods.OptionalEnvMethod(args,env) + return SerializeOptionalEnvMethodResult(result) +} + +func IfWrapped(argsBuf []byte, envSize uint32) []byte { + + args := DeserializeIfArgs(argsBuf) + + result := methods.If(args) + return SerializeIfResult(result) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/enum_custom_enum.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/enum_custom_enum.go new file mode 100644 index 0000000000..5ee8b8ac5d --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/enum_custom_enum.go @@ -0,0 +1,38 @@ +package types + +type CustomEnum int32 + +const ( + CustomEnumSTRING = iota + CustomEnumBYTES = iota + customEnumMax = iota +) + +func SanitizeCustomEnumValue(value int32) { + if !(value >= 0 && value < int32(customEnumMax)) { + panic("Invalid value for enum 'CustomEnum'") + } +} + +func GetCustomEnumValue(key string) CustomEnum { + switch key { + case "STRING": + return CustomEnumSTRING + case "BYTES": + return CustomEnumBYTES + default: + panic("Invalid key for enum 'CustomEnum'") + } +} + +func GetCustomEnumKey(value CustomEnum) string { + SanitizeCustomEnumValue(int32(value)) + switch value { + case CustomEnumSTRING: + return "STRING" + case CustomEnumBYTES: + return "BYTES" + default: + panic("Invalid value for enum 'CustomEnum'") + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/enumwhile.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/enumwhile.go new file mode 100644 index 0000000000..16ed26f498 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/enumwhile.go @@ -0,0 +1,38 @@ +package types + +type While int32 + +const ( + Whilefor = iota + Whilein = iota + whileMax = iota +) + +func SanitizeWhileValue(value int32) { + if !(value >= 0 && value < int32(whileMax)) { + panic("Invalid value for enum 'While'") + } +} + +func GetWhileValue(key string) While { + switch key { + case "for": + return Whilefor + case "in": + return Whilein + default: + panic("Invalid key for enum 'While'") + } +} + +func GetWhileKey(value While) string { + SanitizeWhileValue(int32(value)) + switch value { + case Whilefor: + return "for" + case Whilein: + return "in" + default: + panic("Invalid value for enum 'While'") + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/module_args.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/module_args.go new file mode 100644 index 0000000000..eb228b6267 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/module_args.go @@ -0,0 +1,33 @@ +package types + +type ArgsModuleMethod struct { + Str string `json:"str"` + OptStr *string `json:"optStr"` + En CustomEnum `json:"en"` + OptEnum *CustomEnum `json:"optEnum"` + EnumArray []CustomEnum `json:"enumArray"` + OptEnumArray []*CustomEnum `json:"optEnumArray"` + M_map map[string]int32 `json:"map"` + MapOfArr map[string][]int32 `json:"mapOfArr"` + MapOfMap map[string]map[string]int32 `json:"mapOfMap"` + MapOfObj map[string]AnotherType `json:"mapOfObj"` + MapOfArrOfObj map[string][]AnotherType `json:"mapOfArrOfObj"` +} + +type ArgsObjectMethod struct { + Object AnotherType `json:"object"` + OptObject *AnotherType `json:"optObject"` + ObjectArray []AnotherType `json:"objectArray"` + OptObjectArray []*AnotherType `json:"optObjectArray"` +} + +type ArgsOptionalEnvMethod struct { + Object AnotherType `json:"object"` + OptObject *AnotherType `json:"optObject"` + ObjectArray []AnotherType `json:"objectArray"` + OptObjectArray []*AnotherType `json:"optObjectArray"` +} + +type ArgsIf struct { + M_if Else `json:"if"` +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_another_type.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_another_type.go new file mode 100644 index 0000000000..92d48c4722 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_another_type.go @@ -0,0 +1,27 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type AnotherType struct { + Prop *string `json:"prop"` + Circular *CustomType `json:"circular"` + M_const *string `json:"const"` +} + +func AnotherTypeToBuffer(value *AnotherType) []byte { + return serializeAnotherType(value) +} + +func AnotherTypeFromBuffer(data []byte) *AnotherType { + return deserializeAnotherType(data) +} + +func AnotherTypeWrite(writer msgpack.Write, value *AnotherType) { + writeAnotherType(writer, value) +} + +func AnotherTypeRead(reader msgpack.Read) *AnotherType { + return readAnotherType(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_another_type_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_another_type_serialization.go new file mode 100644 index 0000000000..9379d11e42 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_another_type_serialization.go @@ -0,0 +1,93 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +func serializeAnotherType(value *AnotherType) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: AnotherType") + encoder := msgpack.NewWriteEncoder(ctx) + writeAnotherType(encoder, value) + return encoder.Buffer() +} + +func writeAnotherType(writer msgpack.Write, value *AnotherType) { + writer.WriteMapLength(3) + writer.Context().Push("Prop", "*string", "writing property") + writer.WriteString("Prop") + { + v := value.Prop + if v == nil { + writer.WriteNil() + } else { + writer.WriteString(*v) + } + } + writer.Context().Pop() + writer.Context().Push("Circular", "*CustomType", "writing property") + writer.WriteString("Circular") + { + v := value.Circular + CustomTypeWrite(writer, v) + } + writer.Context().Pop() + writer.Context().Push("M_const", "*string", "writing property") + writer.WriteString("M_const") + { + v := value.M_const + if v == nil { + writer.WriteNil() + } else { + writer.WriteString(*v) + } + } + writer.Context().Pop() +} + +func deserializeAnotherType(data []byte) *AnotherType { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: AnotherType") + reader := msgpack.NewReadDecoder(ctx, data) + return readAnotherType(reader) +} + +func readAnotherType(reader msgpack.Read) *AnotherType { + var ( + _prop *string + _circular *CustomType + _const *string + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "prop": + reader.Context().Push(field, "*string", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadString() + _prop = &v + } + reader.Context().Pop() + case "circular": + reader.Context().Push(field, "*CustomType", "type found, reading property") + if v := CustomTypeRead(reader); v != nil { + _circular = v + } + reader.Context().Pop() + case "const": + reader.Context().Push(field, "*string", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadString() + _const = &v + } + reader.Context().Pop() + } + reader.Context().Pop() + } + + return &AnotherType{ + Prop: _prop, + Circular: _circular, + M_const: _const, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_map_value.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_map_value.go new file mode 100644 index 0000000000..49729b0e00 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_map_value.go @@ -0,0 +1,25 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type CustomMapValue struct { + Foo string `json:"foo"` +} + +func CustomMapValueToBuffer(value *CustomMapValue) []byte { + return serializeCustomMapValue(value) +} + +func CustomMapValueFromBuffer(data []byte) *CustomMapValue { + return deserializeCustomMapValue(data) +} + +func CustomMapValueWrite(writer msgpack.Write, value *CustomMapValue) { + writeCustomMapValue(writer, value) +} + +func CustomMapValueRead(reader msgpack.Read) *CustomMapValue { + return readCustomMapValue(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_map_value_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_map_value_serialization.go new file mode 100644 index 0000000000..056eb66e5d --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_map_value_serialization.go @@ -0,0 +1,56 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +func serializeCustomMapValue(value *CustomMapValue) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: CustomMapValue") + encoder := msgpack.NewWriteEncoder(ctx) + writeCustomMapValue(encoder, value) + return encoder.Buffer() +} + +func writeCustomMapValue(writer msgpack.Write, value *CustomMapValue) { + writer.WriteMapLength(1) + writer.Context().Push("Foo", "string", "writing property") + writer.WriteString("Foo") + { + v := value.Foo + writer.WriteString(v) + } + writer.Context().Pop() +} + +func deserializeCustomMapValue(data []byte) *CustomMapValue { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: CustomMapValue") + reader := msgpack.NewReadDecoder(ctx, data) + return readCustomMapValue(reader) +} + +func readCustomMapValue(reader msgpack.Read) *CustomMapValue { + var ( + _foo string + _fooSet bool + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "foo": + reader.Context().Push(field, "string", "type found, reading property") + _foo = reader.ReadString() + _fooSet = true + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_fooSet { + panic(reader.Context().PrintWithContext("Missing required property: 'foo: String'")) + } + return &CustomMapValue{ + Foo: _foo, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_type.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_type.go new file mode 100644 index 0000000000..6c97ef1ba9 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_type.go @@ -0,0 +1,68 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" + "github.com/polywrap/go-wrap/msgpack/big" + "github.com/valyala/fastjson" +) + +type CustomType struct { + Str string `json:"str"` + OptStr *string `json:"optStr"` + U uint32 `json:"u"` + OptU *uint32 `json:"optU"` + M_u8 uint8 `json:"u8"` + M_u16 uint16 `json:"u16"` + M_u32 uint32 `json:"u32"` + I int32 `json:"i"` + M_i8 int8 `json:"i8"` + M_i16 int16 `json:"i16"` + M_i32 int32 `json:"i32"` + Bigint *big.Int `json:"bigint"` + OptBigint *big.Int `json:"optBigint"` + Bignumber *big.Int `json:"bignumber"` + OptBignumber *big.Int `json:"optBignumber"` + Json *fastjson.Value `json:"json"` + OptJson *fastjson.Value `json:"optJson"` + Bytes []byte `json:"bytes"` + OptBytes []byte `json:"optBytes"` + M_boolean bool `json:"boolean"` + OptBoolean *bool `json:"optBoolean"` + U_array []uint32 `json:"u_array"` + UOpt_array []uint32 `json:"uOpt_array"` + _opt_uOptArray []*uint32 `json:"_opt_uOptArray"` + OptStrOptArray []*string `json:"optStrOptArray"` + UArrayArray [][]uint32 `json:"uArrayArray"` + UOptArrayOptArray [][]*uint32 `json:"uOptArrayOptArray"` + UArrayOptArrayArray [][][]uint32 `json:"uArrayOptArrayArray"` + CrazyArray [][][][]uint32 `json:"crazyArray"` + Object AnotherType `json:"object"` + OptObject *AnotherType `json:"optObject"` + ObjectArray []AnotherType `json:"objectArray"` + OptObjectArray []*AnotherType `json:"optObjectArray"` + En CustomEnum `json:"en"` + OptEnum *CustomEnum `json:"optEnum"` + EnumArray []CustomEnum `json:"enumArray"` + OptEnumArray []*CustomEnum `json:"optEnumArray"` + M_map map[string]int32 `json:"map"` + MapOfArr map[string][]int32 `json:"mapOfArr"` + MapOfObj map[string]AnotherType `json:"mapOfObj"` + MapOfArrOfObj map[string][]AnotherType `json:"mapOfArrOfObj"` + MapCustomValue map[string]*CustomMapValue `json:"mapCustomValue"` +} + +func CustomTypeToBuffer(value *CustomType) []byte { + return serializeCustomType(value) +} + +func CustomTypeFromBuffer(data []byte) *CustomType { + return deserializeCustomType(data) +} + +func CustomTypeWrite(writer msgpack.Write, value *CustomType) { + writeCustomType(writer, value) +} + +func CustomTypeRead(reader msgpack.Read) *CustomType { + return readCustomType(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_type_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_type_serialization.go new file mode 100644 index 0000000000..78d4df2834 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_custom_type_serialization.go @@ -0,0 +1,1270 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" + "github.com/polywrap/go-wrap/msgpack/big" + "github.com/valyala/fastjson" +) + +func serializeCustomType(value *CustomType) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: CustomType") + encoder := msgpack.NewWriteEncoder(ctx) + writeCustomType(encoder, value) + return encoder.Buffer() +} + +func writeCustomType(writer msgpack.Write, value *CustomType) { + writer.WriteMapLength(42) + writer.Context().Push("Str", "string", "writing property") + writer.WriteString("Str") + { + v := value.Str + writer.WriteString(v) + } + writer.Context().Pop() + writer.Context().Push("OptStr", "*string", "writing property") + writer.WriteString("OptStr") + { + v := value.OptStr + if v == nil { + writer.WriteNil() + } else { + writer.WriteString(*v) + } + } + writer.Context().Pop() + writer.Context().Push("U", "uint32", "writing property") + writer.WriteString("U") + { + v := value.U + writer.WriteU32(v) + } + writer.Context().Pop() + writer.Context().Push("OptU", "*uint32", "writing property") + writer.WriteString("OptU") + { + v := value.OptU + if v == nil { + writer.WriteNil() + } else { + writer.WriteU32(*v) + } + } + writer.Context().Pop() + writer.Context().Push("M_u8", "uint8", "writing property") + writer.WriteString("M_u8") + { + v := value.M_u8 + writer.WriteU8(v) + } + writer.Context().Pop() + writer.Context().Push("M_u16", "uint16", "writing property") + writer.WriteString("M_u16") + { + v := value.M_u16 + writer.WriteU16(v) + } + writer.Context().Pop() + writer.Context().Push("M_u32", "uint32", "writing property") + writer.WriteString("M_u32") + { + v := value.M_u32 + writer.WriteU32(v) + } + writer.Context().Pop() + writer.Context().Push("I", "int32", "writing property") + writer.WriteString("I") + { + v := value.I + writer.WriteI32(v) + } + writer.Context().Pop() + writer.Context().Push("M_i8", "int8", "writing property") + writer.WriteString("M_i8") + { + v := value.M_i8 + writer.WriteI8(v) + } + writer.Context().Pop() + writer.Context().Push("M_i16", "int16", "writing property") + writer.WriteString("M_i16") + { + v := value.M_i16 + writer.WriteI16(v) + } + writer.Context().Pop() + writer.Context().Push("M_i32", "int32", "writing property") + writer.WriteString("M_i32") + { + v := value.M_i32 + writer.WriteI32(v) + } + writer.Context().Pop() + writer.Context().Push("Bigint", "*big.Int", "writing property") + writer.WriteString("Bigint") + { + v := value.Bigint + writer.WriteBigInt(v) + } + writer.Context().Pop() + writer.Context().Push("OptBigint", "*big.Int", "writing property") + writer.WriteString("OptBigint") + { + v := value.OptBigint + if v == nil { + writer.WriteNil() + } else { + writer.WriteBigInt(v) + } + } + writer.Context().Pop() + writer.Context().Push("Bignumber", "*big.Int", "writing property") + writer.WriteString("Bignumber") + { + v := value.Bignumber + writer.WriteBigInt(v) + } + writer.Context().Pop() + writer.Context().Push("OptBignumber", "*big.Int", "writing property") + writer.WriteString("OptBignumber") + { + v := value.OptBignumber + if v == nil { + writer.WriteNil() + } else { + writer.WriteBigInt(v) + } + } + writer.Context().Pop() + writer.Context().Push("Json", "*fastjson.Value", "writing property") + writer.WriteString("Json") + { + v := value.Json + writer.WriteJson(v) + } + writer.Context().Pop() + writer.Context().Push("OptJson", "*fastjson.Value", "writing property") + writer.WriteString("OptJson") + { + v := value.OptJson + if v == nil { + writer.WriteNil() + } else { + writer.WriteJson(v) + } + } + writer.Context().Pop() + writer.Context().Push("Bytes", "[]byte", "writing property") + writer.WriteString("Bytes") + { + v := value.Bytes + writer.WriteBytes(v) + } + writer.Context().Pop() + writer.Context().Push("OptBytes", "[]byte", "writing property") + writer.WriteString("OptBytes") + { + v := value.OptBytes + if v == nil { + writer.WriteNil() + } else { + writer.WriteBytes(v) + } + } + writer.Context().Pop() + writer.Context().Push("M_boolean", "bool", "writing property") + writer.WriteString("M_boolean") + { + v := value.M_boolean + writer.WriteBool(v) + } + writer.Context().Pop() + writer.Context().Push("OptBoolean", "*bool", "writing property") + writer.WriteString("OptBoolean") + { + v := value.OptBoolean + if v == nil { + writer.WriteNil() + } else { + writer.WriteBool(*v) + } + } + writer.Context().Pop() + writer.Context().Push("U_array", "[]uint32", "writing property") + writer.WriteString("U_array") + if value.U_array == nil { + writer.WriteNil() + } else if len(value.U_array) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.U_array))) + for i0 := range value.U_array { + { + v := value.U_array[i0] + writer.WriteU32(v) + } + } + } + writer.Context().Pop() + writer.Context().Push("UOpt_array", "[]uint32", "writing property") + writer.WriteString("UOpt_array") + if value.UOpt_array == nil { + writer.WriteNil() + } else if len(value.UOpt_array) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UOpt_array))) + for i0 := range value.UOpt_array { + { + v := value.UOpt_array[i0] + writer.WriteU32(v) + } + } + } + writer.Context().Pop() + writer.Context().Push("_opt_uOptArray", "[]*uint32", "writing property") + writer.WriteString("_opt_uOptArray") + if value._opt_uOptArray == nil { + writer.WriteNil() + } else if len(value._opt_uOptArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value._opt_uOptArray))) + for i0 := range value._opt_uOptArray { + { + v := value._opt_uOptArray[i0] + if v == nil { + writer.WriteNil() + } else { + writer.WriteU32(*v) + } + } + } + } + writer.Context().Pop() + writer.Context().Push("OptStrOptArray", "[]*string", "writing property") + writer.WriteString("OptStrOptArray") + if value.OptStrOptArray == nil { + writer.WriteNil() + } else if len(value.OptStrOptArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptStrOptArray))) + for i0 := range value.OptStrOptArray { + { + v := value.OptStrOptArray[i0] + if v == nil { + writer.WriteNil() + } else { + writer.WriteString(*v) + } + } + } + } + writer.Context().Pop() + writer.Context().Push("UArrayArray", "[][]uint32", "writing property") + writer.WriteString("UArrayArray") + if value.UArrayArray == nil { + writer.WriteNil() + } else if len(value.UArrayArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UArrayArray))) + for i0 := range value.UArrayArray { + if value.UArrayArray[i0] == nil { + writer.WriteNil() + } else if len(value.UArrayArray[i0]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UArrayArray[i0]))) + for i1 := range value.UArrayArray[i0] { + { + v := value.UArrayArray[i0][i1] + writer.WriteU32(v) + } + } + } + } + } + writer.Context().Pop() + writer.Context().Push("UOptArrayOptArray", "[][]*uint32", "writing property") + writer.WriteString("UOptArrayOptArray") + if value.UOptArrayOptArray == nil { + writer.WriteNil() + } else if len(value.UOptArrayOptArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UOptArrayOptArray))) + for i0 := range value.UOptArrayOptArray { + if value.UOptArrayOptArray[i0] == nil { + writer.WriteNil() + } else if len(value.UOptArrayOptArray[i0]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UOptArrayOptArray[i0]))) + for i1 := range value.UOptArrayOptArray[i0] { + { + v := value.UOptArrayOptArray[i0][i1] + if v == nil { + writer.WriteNil() + } else { + writer.WriteU32(*v) + } + } + } + } + } + } + writer.Context().Pop() + writer.Context().Push("UArrayOptArrayArray", "[][][]uint32", "writing property") + writer.WriteString("UArrayOptArrayArray") + if value.UArrayOptArrayArray == nil { + writer.WriteNil() + } else if len(value.UArrayOptArrayArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UArrayOptArrayArray))) + for i0 := range value.UArrayOptArrayArray { + if value.UArrayOptArrayArray[i0] == nil { + writer.WriteNil() + } else if len(value.UArrayOptArrayArray[i0]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UArrayOptArrayArray[i0]))) + for i1 := range value.UArrayOptArrayArray[i0] { + if value.UArrayOptArrayArray[i0][i1] == nil { + writer.WriteNil() + } else if len(value.UArrayOptArrayArray[i0][i1]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.UArrayOptArrayArray[i0][i1]))) + for i2 := range value.UArrayOptArrayArray[i0][i1] { + { + v := value.UArrayOptArrayArray[i0][i1][i2] + writer.WriteU32(v) + } + } + } + } + } + } + } + writer.Context().Pop() + writer.Context().Push("CrazyArray", "[][][][]uint32", "writing property") + writer.WriteString("CrazyArray") + if value.CrazyArray == nil { + writer.WriteNil() + } else if len(value.CrazyArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.CrazyArray))) + for i0 := range value.CrazyArray { + if value.CrazyArray[i0] == nil { + writer.WriteNil() + } else if len(value.CrazyArray[i0]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.CrazyArray[i0]))) + for i1 := range value.CrazyArray[i0] { + if value.CrazyArray[i0][i1] == nil { + writer.WriteNil() + } else if len(value.CrazyArray[i0][i1]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.CrazyArray[i0][i1]))) + for i2 := range value.CrazyArray[i0][i1] { + if value.CrazyArray[i0][i1][i2] == nil { + writer.WriteNil() + } else if len(value.CrazyArray[i0][i1][i2]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.CrazyArray[i0][i1][i2]))) + for i3 := range value.CrazyArray[i0][i1][i2] { + { + v := value.CrazyArray[i0][i1][i2][i3] + writer.WriteU32(v) + } + } + } + } + } + } + } + } + } + writer.Context().Pop() + writer.Context().Push("Object", "AnotherType", "writing property") + writer.WriteString("Object") + { + v := value.Object + AnotherTypeWrite(writer, &v) + } + writer.Context().Pop() + writer.Context().Push("OptObject", "*AnotherType", "writing property") + writer.WriteString("OptObject") + { + v := value.OptObject + AnotherTypeWrite(writer, v) + } + writer.Context().Pop() + writer.Context().Push("ObjectArray", "[]AnotherType", "writing property") + writer.WriteString("ObjectArray") + if value.ObjectArray == nil { + writer.WriteNil() + } else if len(value.ObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.ObjectArray))) + for i0 := range value.ObjectArray { + { + v := value.ObjectArray[i0] + AnotherTypeWrite(writer, &v) + } + } + } + writer.Context().Pop() + writer.Context().Push("OptObjectArray", "[]*AnotherType", "writing property") + writer.WriteString("OptObjectArray") + if value.OptObjectArray == nil { + writer.WriteNil() + } else if len(value.OptObjectArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptObjectArray))) + for i0 := range value.OptObjectArray { + { + v := value.OptObjectArray[i0] + AnotherTypeWrite(writer, v) + } + } + } + writer.Context().Pop() + writer.Context().Push("En", "CustomEnum", "writing property") + writer.WriteString("En") + { + v := value.En + writer.WriteI32(int32(v)) + } + writer.Context().Pop() + writer.Context().Push("OptEnum", "*CustomEnum", "writing property") + writer.WriteString("OptEnum") + { + v := value.OptEnum + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + writer.Context().Pop() + writer.Context().Push("EnumArray", "[]CustomEnum", "writing property") + writer.WriteString("EnumArray") + if value.EnumArray == nil { + writer.WriteNil() + } else if len(value.EnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.EnumArray))) + for i0 := range value.EnumArray { + { + v := value.EnumArray[i0] + writer.WriteI32(int32(v)) + } + } + } + writer.Context().Pop() + writer.Context().Push("OptEnumArray", "[]*CustomEnum", "writing property") + writer.WriteString("OptEnumArray") + if value.OptEnumArray == nil { + writer.WriteNil() + } else if len(value.OptEnumArray) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.OptEnumArray))) + for i0 := range value.OptEnumArray { + { + v := value.OptEnumArray[i0] + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(int32(*v)) + } + } + } + } + writer.Context().Pop() + writer.Context().Push("M_map", "map[string]int32", "writing property") + writer.WriteString("M_map") + if value.M_map == nil { + writer.WriteNil() + } else if len(value.M_map) == 0 { + writer.WriteNil() + } else { + for i0 := range value.M_map { + writer.WriteString(i0) + { + v := value.M_map[i0] + writer.WriteI32(v) + } + } + } + writer.Context().Pop() + writer.Context().Push("MapOfArr", "map[string][]int32", "writing property") + writer.WriteString("MapOfArr") + if value.MapOfArr == nil { + writer.WriteNil() + } else if len(value.MapOfArr) == 0 { + writer.WriteNil() + } else { + for i0 := range value.MapOfArr { + writer.WriteString(i0) + if value.MapOfArr[i0] == nil { + writer.WriteNil() + } else if len(value.MapOfArr[i0]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.MapOfArr[i0]))) + for i1 := range value.MapOfArr[i0] { + { + v := value.MapOfArr[i0][i1] + writer.WriteI32(v) + } + } + } + } + } + writer.Context().Pop() + writer.Context().Push("MapOfObj", "map[string]AnotherType", "writing property") + writer.WriteString("MapOfObj") + if value.MapOfObj == nil { + writer.WriteNil() + } else if len(value.MapOfObj) == 0 { + writer.WriteNil() + } else { + for i0 := range value.MapOfObj { + writer.WriteString(i0) + { + v := value.MapOfObj[i0] + AnotherTypeWrite(writer, &v) + } + } + } + writer.Context().Pop() + writer.Context().Push("MapOfArrOfObj", "map[string][]AnotherType", "writing property") + writer.WriteString("MapOfArrOfObj") + if value.MapOfArrOfObj == nil { + writer.WriteNil() + } else if len(value.MapOfArrOfObj) == 0 { + writer.WriteNil() + } else { + for i0 := range value.MapOfArrOfObj { + writer.WriteString(i0) + if value.MapOfArrOfObj[i0] == nil { + writer.WriteNil() + } else if len(value.MapOfArrOfObj[i0]) == 0 { + writer.WriteNil() + } else { + writer.WriteArrayLength(uint32(len(value.MapOfArrOfObj[i0]))) + for i1 := range value.MapOfArrOfObj[i0] { + { + v := value.MapOfArrOfObj[i0][i1] + AnotherTypeWrite(writer, &v) + } + } + } + } + } + writer.Context().Pop() + writer.Context().Push("MapCustomValue", "map[string]*CustomMapValue", "writing property") + writer.WriteString("MapCustomValue") + if value.MapCustomValue == nil { + writer.WriteNil() + } else if len(value.MapCustomValue) == 0 { + writer.WriteNil() + } else { + for i0 := range value.MapCustomValue { + writer.WriteString(i0) + { + v := value.MapCustomValue[i0] + CustomMapValueWrite(writer, v) + } + } + } + writer.Context().Pop() +} + +func deserializeCustomType(data []byte) *CustomType { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: CustomType") + reader := msgpack.NewReadDecoder(ctx, data) + return readCustomType(reader) +} + +func readCustomType(reader msgpack.Read) *CustomType { + var ( + _str string + _strSet bool + _optStr *string + _u uint32 + _uSet bool + _optU *uint32 + _u8 uint8 + _u8Set bool + _u16 uint16 + _u16Set bool + _u32 uint32 + _u32Set bool + _i int32 + _iSet bool + _i8 int8 + _i8Set bool + _i16 int16 + _i16Set bool + _i32 int32 + _i32Set bool + _bigint *big.Int + _bigintSet bool + _optBigint *big.Int + _bignumber *big.Int + _bignumberSet bool + _optBignumber *big.Int + _json *fastjson.Value + _jsonSet bool + _optJson *fastjson.Value + _bytes []byte + _bytesSet bool + _optBytes []byte + _boolean bool + _booleanSet bool + _optBoolean *bool + _u_array []uint32 + _u_arraySet bool + _uOpt_array []uint32 + __opt_uOptArray []*uint32 + _optStrOptArray []*string + _uArrayArray [][]uint32 + _uArrayArraySet bool + _uOptArrayOptArray [][]*uint32 + _uOptArrayOptArraySet bool + _uArrayOptArrayArray [][][]uint32 + _uArrayOptArrayArraySet bool + _crazyArray [][][][]uint32 + _object AnotherType + _objectSet bool + _optObject *AnotherType + _objectArray []AnotherType + _objectArraySet bool + _optObjectArray []*AnotherType + _en CustomEnum + _enSet bool + _optEnum *CustomEnum + _enumArray []CustomEnum + _enumArraySet bool + _optEnumArray []*CustomEnum + _map map[string]int32 + _mapSet bool + _mapOfArr map[string][]int32 + _mapOfArrSet bool + _mapOfObj map[string]AnotherType + _mapOfObjSet bool + _mapOfArrOfObj map[string][]AnotherType + _mapOfArrOfObjSet bool + _mapCustomValue map[string]*CustomMapValue + _mapCustomValueSet bool + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "str": + reader.Context().Push(field, "string", "type found, reading property") + _str = reader.ReadString() + _strSet = true + reader.Context().Pop() + case "optStr": + reader.Context().Push(field, "*string", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadString() + _optStr = &v + } + reader.Context().Pop() + case "u": + reader.Context().Push(field, "uint32", "type found, reading property") + _u = reader.ReadU32() + _uSet = true + reader.Context().Pop() + case "optU": + reader.Context().Push(field, "*uint32", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadU32() + _optU = &v + } + reader.Context().Pop() + case "u8": + reader.Context().Push(field, "uint8", "type found, reading property") + _u8 = reader.ReadU8() + _u8Set = true + reader.Context().Pop() + case "u16": + reader.Context().Push(field, "uint16", "type found, reading property") + _u16 = reader.ReadU16() + _u16Set = true + reader.Context().Pop() + case "u32": + reader.Context().Push(field, "uint32", "type found, reading property") + _u32 = reader.ReadU32() + _u32Set = true + reader.Context().Pop() + case "i": + reader.Context().Push(field, "int32", "type found, reading property") + _i = reader.ReadI32() + _iSet = true + reader.Context().Pop() + case "i8": + reader.Context().Push(field, "int8", "type found, reading property") + _i8 = reader.ReadI8() + _i8Set = true + reader.Context().Pop() + case "i16": + reader.Context().Push(field, "int16", "type found, reading property") + _i16 = reader.ReadI16() + _i16Set = true + reader.Context().Pop() + case "i32": + reader.Context().Push(field, "int32", "type found, reading property") + _i32 = reader.ReadI32() + _i32Set = true + reader.Context().Pop() + case "bigint": + reader.Context().Push(field, "*big.Int", "type found, reading property") + _bigint = reader.ReadBigInt() + _bigintSet = true + reader.Context().Pop() + case "optBigint": + reader.Context().Push(field, "*big.Int", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadBigInt() + _optBigint = v + } + reader.Context().Pop() + case "bignumber": + reader.Context().Push(field, "*big.Int", "type found, reading property") + _bignumber = reader.ReadBigInt() + _bignumberSet = true + reader.Context().Pop() + case "optBignumber": + reader.Context().Push(field, "*big.Int", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadBigInt() + _optBignumber = v + } + reader.Context().Pop() + case "json": + reader.Context().Push(field, "*fastjson.Value", "type found, reading property") + _json = reader.ReadJson() + _jsonSet = true + reader.Context().Pop() + case "optJson": + reader.Context().Push(field, "*fastjson.Value", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadJson() + _optJson = v + } + reader.Context().Pop() + case "bytes": + reader.Context().Push(field, "[]byte", "type found, reading property") + _bytes = reader.ReadBytes() + _bytesSet = true + reader.Context().Pop() + case "optBytes": + reader.Context().Push(field, "[]byte", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadBytes() + _optBytes = v + } + reader.Context().Pop() + case "boolean": + reader.Context().Push(field, "bool", "type found, reading property") + _boolean = reader.ReadBool() + _booleanSet = true + reader.Context().Pop() + case "optBoolean": + reader.Context().Push(field, "*bool", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadBool() + _optBoolean = &v + } + reader.Context().Pop() + case "u_array": + reader.Context().Push(field, "[]uint32", "type found, reading property") + if reader.IsNil() { + _u_array = nil + } else { + ln0 := reader.ReadArrayLength() + _u_array = make([]uint32, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + _u_array[i0] = reader.ReadU32() + } + } + _u_arraySet = true + reader.Context().Pop() + case "uOpt_array": + reader.Context().Push(field, "[]uint32", "type found, reading property") + if reader.IsNil() { + _uOpt_array = nil + } else { + ln0 := reader.ReadArrayLength() + _uOpt_array = make([]uint32, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + _uOpt_array[i0] = reader.ReadU32() + } + } + reader.Context().Pop() + case "_opt_uOptArray": + reader.Context().Push(field, "[]*uint32", "type found, reading property") + if reader.IsNil() { + __opt_uOptArray = nil + } else { + ln0 := reader.ReadArrayLength() + __opt_uOptArray = make([]*uint32, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if !reader.IsNil() { + v := reader.ReadU32() + __opt_uOptArray[i0] = &v + } + } + } + reader.Context().Pop() + case "optStrOptArray": + reader.Context().Push(field, "[]*string", "type found, reading property") + if reader.IsNil() { + _optStrOptArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optStrOptArray = make([]*string, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if !reader.IsNil() { + v := reader.ReadString() + _optStrOptArray[i0] = &v + } + } + } + reader.Context().Pop() + case "uArrayArray": + reader.Context().Push(field, "[][]uint32", "type found, reading property") + if reader.IsNil() { + _uArrayArray = nil + } else { + ln0 := reader.ReadArrayLength() + _uArrayArray = make([][]uint32, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if reader.IsNil() { + _uArrayArray[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _uArrayArray[i0] = make([]uint32, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + _uArrayArray[i0][i1] = reader.ReadU32() + } + } + } + } + _uArrayArraySet = true + reader.Context().Pop() + case "uOptArrayOptArray": + reader.Context().Push(field, "[][]*uint32", "type found, reading property") + if reader.IsNil() { + _uOptArrayOptArray = nil + } else { + ln0 := reader.ReadArrayLength() + _uOptArrayOptArray = make([][]*uint32, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if reader.IsNil() { + _uOptArrayOptArray[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _uOptArrayOptArray[i0] = make([]*uint32, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + if !reader.IsNil() { + v := reader.ReadU32() + _uOptArrayOptArray[i0][i1] = &v + } + } + } + } + } + _uOptArrayOptArraySet = true + reader.Context().Pop() + case "uArrayOptArrayArray": + reader.Context().Push(field, "[][][]uint32", "type found, reading property") + if reader.IsNil() { + _uArrayOptArrayArray = nil + } else { + ln0 := reader.ReadArrayLength() + _uArrayOptArrayArray = make([][][]uint32, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if reader.IsNil() { + _uArrayOptArrayArray[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _uArrayOptArrayArray[i0] = make([][]uint32, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + if reader.IsNil() { + _uArrayOptArrayArray[i0][i1] = nil + } else { + ln2 := reader.ReadArrayLength() + _uArrayOptArrayArray[i0][i1] = make([]uint32, ln2) + for i2 := uint32(0); i2 < ln2; i2++ { + _uArrayOptArrayArray[i0][i1][i2] = reader.ReadU32() + } + } + } + } + } + } + _uArrayOptArrayArraySet = true + reader.Context().Pop() + case "crazyArray": + reader.Context().Push(field, "[][][][]uint32", "type found, reading property") + if reader.IsNil() { + _crazyArray = nil + } else { + ln0 := reader.ReadArrayLength() + _crazyArray = make([][][][]uint32, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if reader.IsNil() { + _crazyArray[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _crazyArray[i0] = make([][][]uint32, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + if reader.IsNil() { + _crazyArray[i0][i1] = nil + } else { + ln2 := reader.ReadArrayLength() + _crazyArray[i0][i1] = make([][]uint32, ln2) + for i2 := uint32(0); i2 < ln2; i2++ { + if reader.IsNil() { + _crazyArray[i0][i1][i2] = nil + } else { + ln3 := reader.ReadArrayLength() + _crazyArray[i0][i1][i2] = make([]uint32, ln3) + for i3 := uint32(0); i3 < ln3; i3++ { + _crazyArray[i0][i1][i2][i3] = reader.ReadU32() + } + } + } + } + } + } + } + } + reader.Context().Pop() + case "object": + reader.Context().Push(field, "AnotherType", "type found, reading property") + if v := AnotherTypeRead(reader); v != nil { + _object = *v + } + _objectSet = true + reader.Context().Pop() + case "optObject": + reader.Context().Push(field, "*AnotherType", "type found, reading property") + if v := AnotherTypeRead(reader); v != nil { + _optObject = v + } + reader.Context().Pop() + case "objectArray": + reader.Context().Push(field, "[]AnotherType", "type found, reading property") + if reader.IsNil() { + _objectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _objectArray = make([]AnotherType, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := AnotherTypeRead(reader); v != nil { + _objectArray[i0] = *v + } + } + } + _objectArraySet = true + reader.Context().Pop() + case "optObjectArray": + reader.Context().Push(field, "[]*AnotherType", "type found, reading property") + if reader.IsNil() { + _optObjectArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optObjectArray = make([]*AnotherType, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if v := AnotherTypeRead(reader); v != nil { + _optObjectArray[i0] = v + } + } + } + reader.Context().Pop() + case "en": + reader.Context().Push(field, "CustomEnum", "type found, reading property") + _en = CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(_en)) + _enSet = true + reader.Context().Pop() + case "optEnum": + reader.Context().Push(field, "*CustomEnum", "type found, reading property") + if !reader.IsNil() { + v := CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(v)) + _optEnum = &v + } + reader.Context().Pop() + case "enumArray": + reader.Context().Push(field, "[]CustomEnum", "type found, reading property") + if reader.IsNil() { + _enumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _enumArray = make([]CustomEnum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + _enumArray[i0] = CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(_enumArray[i0])) + } + } + _enumArraySet = true + reader.Context().Pop() + case "optEnumArray": + reader.Context().Push(field, "[]*CustomEnum", "type found, reading property") + if reader.IsNil() { + _optEnumArray = nil + } else { + ln0 := reader.ReadArrayLength() + _optEnumArray = make([]*CustomEnum, ln0) + for i0 := uint32(0); i0 < ln0; i0++ { + if !reader.IsNil() { + v := CustomEnum(reader.ReadI32()) + SanitizeCustomEnumValue(int32(v)) + _optEnumArray[i0] = &v + } + } + } + reader.Context().Pop() + case "map": + reader.Context().Push(field, "map[string]int32", "type found, reading property") + if reader.IsNil() { + _map = nil + } else { + ln0 := reader.ReadMapLength() + _map = make(map[string]int32) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + _map[i0] = reader.ReadI32() + } + } + _mapSet = true + reader.Context().Pop() + case "mapOfArr": + reader.Context().Push(field, "map[string][]int32", "type found, reading property") + if reader.IsNil() { + _mapOfArr = nil + } else { + ln0 := reader.ReadMapLength() + _mapOfArr = make(map[string][]int32) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if reader.IsNil() { + _mapOfArr[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _mapOfArr[i0] = make([]int32, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + _mapOfArr[i0][i1] = reader.ReadI32() + } + } + } + } + _mapOfArrSet = true + reader.Context().Pop() + case "mapOfObj": + reader.Context().Push(field, "map[string]AnotherType", "type found, reading property") + if reader.IsNil() { + _mapOfObj = nil + } else { + ln0 := reader.ReadMapLength() + _mapOfObj = make(map[string]AnotherType) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if v := AnotherTypeRead(reader); v != nil { + _mapOfObj[i0] = *v + } + } + } + _mapOfObjSet = true + reader.Context().Pop() + case "mapOfArrOfObj": + reader.Context().Push(field, "map[string][]AnotherType", "type found, reading property") + if reader.IsNil() { + _mapOfArrOfObj = nil + } else { + ln0 := reader.ReadMapLength() + _mapOfArrOfObj = make(map[string][]AnotherType) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if reader.IsNil() { + _mapOfArrOfObj[i0] = nil + } else { + ln1 := reader.ReadArrayLength() + _mapOfArrOfObj[i0] = make([]AnotherType, ln1) + for i1 := uint32(0); i1 < ln1; i1++ { + if v := AnotherTypeRead(reader); v != nil { + _mapOfArrOfObj[i0][i1] = *v + } + } + } + } + } + _mapOfArrOfObjSet = true + reader.Context().Pop() + case "mapCustomValue": + reader.Context().Push(field, "map[string]*CustomMapValue", "type found, reading property") + if reader.IsNil() { + _mapCustomValue = nil + } else { + ln0 := reader.ReadMapLength() + _mapCustomValue = make(map[string]*CustomMapValue) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if v := CustomMapValueRead(reader); v != nil { + _mapCustomValue[i0] = v + } + } + } + _mapCustomValueSet = true + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_strSet { + panic(reader.Context().PrintWithContext("Missing required property: 'str: String'")) + } + if !_uSet { + panic(reader.Context().PrintWithContext("Missing required property: 'u: UInt'")) + } + if !_u8Set { + panic(reader.Context().PrintWithContext("Missing required property: 'u8: UInt8'")) + } + if !_u16Set { + panic(reader.Context().PrintWithContext("Missing required property: 'u16: UInt16'")) + } + if !_u32Set { + panic(reader.Context().PrintWithContext("Missing required property: 'u32: UInt32'")) + } + if !_iSet { + panic(reader.Context().PrintWithContext("Missing required property: 'i: Int'")) + } + if !_i8Set { + panic(reader.Context().PrintWithContext("Missing required property: 'i8: Int8'")) + } + if !_i16Set { + panic(reader.Context().PrintWithContext("Missing required property: 'i16: Int16'")) + } + if !_i32Set { + panic(reader.Context().PrintWithContext("Missing required property: 'i32: Int32'")) + } + if !_bigintSet { + panic(reader.Context().PrintWithContext("Missing required property: 'bigint: BigInt'")) + } + if !_bignumberSet { + panic(reader.Context().PrintWithContext("Missing required property: 'bignumber: BigNumber'")) + } + if !_jsonSet { + panic(reader.Context().PrintWithContext("Missing required property: 'json: JSON'")) + } + if !_bytesSet { + panic(reader.Context().PrintWithContext("Missing required property: 'bytes: Bytes'")) + } + if !_booleanSet { + panic(reader.Context().PrintWithContext("Missing required property: 'boolean: Boolean'")) + } + if !_u_arraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'u_array: [UInt]'")) + } + if !_uArrayArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'uArrayArray: [[UInt]]'")) + } + if !_uOptArrayOptArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'uOptArrayOptArray: [[UInt32]]'")) + } + if !_uArrayOptArrayArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'uArrayOptArrayArray: [[[UInt32]]]'")) + } + if !_objectSet { + panic(reader.Context().PrintWithContext("Missing required property: 'object: AnotherType'")) + } + if !_objectArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'objectArray: [AnotherType]'")) + } + if !_enSet { + panic(reader.Context().PrintWithContext("Missing required property: 'en: CustomEnum'")) + } + if !_enumArraySet { + panic(reader.Context().PrintWithContext("Missing required property: 'enumArray: [CustomEnum]'")) + } + if !_mapSet { + panic(reader.Context().PrintWithContext("Missing required property: 'map: Map'")) + } + if !_mapOfArrSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapOfArr: Map'")) + } + if !_mapOfObjSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapOfObj: Map'")) + } + if !_mapOfArrOfObjSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapOfArrOfObj: Map'")) + } + if !_mapCustomValueSet { + panic(reader.Context().PrintWithContext("Missing required property: 'mapCustomValue: Map'")) + } + return &CustomType{ + Str: _str, + OptStr: _optStr, + U: _u, + OptU: _optU, + M_u8: _u8, + M_u16: _u16, + M_u32: _u32, + I: _i, + M_i8: _i8, + M_i16: _i16, + M_i32: _i32, + Bigint: _bigint, + OptBigint: _optBigint, + Bignumber: _bignumber, + OptBignumber: _optBignumber, + Json: _json, + OptJson: _optJson, + Bytes: _bytes, + OptBytes: _optBytes, + M_boolean: _boolean, + OptBoolean: _optBoolean, + U_array: _u_array, + UOpt_array: _uOpt_array, + _opt_uOptArray: __opt_uOptArray, + OptStrOptArray: _optStrOptArray, + UArrayArray: _uArrayArray, + UOptArrayOptArray: _uOptArrayOptArray, + UArrayOptArrayArray: _uArrayOptArrayArray, + CrazyArray: _crazyArray, + Object: _object, + OptObject: _optObject, + ObjectArray: _objectArray, + OptObjectArray: _optObjectArray, + En: _en, + OptEnum: _optEnum, + EnumArray: _enumArray, + OptEnumArray: _optEnumArray, + M_map: _map, + MapOfArr: _mapOfArr, + MapOfObj: _mapOfObj, + MapOfArrOfObj: _mapOfArrOfObj, + MapCustomValue: _mapCustomValue, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_env.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_env.go new file mode 100644 index 0000000000..14f90adbc6 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_env.go @@ -0,0 +1,27 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type Env struct { + Prop string `json:"prop"` + OptProp *string `json:"optProp"` + OptMap map[string]*int32 `json:"optMap"` +} + +func EnvToBuffer(value *Env) []byte { + return serializeEnv(value) +} + +func EnvFromBuffer(data []byte) *Env { + return deserializeEnv(data) +} + +func EnvWrite(writer msgpack.Write, value *Env) { + writeEnv(writer, value) +} + +func EnvRead(reader msgpack.Read) *Env { + return readEnv(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_env_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_env_serialization.go new file mode 100644 index 0000000000..9d12746234 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/object_env_serialization.go @@ -0,0 +1,114 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +func serializeEnv(value *Env) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: Env") + encoder := msgpack.NewWriteEncoder(ctx) + writeEnv(encoder, value) + return encoder.Buffer() +} + +func writeEnv(writer msgpack.Write, value *Env) { + writer.WriteMapLength(3) + writer.Context().Push("Prop", "string", "writing property") + writer.WriteString("Prop") + { + v := value.Prop + writer.WriteString(v) + } + writer.Context().Pop() + writer.Context().Push("OptProp", "*string", "writing property") + writer.WriteString("OptProp") + { + v := value.OptProp + if v == nil { + writer.WriteNil() + } else { + writer.WriteString(*v) + } + } + writer.Context().Pop() + writer.Context().Push("OptMap", "map[string]*int32", "writing property") + writer.WriteString("OptMap") + if value.OptMap == nil { + writer.WriteNil() + } else if len(value.OptMap) == 0 { + writer.WriteNil() + } else { + for i0 := range value.OptMap { + writer.WriteString(i0) + { + v := value.OptMap[i0] + if v == nil { + writer.WriteNil() + } else { + writer.WriteI32(*v) + } + } + } + } + writer.Context().Pop() +} + +func deserializeEnv(data []byte) *Env { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: Env") + reader := msgpack.NewReadDecoder(ctx, data) + return readEnv(reader) +} + +func readEnv(reader msgpack.Read) *Env { + var ( + _prop string + _propSet bool + _optProp *string + _optMap map[string]*int32 + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "prop": + reader.Context().Push(field, "string", "type found, reading property") + _prop = reader.ReadString() + _propSet = true + reader.Context().Pop() + case "optProp": + reader.Context().Push(field, "*string", "type found, reading property") + if !reader.IsNil() { + v := reader.ReadString() + _optProp = &v + } + reader.Context().Pop() + case "optMap": + reader.Context().Push(field, "map[string]*int32", "type found, reading property") + if reader.IsNil() { + _optMap = nil + } else { + ln0 := reader.ReadMapLength() + _optMap = make(map[string]*int32) + for j0 := uint32(0); j0 < ln0; j0++ { + i0 := reader.ReadString() + if !reader.IsNil() { + v := reader.ReadI32() + _optMap[i0] = &v + } + } + } + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_propSet { + panic(reader.Context().PrintWithContext("Missing required property: 'prop: String'")) + } + return &Env{ + Prop: _prop, + OptProp: _optProp, + OptMap: _optMap, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/objectelse.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/objectelse.go new file mode 100644 index 0000000000..930eb8f8e3 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/objectelse.go @@ -0,0 +1,25 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +type Else struct { + M_else string `json:"else"` +} + +func ElseToBuffer(value *Else) []byte { + return serializeElse(value) +} + +func ElseFromBuffer(data []byte) *Else { + return deserializeElse(data) +} + +func ElseWrite(writer msgpack.Write, value *Else) { + writeElse(writer, value) +} + +func ElseRead(reader msgpack.Read) *Else { + return readElse(reader) +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/types/objectelse_serialization.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/objectelse_serialization.go new file mode 100644 index 0000000000..a89c8e047d --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/types/objectelse_serialization.go @@ -0,0 +1,56 @@ +package types + +import ( + "github.com/polywrap/go-wrap/msgpack" +) + +func serializeElse(value *Else) []byte { + ctx := msgpack.NewContext("Serializing (encoding) env-type: Else") + encoder := msgpack.NewWriteEncoder(ctx) + writeElse(encoder, value) + return encoder.Buffer() +} + +func writeElse(writer msgpack.Write, value *Else) { + writer.WriteMapLength(1) + writer.Context().Push("M_else", "string", "writing property") + writer.WriteString("M_else") + { + v := value.M_else + writer.WriteString(v) + } + writer.Context().Pop() +} + +func deserializeElse(data []byte) *Else { + ctx := msgpack.NewContext("Deserializing (decoding) env-type: Else") + reader := msgpack.NewReadDecoder(ctx, data) + return readElse(reader) +} + +func readElse(reader msgpack.Read) *Else { + var ( + _else string + _elseSet bool + ) + + for i := int32(reader.ReadMapLength()); i > 0; i-- { + field := reader.ReadString() + reader.Context().Push(field, "unknown", "searching for property type") + switch field { + case "else": + reader.Context().Push(field, "string", "type found, reading property") + _else = reader.ReadString() + _elseSet = true + reader.Context().Pop() + } + reader.Context().Pop() + } + + if !_elseSet { + panic(reader.Context().PrintWithContext("Missing required property: 'else: String'")) + } + return &Else{ + M_else: _else, + } +} diff --git a/packages/test-cases/cases/bind/sanity/output/wasm-go/wrap.go b/packages/test-cases/cases/bind/sanity/output/wasm-go/wrap.go new file mode 100644 index 0000000000..a1080fa322 --- /dev/null +++ b/packages/test-cases/cases/bind/sanity/output/wasm-go/wrap.go @@ -0,0 +1 @@ +package wrap diff --git a/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/go.mod b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/go.mod new file mode 100644 index 0000000000..ef679eeb1b --- /dev/null +++ b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/go.mod @@ -0,0 +1,7 @@ +module example.com/go-wrap-test + +go 1.18 + +require github.com/polywrap/go-wrap wrap-0.1 + +require github.com/valyala/fastjson v1.6.3 // indirect diff --git a/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/go.sum b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/go.sum new file mode 100644 index 0000000000..35d9e89726 --- /dev/null +++ b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/go.sum @@ -0,0 +1,4 @@ +github.com/polywrap/go-wrap v0.0.0-20230712183729-e3684b1430f1 h1:fhJVAD+8CcssXc7g/F39AQdDHiV3li35mUyHeHp5/Dk= +github.com/polywrap/go-wrap v0.0.0-20230712183729-e3684b1430f1/go.mod h1:rxqhIFKUzn/M46+zjnA1RHlCzLGQn2BiLWalezhLj/k= +github.com/valyala/fastjson v1.6.3 h1:tAKFnnwmeMGPbwJ7IwxcTPCNr3uIzoIj3/Fh90ra4xc= +github.com/valyala/fastjson v1.6.3/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY= diff --git a/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/module/module.go b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/module/module.go new file mode 100644 index 0000000000..67c8df4810 --- /dev/null +++ b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/module/module.go @@ -0,0 +1,7 @@ +package module + +import "example.com/go-wrap-test/module/wrap/types" + +func Method(args *types.ArgsMethod) string { + return args.Arg +} diff --git a/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/polywrap.yaml b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/polywrap.yaml new file mode 100644 index 0000000000..07650dd125 --- /dev/null +++ b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/polywrap.yaml @@ -0,0 +1,7 @@ +format: 0.4.0 +project: + name: ObjectTypes + type: wasm/golang +source: + schema: ./schema.graphql + module: ./go.mod diff --git a/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/schema.graphql b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/schema.graphql new file mode 100644 index 0000000000..325e224971 --- /dev/null +++ b/packages/test-cases/cases/cli/build-cmd/wasm/golang/001-sanity/schema.graphql @@ -0,0 +1,5 @@ +type Module { + method( + arg: String! + ): String! +} diff --git a/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/expected/stdout.json b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/expected/stdout.json new file mode 100644 index 0000000000..735a6dca2c --- /dev/null +++ b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/expected/stdout.json @@ -0,0 +1,4 @@ +{ + "stdout": "Types were generated successfully", + "exitCode": 0 +} diff --git a/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/go.mod b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/go.mod new file mode 100644 index 0000000000..ef679eeb1b --- /dev/null +++ b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/go.mod @@ -0,0 +1,7 @@ +module example.com/go-wrap-test + +go 1.18 + +require github.com/polywrap/go-wrap wrap-0.1 + +require github.com/valyala/fastjson v1.6.3 // indirect diff --git a/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/module/module.go b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/module/module.go new file mode 100644 index 0000000000..67c8df4810 --- /dev/null +++ b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/module/module.go @@ -0,0 +1,7 @@ +package module + +import "example.com/go-wrap-test/module/wrap/types" + +func Method(args *types.ArgsMethod) string { + return args.Arg +} diff --git a/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/polywrap.yaml b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/polywrap.yaml new file mode 100644 index 0000000000..07650dd125 --- /dev/null +++ b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/polywrap.yaml @@ -0,0 +1,7 @@ +format: 0.4.0 +project: + name: ObjectTypes + type: wasm/golang +source: + schema: ./schema.graphql + module: ./go.mod diff --git a/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/schema.graphql b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/schema.graphql new file mode 100644 index 0000000000..3dc66d388a --- /dev/null +++ b/packages/test-cases/cases/cli/codegen/wasm/008-sanity-golang/schema.graphql @@ -0,0 +1,5 @@ +type Module { + method( + arg: String! + ): String! +} \ No newline at end of file diff --git a/packages/test-cases/yarn.lock b/packages/test-cases/yarn.lock deleted file mode 100644 index 3a95d739de..0000000000 --- a/packages/test-cases/yarn.lock +++ /dev/null @@ -1,338 +0,0 @@ -# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. -# yarn lockfile v1 - - -"@cspotcode/source-map-support@^0.8.0": - version "0.8.1" - resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz#00629c35a688e05a88b1cda684fb9d5e73f000a1" - integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw== - dependencies: - "@jridgewell/trace-mapping" "0.3.9" - -"@jridgewell/resolve-uri@^3.0.3": - version "3.1.1" - resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721" - integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA== - -"@jridgewell/sourcemap-codec@^1.4.10": - version "1.4.15" - resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32" - integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg== - -"@jridgewell/trace-mapping@0.3.9": - version "0.3.9" - resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9" - integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ== - dependencies: - "@jridgewell/resolve-uri" "^3.0.3" - "@jridgewell/sourcemap-codec" "^1.4.10" - -"@polywrap/os-js@0.10.5": - version "0.10.5" - resolved "https://registry.yarnpkg.com/@polywrap/os-js/-/os-js-0.10.5.tgz#b9ecae978f69edc341aedec1867161d1e609eb3a" - integrity sha512-Xh7KqCQy2aEoHDGQE5eV2ykCDjhCRzUVryiF+P/HbfxG//bW6Wte4e97H4tcuD8RkApYVaGjmUTAlvX+g+26AQ== - -"@tsconfig/node10@^1.0.7": - version "1.0.9" - resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2" - integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA== - -"@tsconfig/node12@^1.0.7": - version "1.0.11" - resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.11.tgz#ee3def1f27d9ed66dac6e46a295cffb0152e058d" - integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag== - -"@tsconfig/node14@^1.0.0": - version "1.0.3" - resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.3.tgz#e4386316284f00b98435bf40f72f75a09dabf6c1" - integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow== - -"@tsconfig/node16@^1.0.2": - version "1.0.4" - resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9" - integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA== - -"@types/adm-zip@0.5.0": - version "0.5.0" - resolved "https://registry.yarnpkg.com/@types/adm-zip/-/adm-zip-0.5.0.tgz#94c90a837ce02e256c7c665a6a1eb295906333c1" - integrity sha512-FCJBJq9ODsQZUNURo5ILAQueuA8WJhRvuihS3ke2iI25mJlfV2LK8jG2Qj2z2AWg8U0FtWWqBHVRetceLskSaw== - dependencies: - "@types/node" "*" - -"@types/glob@*": - version "8.1.0" - resolved "https://registry.yarnpkg.com/@types/glob/-/glob-8.1.0.tgz#b63e70155391b0584dce44e7ea25190bbc38f2fc" - integrity sha512-IO+MJPVhoqz+28h1qLAcBEH2+xHMK6MTyHJc7MTnnYb6wsoLR29POVGJ7LycmVXIqyy/4/2ShP5sUwTXuOwb/w== - dependencies: - "@types/minimatch" "^5.1.2" - "@types/node" "*" - -"@types/minimatch@^5.1.2": - version "5.1.2" - resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-5.1.2.tgz#07508b45797cb81ec3f273011b054cd0755eddca" - integrity sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA== - -"@types/node@*": - version "20.3.2" - resolved "https://registry.yarnpkg.com/@types/node/-/node-20.3.2.tgz#fa6a90f2600e052a03c18b8cb3fd83dd4e599898" - integrity sha512-vOBLVQeCQfIcF/2Y7eKFTqrMnizK5lRNQ7ykML/5RuwVXVWxYkgwS7xbt4B6fKCUPgbSL5FSsjHQpaGQP/dQmw== - -"@types/shelljs@0.8.9": - version "0.8.9" - resolved "https://registry.yarnpkg.com/@types/shelljs/-/shelljs-0.8.9.tgz#45dd8501aa9882976ca3610517dac3831c2fbbf4" - integrity sha512-flVe1dvlrCyQJN/SGrnBxqHG+RzXrVKsmjD8WS/qYHpq5UPjfq7UWFBENP0ZuOl0g6OpAlL6iBoLSvKYUUmyQw== - dependencies: - "@types/glob" "*" - "@types/node" "*" - -acorn-walk@^8.1.1: - version "8.2.0" - resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1" - integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA== - -acorn@^8.4.1: - version "8.9.0" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.9.0.tgz#78a16e3b2bcc198c10822786fa6679e245db5b59" - integrity sha512-jaVNAFBHNLXspO543WnNNPZFRtavh3skAkITqD0/2aeMkKZTN+254PyhwxFYrk3vQ1xfY+2wbesJMs/JC8/PwQ== - -adm-zip@0.5.10: - version "0.5.10" - resolved "https://registry.yarnpkg.com/adm-zip/-/adm-zip-0.5.10.tgz#4a51d5ab544b1f5ce51e1b9043139b639afff45b" - integrity sha512-x0HvcHqVJNTPk/Bw8JbLWlWoo6Wwnsug0fnYYro1HBrjxZ3G7/AZk7Ahv8JwDe1uIcz8eBqvu86FuF1POiG7vQ== - -arg@^4.1.0: - version "4.1.3" - resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089" - integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== - -asynckit@^0.4.0: - version "0.4.0" - resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" - integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== - -axios@1.2.2: - version "1.2.2" - resolved "https://registry.yarnpkg.com/axios/-/axios-1.2.2.tgz#72681724c6e6a43a9fea860fc558127dbe32f9f1" - integrity sha512-bz/J4gS2S3I7mpN/YZfGFTqhXTYzRho8Ay38w2otuuDR322KzFIWm/4W2K6gIwvWaws5n+mnb7D1lN9uD+QH6Q== - dependencies: - follow-redirects "^1.15.0" - form-data "^4.0.0" - proxy-from-env "^1.1.0" - -balanced-match@^1.0.0: - version "1.0.2" - resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" - integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== - -brace-expansion@^1.1.7: - version "1.1.11" - resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd" - integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== - dependencies: - balanced-match "^1.0.0" - concat-map "0.0.1" - -combined-stream@^1.0.8: - version "1.0.8" - resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f" - integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== - dependencies: - delayed-stream "~1.0.0" - -concat-map@0.0.1: - version "0.0.1" - resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" - integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== - -create-require@^1.1.0: - version "1.1.1" - resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333" - integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== - -delayed-stream@~1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" - integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== - -diff@^4.0.1: - version "4.0.2" - resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d" - integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== - -follow-redirects@^1.15.0: - version "1.15.2" - resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.2.tgz#b460864144ba63f2681096f274c4e57026da2c13" - integrity sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA== - -form-data@^4.0.0: - version "4.0.0" - resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.0.tgz#93919daeaf361ee529584b9b31664dc12c9fa452" - integrity sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww== - dependencies: - asynckit "^0.4.0" - combined-stream "^1.0.8" - mime-types "^2.1.12" - -fs.realpath@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" - integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== - -function-bind@^1.1.1: - version "1.1.1" - resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" - integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== - -glob@^7.0.0: - version "7.2.3" - resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" - integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== - dependencies: - fs.realpath "^1.0.0" - inflight "^1.0.4" - inherits "2" - minimatch "^3.1.1" - once "^1.3.0" - path-is-absolute "^1.0.0" - -has@^1.0.3: - version "1.0.3" - resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796" - integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw== - dependencies: - function-bind "^1.1.1" - -inflight@^1.0.4: - version "1.0.6" - resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" - integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== - dependencies: - once "^1.3.0" - wrappy "1" - -inherits@2: - version "2.0.4" - resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" - integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== - -interpret@^1.0.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e" - integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA== - -is-core-module@^2.11.0: - version "2.12.1" - resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.12.1.tgz#0c0b6885b6f80011c71541ce15c8d66cf5a4f9fd" - integrity sha512-Q4ZuBAe2FUsKtyQJoQHlvP8OvBERxO3jEmy1I7hcRXcJBGGHFh/aJBswbXuS9sgrDH2QUO8ilkwNPHvHMd8clg== - dependencies: - has "^1.0.3" - -make-error@^1.1.1: - version "1.3.6" - resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" - integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== - -mime-db@1.52.0: - version "1.52.0" - resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" - integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== - -mime-types@^2.1.12: - version "2.1.35" - resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" - integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== - dependencies: - mime-db "1.52.0" - -minimatch@^3.1.1: - version "3.1.2" - resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" - integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== - dependencies: - brace-expansion "^1.1.7" - -once@^1.3.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" - integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== - dependencies: - wrappy "1" - -path-is-absolute@^1.0.0: - version "1.0.1" - resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" - integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== - -path-parse@^1.0.7: - version "1.0.7" - resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" - integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== - -proxy-from-env@^1.1.0: - version "1.1.0" - resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2" - integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg== - -rechoir@^0.6.2: - version "0.6.2" - resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384" - integrity sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw== - dependencies: - resolve "^1.1.6" - -resolve@^1.1.6: - version "1.22.2" - resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.2.tgz#0ed0943d4e301867955766c9f3e1ae6d01c6845f" - integrity sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g== - dependencies: - is-core-module "^2.11.0" - path-parse "^1.0.7" - supports-preserve-symlinks-flag "^1.0.0" - -shelljs@0.8.5: - version "0.8.5" - resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.5.tgz#de055408d8361bed66c669d2f000538ced8ee20c" - integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow== - dependencies: - glob "^7.0.0" - interpret "^1.0.0" - rechoir "^0.6.2" - -supports-preserve-symlinks-flag@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09" - integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== - -ts-node@10.9.1: - version "10.9.1" - resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.9.1.tgz#e73de9102958af9e1f0b168a6ff320e25adcff4b" - integrity sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw== - dependencies: - "@cspotcode/source-map-support" "^0.8.0" - "@tsconfig/node10" "^1.0.7" - "@tsconfig/node12" "^1.0.7" - "@tsconfig/node14" "^1.0.0" - "@tsconfig/node16" "^1.0.2" - acorn "^8.4.1" - acorn-walk "^8.1.1" - arg "^4.1.0" - create-require "^1.1.0" - diff "^4.0.1" - make-error "^1.1.1" - v8-compile-cache-lib "^3.0.1" - yn "3.1.1" - -v8-compile-cache-lib@^3.0.1: - version "3.0.1" - resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf" - integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== - -wrappy@1: - version "1.0.2" - resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" - integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== - -yn@3.1.1: - version "3.1.1" - resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50" - integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q== diff --git a/yarn.lock b/yarn.lock index 5b08c59716..2185460b6b 100644 --- a/yarn.lock +++ b/yarn.lock @@ -113,52 +113,52 @@ dependencies: "@babel/highlight" "^7.22.5" -"@babel/compat-data@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.22.5.tgz#b1f6c86a02d85d2dd3368a2b67c09add8cd0c255" - integrity sha512-4Jc/YuIaYqKnDDz892kPIledykKg12Aw1PYX5i/TY28anJtacvM1Rrr8wbieB9GfEJwlzqT0hUEao0CxEebiDA== +"@babel/compat-data@^7.22.9": + version "7.22.9" + resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.22.9.tgz#71cdb00a1ce3a329ce4cbec3a44f9fef35669730" + integrity sha512-5UamI7xkUcJ3i9qVDS+KFDEK8/7oJ55/sJMB1Ge7IEapr7KfdfV/HErR+koZwOfd+SgtFKOKRhRakdg++DcJpQ== "@babel/core@^7.1.0", "@babel/core@^7.12.3", "@babel/core@^7.7.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.22.5.tgz#d67d9747ecf26ee7ecd3ebae1ee22225fe902a89" - integrity sha512-SBuTAjg91A3eKOvD+bPEz3LlhHZRNu1nFOVts9lzDJTXshHTjII0BAtDS3Y2DAkdZdDKWVZGVwkDfc4Clxn1dg== + version "7.22.9" + resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.22.9.tgz#bd96492c68822198f33e8a256061da3cf391f58f" + integrity sha512-G2EgeufBcYw27U4hhoIwFcgc1XU7TlXJ3mv04oOv1WCuo900U/anZSPzEqNjwdjgffkk2Gs0AN0dW1CKVLcG7w== dependencies: "@ampproject/remapping" "^2.2.0" "@babel/code-frame" "^7.22.5" - "@babel/generator" "^7.22.5" - "@babel/helper-compilation-targets" "^7.22.5" - "@babel/helper-module-transforms" "^7.22.5" - "@babel/helpers" "^7.22.5" - "@babel/parser" "^7.22.5" + "@babel/generator" "^7.22.9" + "@babel/helper-compilation-targets" "^7.22.9" + "@babel/helper-module-transforms" "^7.22.9" + "@babel/helpers" "^7.22.6" + "@babel/parser" "^7.22.7" "@babel/template" "^7.22.5" - "@babel/traverse" "^7.22.5" + "@babel/traverse" "^7.22.8" "@babel/types" "^7.22.5" convert-source-map "^1.7.0" debug "^4.1.0" gensync "^1.0.0-beta.2" json5 "^2.2.2" - semver "^6.3.0" + semver "^6.3.1" -"@babel/generator@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.22.5.tgz#1e7bf768688acfb05cf30b2369ef855e82d984f7" - integrity sha512-+lcUbnTRhd0jOewtFSedLyiPsD5tswKkbgcezOqqWFUVNEwoUTlpPOBmvhG7OXWLR4jMdv0czPGH5XbflnD1EA== +"@babel/generator@^7.22.7", "@babel/generator@^7.22.9": + version "7.22.9" + resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.22.9.tgz#572ecfa7a31002fa1de2a9d91621fd895da8493d" + integrity sha512-KtLMbmicyuK2Ak/FTCJVbDnkN1SlT8/kceFTiuDiiRUUSMnHMidxSCdG4ndkTOHHpoomWe/4xkvHkEOncwjYIw== dependencies: "@babel/types" "^7.22.5" "@jridgewell/gen-mapping" "^0.3.2" "@jridgewell/trace-mapping" "^0.3.17" jsesc "^2.5.1" -"@babel/helper-compilation-targets@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.5.tgz#fc7319fc54c5e2fa14b2909cf3c5fd3046813e02" - integrity sha512-Ji+ywpHeuqxB8WDxraCiqR0xfhYjiDE/e6k7FuIaANnoOFxAHskHChz4vA1mJC9Lbm01s1PVAGhQY4FUKSkGZw== +"@babel/helper-compilation-targets@^7.22.9": + version "7.22.9" + resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.9.tgz#f9d0a7aaaa7cd32a3f31c9316a69f5a9bcacb892" + integrity sha512-7qYrNM6HjpnPHJbopxmb8hSPoZ0gsX8IvUS32JGVoy+pU9e5N0nLr1VjJoR6kA4d9dmGLxNYOjeB8sUDal2WMw== dependencies: - "@babel/compat-data" "^7.22.5" + "@babel/compat-data" "^7.22.9" "@babel/helper-validator-option" "^7.22.5" - browserslist "^4.21.3" + browserslist "^4.21.9" lru-cache "^5.1.1" - semver "^6.3.0" + semver "^6.3.1" "@babel/helper-environment-visitor@^7.22.5": version "7.22.5" @@ -187,19 +187,16 @@ dependencies: "@babel/types" "^7.22.5" -"@babel/helper-module-transforms@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.22.5.tgz#0f65daa0716961b6e96b164034e737f60a80d2ef" - integrity sha512-+hGKDt/Ze8GFExiVHno/2dvG5IdstpzCq0y4Qc9OJ25D4q3pKfiIP/4Vp3/JvhDkLKsDK2api3q3fpIgiIF5bw== +"@babel/helper-module-transforms@^7.22.9": + version "7.22.9" + resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.22.9.tgz#92dfcb1fbbb2bc62529024f72d942a8c97142129" + integrity sha512-t+WA2Xn5K+rTeGtC8jCsdAH52bjggG5TKRuRrAGNM/mjIbO4GxvlLMFOEz9wXY5I2XQ60PMFsAG2WIcG82dQMQ== dependencies: "@babel/helper-environment-visitor" "^7.22.5" "@babel/helper-module-imports" "^7.22.5" "@babel/helper-simple-access" "^7.22.5" - "@babel/helper-split-export-declaration" "^7.22.5" + "@babel/helper-split-export-declaration" "^7.22.6" "@babel/helper-validator-identifier" "^7.22.5" - "@babel/template" "^7.22.5" - "@babel/traverse" "^7.22.5" - "@babel/types" "^7.22.5" "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.8.0": version "7.22.5" @@ -213,10 +210,10 @@ dependencies: "@babel/types" "^7.22.5" -"@babel/helper-split-export-declaration@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.5.tgz#88cf11050edb95ed08d596f7a044462189127a08" - integrity sha512-thqK5QFghPKWLhAV321lxF95yCg2K3Ob5yw+M3VHWfdia0IkPXUtoLH8x/6Fh486QUvzhb8YOWHChTVen2/PoQ== +"@babel/helper-split-export-declaration@^7.22.6": + version "7.22.6" + resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz#322c61b7310c0997fe4c323955667f18fcefb91c" + integrity sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g== dependencies: "@babel/types" "^7.22.5" @@ -235,13 +232,13 @@ resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.22.5.tgz#de52000a15a177413c8234fa3a8af4ee8102d0ac" integrity sha512-R3oB6xlIVKUnxNUxbmgq7pKjxpru24zlimpE8WK47fACIlM0II/Hm1RS8IaOI7NgCr6LNS+jl5l75m20npAziw== -"@babel/helpers@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.22.5.tgz#74bb4373eb390d1ceed74a15ef97767e63120820" - integrity sha512-pSXRmfE1vzcUIDFQcSGA5Mr+GxBV9oiRKDuDxXvWQQBCh8HoIjs/2DlDB7H8smac1IVrB9/xdXj2N3Wol9Cr+Q== +"@babel/helpers@^7.22.6": + version "7.22.6" + resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.22.6.tgz#8e61d3395a4f0c5a8060f309fb008200969b5ecd" + integrity sha512-YjDs6y/fVOYFV8hAf1rxd1QvR9wJe1pDBZ2AREKq/SDayfPzgk0PBnVuTCE5X1acEpMMNOVUqoe+OwiZGJ+OaA== dependencies: "@babel/template" "^7.22.5" - "@babel/traverse" "^7.22.5" + "@babel/traverse" "^7.22.6" "@babel/types" "^7.22.5" "@babel/highlight@^7.22.5": @@ -253,10 +250,10 @@ chalk "^2.0.0" js-tokens "^4.0.0" -"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.22.5.tgz#721fd042f3ce1896238cf1b341c77eb7dee7dbea" - integrity sha512-DFZMC9LJUG9PLOclRC32G63UXwzqS2koQC8dkx+PLdmt1xSePYpbT/NbsrJy8Q/muXz7o/h/d4A7Fuyixm559Q== +"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.22.5", "@babel/parser@^7.22.7": + version "7.22.7" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.22.7.tgz#df8cf085ce92ddbdbf668a7f186ce848c9036cae" + integrity sha512-7NF8pOkHP5o2vpmGgNGcfAeCvOYhGLyA3Z4eBQkT1RJlWu47n63bCs93QfJ2hIAFCil7L5P2IWhs1oToVgrL0Q== "@babel/plugin-syntax-async-generators@^7.8.4": version "7.8.4" @@ -351,18 +348,18 @@ "@babel/parser" "^7.22.5" "@babel/types" "^7.22.5" -"@babel/traverse@^7.1.0", "@babel/traverse@^7.22.5": - version "7.22.5" - resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.22.5.tgz#44bd276690db6f4940fdb84e1cb4abd2f729ccd1" - integrity sha512-7DuIjPgERaNo6r+PZwItpjCZEa5vyw4eJGufeLxrPdBXBoLcCJCIasvK6pK/9DVNrLZTLFhUGqaC6X/PA007TQ== +"@babel/traverse@^7.1.0", "@babel/traverse@^7.22.6", "@babel/traverse@^7.22.8": + version "7.22.8" + resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.22.8.tgz#4d4451d31bc34efeae01eac222b514a77aa4000e" + integrity sha512-y6LPR+wpM2I3qJrsheCTwhIinzkETbplIgPBbwvqPKc+uljeA5gP+3nP8irdYt1mjQaDnlIcG+dw8OjAco4GXw== dependencies: "@babel/code-frame" "^7.22.5" - "@babel/generator" "^7.22.5" + "@babel/generator" "^7.22.7" "@babel/helper-environment-visitor" "^7.22.5" "@babel/helper-function-name" "^7.22.5" "@babel/helper-hoist-variables" "^7.22.5" - "@babel/helper-split-export-declaration" "^7.22.5" - "@babel/parser" "^7.22.5" + "@babel/helper-split-export-declaration" "^7.22.6" + "@babel/parser" "^7.22.7" "@babel/types" "^7.22.5" debug "^4.1.0" globals "^11.1.0" @@ -2760,14 +2757,14 @@ integrity sha512-wH6Tu9mbiOt0n5EvdoWy0VGQaJMHfLIxY/6wS0xLC7CV1taM6gESEzcYy0ZlWvxxiiljYvfDIvz4hHbUUDRlhw== "@types/node@*": - version "20.3.2" - resolved "https://registry.yarnpkg.com/@types/node/-/node-20.3.2.tgz#fa6a90f2600e052a03c18b8cb3fd83dd4e599898" - integrity sha512-vOBLVQeCQfIcF/2Y7eKFTqrMnizK5lRNQ7ykML/5RuwVXVWxYkgwS7xbt4B6fKCUPgbSL5FSsjHQpaGQP/dQmw== + version "20.4.1" + resolved "https://registry.yarnpkg.com/@types/node/-/node-20.4.1.tgz#a6033a8718653c50ac4962977e14d0f984d9527d" + integrity sha512-JIzsAvJeA/5iY6Y/OxZbv1lUcc8dNSE77lb2gnBH+/PJ3lFR1Ccvgwl5JWnHAkNHcRsT0TbpVOsiMKZ1F/yyJg== "@types/node@^18.14.6": - version "18.16.18" - resolved "https://registry.yarnpkg.com/@types/node/-/node-18.16.18.tgz#85da09bafb66d4bc14f7c899185336d0c1736390" - integrity sha512-/aNaQZD0+iSBAGnvvN2Cx92HqE5sZCPZtx2TsK+4nvV23fFe09jVDvpArXr2j9DnYlzuU9WuoykDDc6wqvpNcw== + version "18.16.19" + resolved "https://registry.yarnpkg.com/@types/node/-/node-18.16.19.tgz#cb03fca8910fdeb7595b755126a8a78144714eea" + integrity sha512-IXl7o+R9iti9eBW4Wg2hx1xQDig183jj7YLn8F7udNceyfkbn1ZxmzZXuak20gR40D7pIkIY1kYGx5VIGbaHKA== "@types/normalize-package-data@^2.4.0": version "2.4.1" @@ -3002,9 +2999,9 @@ acorn@^7.1.1, acorn@^7.4.0: integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A== acorn@^8.2.4, acorn@^8.4.1: - version "8.9.0" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.9.0.tgz#78a16e3b2bcc198c10822786fa6679e245db5b59" - integrity sha512-jaVNAFBHNLXspO543WnNNPZFRtavh3skAkITqD0/2aeMkKZTN+254PyhwxFYrk3vQ1xfY+2wbesJMs/JC8/PwQ== + version "8.10.0" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.10.0.tgz#8be5b3907a67221a81ab23c7889c4c5526b62ec5" + integrity sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw== add-stream@^1.0.0: version "1.0.0" @@ -3527,7 +3524,7 @@ browser-process-hrtime@^1.0.0: resolved "https://registry.yarnpkg.com/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz#3c9b4b7d782c8121e56f10106d84c0d0ffc94626" integrity sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow== -browserslist@^4.21.3: +browserslist@^4.21.9: version "4.21.9" resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.9.tgz#e11bdd3c313d7e2a9e87e8b4b0c7872b13897635" integrity sha512-M0MFoZzbUrRU4KNfCrDLnvyE7gub+peetoTid3TBIqtunaDJyXlwhakT+/VkvSXcfIzFfK/nkCs4nmyTmxdNSg== @@ -3666,9 +3663,9 @@ camelcase@^6.0.0: integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== caniuse-lite@^1.0.30001503: - version "1.0.30001509" - resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001509.tgz#2b7ad5265392d6d2de25cd8776d1ab3899570d14" - integrity sha512-2uDDk+TRiTX5hMcUYT/7CSyzMZxjfGu0vAUjS2g0LSD8UoXOv0LtpH4LxGMemsiPq6LCVIUjNwVM0erkOkGCDA== + version "1.0.30001515" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001515.tgz#418aefeed9d024cd3129bfae0ccc782d4cb8f12b" + integrity sha512-eEFDwUOZbE24sb+Ecsx3+OvNETqjWIdabMy52oOkIgcUtAsQifjUG9q4U9dgTHJM2mfk4uEPxc0+xuFdJ629QA== capture-exit@^2.0.0: version "2.0.0" @@ -3869,9 +3866,9 @@ code-point-at@^1.0.0: integrity sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA== collect-v8-coverage@^1.0.0: - version "1.0.1" - resolved "https://registry.yarnpkg.com/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz#cc2c8e94fc18bbdffe64d6534570c8a673b27f59" - integrity sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg== + version "1.0.2" + resolved "https://registry.yarnpkg.com/collect-v8-coverage/-/collect-v8-coverage-1.0.2.tgz#c0b29bcd33bcd0779a1344c2136051e6afd3d9e9" + integrity sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q== collection-visit@^1.0.0: version "1.0.0" @@ -4251,7 +4248,7 @@ dedent@^0.7.0: resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c" integrity sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA== -deep-is@^0.1.3, deep-is@~0.1.3: +deep-is@^0.1.3: version "0.1.4" resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831" integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== @@ -4443,9 +4440,9 @@ ecc-jsbn@~0.1.1: safer-buffer "^2.1.0" electron-to-chromium@^1.4.431: - version "1.4.445" - resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.445.tgz#058d2c5f3a2981ab1a37440f5a5e42d15672aa6d" - integrity sha512-++DB+9VK8SBJwC+X1zlMfJ1tMA3F0ipi39GdEp+x3cV2TyBihqAgad8cNMWtLDEkbH39nlDQP7PfGrDr3Dr7HA== + version "1.4.457" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.457.tgz#3fdc7b4f97d628ac6b51e8b4b385befb362fe343" + integrity sha512-/g3UyNDmDd6ebeWapmAoiyy+Sy2HyJ+/X8KyvNeHfKRFfHaA2W8oF5fxD5F3tjBDcjpwo0iek6YNgxNXDBoEtA== elliptic@6.5.4: version "6.5.4" @@ -4640,14 +4637,13 @@ escape-string-regexp@^2.0.0: integrity sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== escodegen@^2.0.0: - version "2.0.0" - resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-2.0.0.tgz#5e32b12833e8aa8fa35e1bf0befa89380484c7dd" - integrity sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw== + version "2.1.0" + resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-2.1.0.tgz#ba93bbb7a43986d29d6041f99f5262da773e2e17" + integrity sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w== dependencies: esprima "^4.0.1" estraverse "^5.2.0" esutils "^2.0.2" - optionator "^0.8.1" optionalDependencies: source-map "~0.6.1" @@ -5039,9 +5035,9 @@ fast-diff@^1.1.2: integrity sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw== fast-glob@^3.2.5, fast-glob@^3.2.9: - version "3.2.12" - resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80" - integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w== + version "3.3.0" + resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.0.tgz#7c40cb491e1e2ed5664749e87bfb516dbe8727c0" + integrity sha512-ChDuvbOypPuNjO8yIDf36x7BlZX1smcUMTTcyoIjycexOxd6DFsKsg21qVBzEmr3G7fUKIRy2/psii+CIUt7FA== dependencies: "@nodelib/fs.stat" "^2.0.2" "@nodelib/fs.walk" "^1.2.3" @@ -5054,7 +5050,7 @@ fast-json-stable-stringify@2.x, fast-json-stable-stringify@^2.0.0: resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== -fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.6: +fast-levenshtein@^2.0.6: version "2.0.6" resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== @@ -6938,14 +6934,6 @@ levn@^0.4.1: prelude-ls "^1.2.1" type-check "~0.4.0" -levn@~0.3.0: - version "0.3.0" - resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee" - integrity sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA== - dependencies: - prelude-ls "~1.1.2" - type-check "~0.3.2" - libnpmaccess@^4.0.1: version "4.0.3" resolved "https://registry.yarnpkg.com/libnpmaccess/-/libnpmaccess-4.0.3.tgz#dfb0e5b0a53c315a2610d300e46b4ddeb66e7eec" @@ -7589,9 +7577,9 @@ nice-try@^1.0.4: integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ== node-fetch@^2.6.1, node-fetch@^2.6.7: - version "2.6.11" - resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.11.tgz#cde7fc71deef3131ef80a738919f999e6edfff25" - integrity sha512-4I6pdBY1EthSqDmJkiNk3JIT8cswwR9nfeW/cPdUagJYEQG7R95WRH74wpz7ma8Gh/9dI9FP+OU+0E4FvtA55w== + version "2.6.12" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.12.tgz#02eb8e22074018e3d5a83016649d04df0e348fba" + integrity sha512-C/fGU2E8ToujUivIO0H+tpQ6HWo4eEmchoPIoXtxCrVghxdKq+QOHqEZW7tuP3KlV3bC8FRMO5nMCC7Zm1VP6g== dependencies: whatwg-url "^5.0.0" @@ -7646,9 +7634,9 @@ node-notifier@^8.0.0: which "^2.0.2" node-releases@^2.0.12: - version "2.0.12" - resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.12.tgz#35627cc224a23bfb06fb3380f2b3afaaa7eb1039" - integrity sha512-QzsYKWhXTWx8h1kIvqfnC++o0pEmpRQA/aenALsL2F4pqNVr7YzcdMlDij5WBnwftRbJCNJL/O7zdKaxKPHqgQ== + version "2.0.13" + resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.13.tgz#d5ed1627c23e3461e819b02e57b75e4899b1c81d" + integrity sha512-uYr7J37ae/ORWdZeQ1xxMJe3NtdmqMC/JZK+geofDrkLUApKRHPd18/TxtBOJ4A0/+uUIliorNrfYV6s1b02eQ== noms@0.0.0: version "0.0.0" @@ -7828,9 +7816,9 @@ number-is-nan@^1.0.0: integrity sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ== nwsapi@^2.2.0: - version "2.2.5" - resolved "https://registry.yarnpkg.com/nwsapi/-/nwsapi-2.2.5.tgz#a52744c61b3889dd44b0a158687add39b8d935e2" - integrity sha512-6xpotnECFy/og7tKSBVmUNft7J3jyXAka4XvG6AUhFWRz+Q/Ljus7znJAA3bxColfQLdS+XsjoodtJfCgeTEFQ== + version "2.2.7" + resolved "https://registry.yarnpkg.com/nwsapi/-/nwsapi-2.2.7.tgz#738e0707d3128cb750dddcfe90e4610482df0f30" + integrity sha512-ub5E4+FBPKwAZx0UwIQOjYWGHTEq5sPqHQNRN8Z9e4A7u3Tj1weLJsL59yH9vmvqEtBHaOmT6cYQKIZOxp35FQ== oauth-sign@~0.9.0: version "0.9.0" @@ -7919,18 +7907,6 @@ onetime@^5.1.0, onetime@^5.1.2: dependencies: mimic-fn "^2.1.0" -optionator@^0.8.1: - version "0.8.3" - resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495" - integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA== - dependencies: - deep-is "~0.1.3" - fast-levenshtein "~2.0.6" - levn "~0.3.0" - prelude-ls "~1.1.2" - type-check "~0.3.2" - word-wrap "~1.2.3" - optionator@^0.9.1: version "0.9.3" resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.3.tgz#007397d44ed1872fdc6ed31360190f81814e2c64" @@ -8270,11 +8246,6 @@ prelude-ls@^1.2.1: resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396" integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g== -prelude-ls@~1.1.2: - version "1.1.2" - resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54" - integrity sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w== - prettier-linter-helpers@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b" @@ -8893,9 +8864,9 @@ scrypt-js@3.0.1: integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA== "semver@2 || 3 || 4 || 5", semver@^5.5.0, semver@^5.6.0, semver@^5.7.1: - version "5.7.1" - resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7" - integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ== + version "5.7.2" + resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8" + integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g== semver@7.3.8: version "7.3.8" @@ -8918,17 +8889,24 @@ semver@7.5.0: dependencies: lru-cache "^6.0.0" -semver@7.5.3, semver@7.x, semver@^7.1.1, semver@^7.1.3, semver@^7.2.1, semver@^7.3.2, semver@^7.3.4, semver@^7.3.5: +semver@7.5.3: version "7.5.3" resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.3.tgz#161ce8c2c6b4b3bdca6caadc9fa3317a4c4fe88e" integrity sha512-QBlUtyVk/5EeHbi7X0fw6liDZc7BBmEaSYn01fMU1OUYbf6GPsbTtd8WmnqbI20SeycoHSeiybkE/q1Q+qlThQ== dependencies: lru-cache "^6.0.0" -semver@^6.0.0, semver@^6.3.0: - version "6.3.0" - resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d" - integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== +semver@7.x, semver@^7.1.1, semver@^7.1.3, semver@^7.2.1, semver@^7.3.2, semver@^7.3.4, semver@^7.3.5: + version "7.5.4" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e" + integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA== + dependencies: + lru-cache "^6.0.0" + +semver@^6.0.0, semver@^6.3.0, semver@^6.3.1: + version "6.3.1" + resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4" + integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== set-blocking@^2.0.0, set-blocking@~2.0.0: version "2.0.0" @@ -9715,13 +9693,6 @@ type-check@^0.4.0, type-check@~0.4.0: dependencies: prelude-ls "^1.2.1" -type-check@~0.3.2: - version "0.3.2" - resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72" - integrity sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg== - dependencies: - prelude-ls "~1.1.2" - type-detect@4.0.8: version "4.0.8" resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c" @@ -10111,9 +10082,9 @@ which-module@^2.0.0: integrity sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ== which-typed-array@^1.1.9: - version "1.1.9" - resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.9.tgz#307cf898025848cf995e795e8423c7f337efbde6" - integrity sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA== + version "1.1.10" + resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.10.tgz#74baa2789991905c2076abb317103b866c64e69e" + integrity sha512-uxoA5vLUfRPdjCuJ1h5LlYdmTLbYfums398v3WLkM+i/Wltl2/XyZpQWKbN++ck5L64SR/grOHqtXCUKmlZPNA== dependencies: available-typed-arrays "^1.0.5" call-bind "^1.0.2" @@ -10143,11 +10114,6 @@ wide-align@^1.1.0: dependencies: string-width "^1.0.2 || 2 || 3 || 4" -word-wrap@~1.2.3: - version "1.2.3" - resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" - integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== - wordwrap@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"