@hyperweb/telescope 1.15.0

package/module/generators/create-rpc-query-client-all.js

@@ -0,0 +1,110 @@
+import * as dotty from 'dotty';
+import { getNestedProto, isRefIncluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { createScopedRpcTmFactory, createScopedGrpcWebFactory, createScopedGrpcGatewayFactory } from '@cosmology/ast';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { TelescopeParseContext } from '../build';
+import { aggregateImports, getDepsFromQueries, getImportStatements } from '../imports';
+export const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.rpcClients?.enabled) {
+        return;
+    }
+    if (builder.options?.rpcClients?.inline) {
+        return;
+    }
+    // if no scopes, do them all!
+    if (!builder.options.rpcClients.scoped ||
+        !builder.options.rpcClients.scoped.length ||
+        !builder.options.rpcClients.scopedIsExclusive) {
+        return makeAllRPCBundles(builder, bundler);
+    }
+};
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = join(dir, filename + '.query');
+    return localname + '.ts';
+};
+const makeAllRPCBundles = (builder, bundler) => {
+    if (!builder.options.rpcClients.bundle)
+        return;
+    const dir = bundler.bundle.base;
+    const filename = 'rpc';
+    // refs with services
+    const refs = builder.store.getProtos().filter((ref) => {
+        const proto = getNestedProto(ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter(a => a !== 'Msg');
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        return true;
+    });
+    const check = refs.filter((ref) => {
+        const [base] = ref.proto.package.split('.');
+        return base === bundler.bundle.base;
+    });
+    if (!check.length) {
+        // if there are no services
+        // exit the plugin
+        return;
+    }
+    const packages = refs.reduce((m, ref) => {
+        const [base] = ref.proto.package.split('.');
+        if (base === 'cosmos' || base === bundler.bundle.base)
+            return [...new Set([...m, ref.proto.package])];
+        return m;
+    }, []);
+    const methodName = 'createRPCQueryClient';
+    const localname = getFileName(dir, filename ?? 'rpc');
+    const obj = {};
+    builder.rpcQueryClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        if (!isRefIncluded(createEmptyProtoRef(file.package, file.proto), {
+            packages,
+        })) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = getRelativePath(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new TelescopeParseContext(createEmptyProtoRef(dir, localname), builder.store, builder.options);
+    //based on rpc type to generate client from client factory
+    let rpcast;
+    switch (builder.options?.rpcClients?.type) {
+        case "grpc-gateway":
+            rpcast = createScopedGrpcGatewayFactory(ctx.proto, obj, "createGrpcGateWayClient"
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "tendermint":
+            // TODO add addUtil to generic context
+            ctx.proto.addUtil('Rpc');
+            rpcast = createScopedRpcTmFactory(ctx.proto, obj, methodName
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "grpc-web":
+            rpcast = createScopedGrpcWebFactory(ctx.proto, obj, "createGrpcWebClient");
+            break;
+        default:
+            break;
+    }
+    const serviceImports = getDepsFromQueries(ctx.queries, localname);
+    const imports = aggregateImports(ctx, serviceImports, localname);
+    const importStmts = getImportStatements(localname, [...fixlocalpaths(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(rpcast);
+    const writeFilename = bundler.getFilename(localname);
+    bundler.writeAst(prog, writeFilename);
+    bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+};

package/module/generators/create-rpc-query-client-scoped.js

@@ -0,0 +1,83 @@
+import * as dotty from 'dotty';
+import { isRefIncluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { createScopedRpcTmFactory, createScopedGrpcWebFactory, createScopedGrpcGatewayFactory } from '@cosmology/ast';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { TelescopeParseContext } from '../build';
+import { aggregateImports, getDepsFromQueries, getImportStatements } from '../imports';
+export const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.rpcClients?.enabled) {
+        return;
+    }
+    if (builder.options?.rpcClients?.inline) {
+        return;
+    }
+    // we have scopes!
+    builder.options.rpcClients.scoped?.forEach(rpc => {
+        if (rpc.dir !== bundler.bundle.base)
+            return;
+        makeRPC(builder, bundler, rpc);
+    });
+};
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = join(dir, filename + '.query');
+    return localname + '.ts';
+};
+const makeRPC = (builder, bundler, rpc) => {
+    const dir = rpc.dir;
+    const packages = rpc.packages;
+    const protos = rpc.protos;
+    const methodName = rpc.methodNameQuery ?? 'createRPCQueryClient';
+    const localname = getFileName(dir, rpc.filename ?? 'rpc');
+    const obj = {};
+    builder.rpcQueryClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        if (!isRefIncluded(createEmptyProtoRef(file.package, file.proto), {
+            packages,
+            protos
+        })) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = getRelativePath(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new TelescopeParseContext(createEmptyProtoRef(dir, localname), builder.store, builder.options);
+    //based on rpc type to generate client from client factory
+    let rpcast;
+    switch (builder.options?.rpcClients?.type) {
+        case "grpc-gateway":
+            rpcast = createScopedGrpcGatewayFactory(ctx.proto, obj, "createGrpcGateWayClient"
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "tendermint":
+            // TODO add addUtil to generic context
+            ctx.proto.addUtil('Rpc');
+            rpcast = createScopedRpcTmFactory(ctx.proto, obj, methodName
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "grpc-web":
+            rpcast = createScopedGrpcWebFactory(ctx.proto, obj, "createGrpcWebClient");
+            break;
+        default:
+            break;
+    }
+    const serviceImports = getDepsFromQueries(ctx.queries, localname);
+    const imports = aggregateImports(ctx, serviceImports, localname);
+    const importStmts = getImportStatements(localname, [...fixlocalpaths(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(rpcast);
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    if (rpc.addToBundle) {
+        bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+    }
+};

package/module/generators/create-rpc-query-clients.js

@@ -0,0 +1,198 @@
+import { buildAllImports, getDepsFromQueries } from '../imports';
+import { createRpcQueryExtension, createRpcClientClass, createRpcClientInterface, createRpcQueryHookInterfaces, createRpcQueryHookClientMap, createRpcQueryHooks, 
+// grpc-gateway:
+createGRPCGatewayQueryClass, createGRPCGatewayWrapperClass, 
+//grpc-web:
+createGrpcWebQueryClass, createGrpcWebQueryInterface, createMobxQueryStores, GetDesc, getMethodDesc, grpcWebRpcInterface, getGrpcWebImpl, createRpcClientImpl, } from '@cosmology/ast';
+import { getNestedProto, isRefIncluded } from '@cosmology/proto-parser';
+import { parse } from '../parse';
+import { camel, getQueryMethodNames, swapKeyValue } from '@cosmology/utils';
+export const plugin = (builder, bundler) => {
+    const instantRpcBundlerFiles = {};
+    const reactQueryBundlerFiles = [];
+    const mobxBundlerFiles = [];
+    const clients = bundler.contexts.map(c => {
+        const enabled = c.proto.pluginValue('rpcClients.enabled');
+        if (!enabled)
+            return;
+        const inline = c.proto.pluginValue('rpcClients.inline');
+        if (inline)
+            return;
+        if (c.proto.isExcluded())
+            return;
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        parse(ctx);
+        const proto = getNestedProto(c.ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients?.enabledServices?.filter(a => a !== 'Msg') ?? [];
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        ///
+        let name, getImportsFrom;
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                if (svcKey === 'Query') {
+                    getImportsFrom = ctx.queries;
+                }
+                else {
+                    getImportsFrom = ctx.services;
+                }
+                name = svcKey;
+            }
+        });
+        const localname = bundler.getLocalFilename(c.ref, `rpc.${name}`);
+        const filename = bundler.getFilename(localname);
+        const bundlerFile = {
+            proto: c.ref.filename,
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+        const asts = [];
+        switch (c.proto.pluginValue('rpcClients.type')) {
+            case 'grpc-gateway':
+                allowedRpcServices.forEach(svcKey => {
+                    if (proto[svcKey]) {
+                        const svc = proto[svcKey];
+                        asts.push(createGRPCGatewayQueryClass(ctx.generic, svc));
+                        asts.push(createGRPCGatewayWrapperClass(ctx.generic, svc));
+                    }
+                });
+                break;
+            case 'grpc-web':
+                allowedRpcServices.forEach(svcKey => {
+                    if (proto[svcKey]) {
+                        const svc = proto[svcKey];
+                        asts.push(createGrpcWebQueryInterface(ctx.generic, svc));
+                        asts.push(createGrpcWebQueryClass(ctx.generic, svc));
+                        // add descriptor for grpc-web
+                        asts.push(GetDesc(ctx.generic, proto[svcKey]));
+                        const Desces = getMethodDesc(ctx.generic, proto[svcKey]);
+                        for (let i = 0; i < Desces.length; i++) {
+                            const element = Desces[i];
+                            asts.push(element);
+                        }
+                        asts.push(grpcWebRpcInterface());
+                        asts.push(getGrpcWebImpl(ctx.generic));
+                        /* Added the sameway as Tendermint implement, if modify below then modify this one too */
+                        // see if current file has been reactQuery enabled and included
+                        const includeReactQueryHooks = c.proto.pluginValue('reactQuery.enabled') && isRefIncluded(c.ref, c.proto.pluginValue('reactQuery.include'));
+                        if (includeReactQueryHooks) {
+                            [].push.apply(asts, createRpcQueryHookInterfaces(ctx.generic, svc));
+                            [].push.apply(asts, createRpcQueryHookClientMap(ctx.generic, svc));
+                            asts.push(createRpcQueryHooks(ctx.generic, proto[svcKey]));
+                            // get all query methods
+                            const patterns = c.proto.pluginValue('reactQuery.instantExport.include.patterns');
+                            bundlerFile.instantExportedMethods = getQueryMethodNames(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns).map((key) => proto[svcKey].methods[key]);
+                            reactQueryBundlerFiles.push(bundlerFile);
+                        }
+                        // whether mobx plugin is enabled has been dealt with inside createMobxQueryStores
+                        const mobxQueryStoreAst = createMobxQueryStores(ctx.generic, proto[svcKey]);
+                        if (mobxQueryStoreAst) {
+                            asts.push(mobxQueryStoreAst);
+                            mobxBundlerFiles.push(bundlerFile);
+                        }
+                    }
+                });
+                break;
+            case 'tendermint':
+            default:
+                allowedRpcServices.forEach(svcKey => {
+                    if (proto[svcKey]) {
+                        const svc = proto[svcKey];
+                        asts.push(createRpcClientInterface(ctx.generic, svc));
+                        const instantOps = c.options.rpcClients?.instantOps ?? [];
+                        const useCamelCase = c.options.rpcClients?.camelCase;
+                        instantOps.forEach((item) => {
+                            let nameMapping = {
+                                ...swapKeyValue(item.nameMapping?.All ?? {}),
+                                ...swapKeyValue(item.nameMapping?.Query ?? {})
+                            };
+                            // get all query methods
+                            const patterns = item.include?.patterns;
+                            const serviceTypes = item.include?.serviceTypes;
+                            if (serviceTypes && !serviceTypes.includes("Query")) {
+                                return;
+                            }
+                            const methodKeys = getQueryMethodNames(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns, useCamelCase ? camel : String);
+                            if (!methodKeys || !methodKeys.length) {
+                                return;
+                            }
+                            asts.push(createRpcClientInterface(ctx.generic, svc, item.className, methodKeys, nameMapping));
+                            bundlerFile.instantExportedMethods = methodKeys.map((key) => proto[svcKey].methods[key]);
+                            if (!instantRpcBundlerFiles[item.className]) {
+                                instantRpcBundlerFiles[item.className] = [];
+                            }
+                            instantRpcBundlerFiles[item.className].push({ ...bundlerFile });
+                        });
+                        asts.push(createRpcClientClass(ctx.generic, svc));
+                        if (c.proto.pluginValue('rpcClients.extensions')) {
+                            asts.push(createRpcQueryExtension(ctx.generic, svc));
+                        }
+                        else {
+                            const env = c.proto.pluginValue('env');
+                            if (env === 'v-next') {
+                                asts.push(createRpcClientImpl(ctx.generic, svc));
+                            }
+                        }
+                        // see if current file has been reactQuery enabled and included
+                        const includeReactQueryHooks = c.proto.pluginValue('reactQuery.enabled') && isRefIncluded(c.ref, c.proto.pluginValue('reactQuery.include'));
+                        const includeMobxHooks = c.proto.pluginValue('mobx.enabled') && isRefIncluded(c.ref, c.proto.pluginValue('mobx.include'));
+                        if (includeReactQueryHooks) {
+                            [].push.apply(asts, createRpcQueryHookInterfaces(ctx.generic, svc));
+                        }
+                        // enable getQueryService for plugins using it.
+                        if (includeReactQueryHooks || includeMobxHooks) {
+                            [].push.apply(asts, createRpcQueryHookClientMap(ctx.generic, svc));
+                        }
+                        // react query
+                        // generate react query parts if included.
+                        // eg: __fixtures__/output1/akash/audit/v1beta2/query.rpc.Query.ts
+                        // export interface UseAuditorAttributesQuery<TData> ...
+                        // const _queryClients: WeakMap ...
+                        // const getQueryService = ...
+                        // export const createRpcQueryHooks = ...
+                        // TODO use the imports and make separate files
+                        if (includeReactQueryHooks) {
+                            asts.push(createRpcQueryHooks(ctx.generic, proto[svcKey]));
+                            // get all query methods
+                            const patterns = c.proto.pluginValue('reactQuery.instantExport.include.patterns');
+                            bundlerFile.instantExportedMethods = getQueryMethodNames(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns).map((key) => proto[svcKey].methods[key]);
+                            reactQueryBundlerFiles.push(bundlerFile);
+                        }
+                        // whether mobx plugin is enabled has been dealt with inside createMobxQueryStores
+                        const mobxQueryStoreAst = createMobxQueryStores(ctx.generic, proto[svcKey]);
+                        if (mobxQueryStoreAst) {
+                            asts.push(mobxQueryStoreAst);
+                            mobxBundlerFiles.push(bundlerFile);
+                        }
+                    }
+                });
+        }
+        if (!asts.length) {
+            return;
+        }
+        const serviceImports = getDepsFromQueries(getImportsFrom, localname);
+        // TODO we do NOT need all imports...
+        const imports = buildAllImports(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body)
+            .concat(asts);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return bundlerFile;
+    }).filter(Boolean);
+    bundler.addRPCQueryClients(clients);
+    Object.keys(instantRpcBundlerFiles).forEach((className) => {
+        bundler.addStateManagers(`instantRpc_${className}`, instantRpcBundlerFiles[className]);
+    });
+    bundler.addStateManagers("reactQuery", reactQueryBundlerFiles);
+    bundler.addStateManagers("mobx", mobxBundlerFiles);
+};

package/module/generators/create-sdk-module-stargate-clients.js

@@ -0,0 +1,91 @@
+import { join, dirname, relative } from 'path';
+import { importNamespace, GenericParseContext, createStargateClient, createStargateClientOptions, createStargateClientProtoRegistry, createStargateClientAminoRegistry, createGetTxRpc } from '@cosmology/ast';
+import { camel, pascal } from 'case';
+import { duplicateImportPathsWithExt, variableSlug, toPosixPath } from '@cosmology/utils';
+import { buildAllImportsFromGenericContext } from '../imports';
+export const plugin = (builder, bundler) => {
+    if (!bundler.registries || !bundler.registries.length) {
+        return;
+    }
+    const registryImports = [];
+    const converterImports = [];
+    const clientFile = bundler.bundle.base.concat('-sdk-module-client.ts');
+    bundler.files.push(clientFile);
+    const ctxRef = {
+        absolute: '/',
+        filename: '/',
+        proto: {
+            imports: [],
+            package: bundler.bundle.base,
+            root: {},
+        }
+    };
+    const ctx = new GenericParseContext(ctxRef, null, builder.options);
+    const registryVariables = [];
+    const converterVariables = [];
+    bundler.registries.forEach(registry => {
+        let rel = relative(dirname(clientFile), registry.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = toPosixPath(rel);
+        const variable = variableSlug(registry.localname);
+        registryVariables.push(variable);
+        registryImports.push(importNamespace(variable, rel));
+    });
+    bundler.converters.forEach(converter => {
+        let rel = relative(dirname(clientFile), converter.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = toPosixPath(rel);
+        const variable = variableSlug(converter.localname);
+        converterVariables.push(variable);
+        converterImports.push(importNamespace(variable, rel));
+    });
+    const name = 'getSigning' + pascal(bundler.bundle.base + 'Client');
+    const txRpcName = 'getSigning' + pascal(bundler.bundle.base + 'TxRpc');
+    const prefix = camel(bundler.bundle.base);
+    const aminos = createStargateClientAminoRegistry({
+        context: ctx,
+        aminos: converterVariables,
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const protos = createStargateClientProtoRegistry({
+        context: ctx,
+        registries: registryVariables,
+        protoTypeRegistry: prefix + 'ProtoRegistry'
+    });
+    const clientOptions = createStargateClientOptions({
+        context: ctx,
+        name: name + 'Options',
+        protoTypeRegistry: prefix + 'ProtoRegistry',
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const clientBody = createStargateClient({
+        context: ctx,
+        name,
+        options: name + 'Options',
+    });
+    let getTxRpc;
+    if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+        getTxRpc = createGetTxRpc(ctx, txRpcName, name);
+    }
+    const imports = buildAllImportsFromGenericContext(ctx, clientFile);
+    let importDecls = [...imports, ...registryImports, ...converterImports];
+    importDecls = duplicateImportPathsWithExt(importDecls, builder.options.restoreImportExtension);
+    let cProg = importDecls
+        .concat(aminos)
+        .concat(protos)
+        .concat(clientOptions)
+        .concat(clientBody);
+    // replace all backslash path for windows
+    for (let i = 0; i < cProg.length; i++) {
+        if (cProg[i].source?.value) {
+            cProg[i].source.value = toPosixPath(cProg[i].source?.value);
+        }
+    }
+    if (getTxRpc) {
+        cProg = cProg.concat(getTxRpc);
+    }
+    const clientOutFile = join(builder.outPath, clientFile);
+    bundler.writeAst(cProg, clientOutFile);
+};

package/module/generators/create-stargate-clients.js

@@ -0,0 +1,92 @@
+import { join, dirname, relative } from 'path';
+import { importNamespace, GenericParseContext, createStargateClient, createStargateClientOptions, createStargateClientProtoRegistry, createStargateClientAminoRegistry, createGetTxRpc } from '@cosmology/ast';
+import { camel, pascal } from 'case';
+import { duplicateImportPathsWithExt, variableSlug, toPosixPath } from '@cosmology/utils';
+import { buildAllImportsFromGenericContext } from '../imports';
+export const plugin = (builder, bundler) => {
+    const ctxRef = {
+        absolute: '/',
+        filename: '/',
+        proto: {
+            imports: [],
+            package: bundler.bundle.base,
+            root: {},
+        }
+    };
+    const ctx = new GenericParseContext(ctxRef, null, builder.options);
+    const stargateClientsEnabled = ctx.pluginValue("stargateClients.enabled");
+    if (!stargateClientsEnabled || !bundler.registries || !bundler.registries.length) {
+        return;
+    }
+    const registryImports = [];
+    const converterImports = [];
+    const clientFile = join(`${bundler.bundle.base}`, 'client.ts');
+    bundler.files.push(clientFile);
+    const registryVariables = [];
+    const converterVariables = [];
+    bundler.registries.forEach(registry => {
+        let rel = relative(dirname(clientFile), registry.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = toPosixPath(rel);
+        const variable = variableSlug(registry.localname);
+        registryVariables.push(variable);
+        registryImports.push(importNamespace(variable, rel));
+    });
+    bundler.converters.forEach(converter => {
+        let rel = relative(dirname(clientFile), converter.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = toPosixPath(rel);
+        const variable = variableSlug(converter.localname);
+        converterVariables.push(variable);
+        converterImports.push(importNamespace(variable, rel));
+    });
+    const name = 'getSigning' + pascal(bundler.bundle.base + 'Client');
+    const txRpcName = 'getSigning' + pascal(bundler.bundle.base + 'TxRpc');
+    const prefix = camel(bundler.bundle.base);
+    const aminos = createStargateClientAminoRegistry({
+        context: ctx,
+        aminos: converterVariables,
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const protos = createStargateClientProtoRegistry({
+        context: ctx,
+        registries: registryVariables,
+        protoTypeRegistry: prefix + 'ProtoRegistry'
+    });
+    const clientOptions = createStargateClientOptions({
+        context: ctx,
+        name: name + 'Options',
+        protoTypeRegistry: prefix + 'ProtoRegistry',
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const clientBody = createStargateClient({
+        context: ctx,
+        name,
+        options: name + 'Options',
+    });
+    let getTxRpc;
+    if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+        getTxRpc = createGetTxRpc(ctx, txRpcName, name);
+    }
+    const imports = buildAllImportsFromGenericContext(ctx, clientFile);
+    let importDecls = [...imports, ...registryImports, ...converterImports];
+    importDecls = duplicateImportPathsWithExt(importDecls, builder.options.restoreImportExtension);
+    let cProg = importDecls
+        .concat(aminos)
+        .concat(protos)
+        .concat(clientOptions)
+        .concat(clientBody);
+    // replace all backslash path for windows
+    for (let i = 0; i < cProg.length; i++) {
+        if (cProg[i].source?.value) {
+            cProg[i].source.value = toPosixPath(cProg[i].source?.value);
+        }
+    }
+    if (getTxRpc) {
+        cProg = cProg.concat(getTxRpc);
+    }
+    const clientOutFile = join(builder.outPath, clientFile);
+    bundler.writeAst(cProg, clientOutFile);
+};