@cosmwasm/ts-codegen 0.35.7 → 1.0.0

package/{src/builder/builder.ts → esm/builder/builder.js}

@@ -1,18 +1,13 @@
-import { RenderOptions, defaultOptions, RenderContext, ContractInfo, MessageComposerOptions, BuilderContext } from "wasm-ast-types";
-
+import { defaultOptions, BuilderContext } from "wasm-ast-types";
 import { header } from '../utils/header';
 import { join } from "path";
 import { writeFileSync } from 'fs';
 import { sync as mkdirp } from "mkdirp";
-
 import { basename } from 'path';
 import { readSchemas } from '../utils';
-import { IBuilderPlugin } from '../plugins';
-
 import deepmerge from 'deepmerge';
 import { pascal } from "case";
 import { createFileBundle, recursiveModuleBundle } from "../bundler";
-
 import generate from '@babel/generator';
 import * as t from '@babel/types';
 import { ReactQueryPlugin } from "../plugins/react-query";
@@ -24,219 +19,124 @@ import { TypesPlugin } from "../plugins/types";
 import { ContractsContextProviderPlugin } from "../plugins/provider";
 import { createHelpers } from "../generators/create-helpers";
 import { ContractsProviderBundlePlugin } from "../plugins/provider-bundle";
-
-const defaultOpts: TSBuilderOptions = {
+const defaultOpts = {
     bundle: {
         enabled: true,
         scope: 'contracts',
         bundleFile: 'bundle.ts'
     },
     useShorthandCtor: true
-}
-
-export interface TSBuilderInput {
-    contracts: Array<ContractFile | string>;
-    outPath: string;
-    options?: TSBuilderOptions;
-    plugins?: IBuilderPlugin[];
-};
-
-export interface BundleOptions {
-    enabled?: boolean;
-    scope?: string;
-    bundleFile?: string;
-    bundlePath?: string;
-};
-
-export interface UseContractsOptions {
-    enabled?: boolean;
 };
-
-export type TSBuilderOptions = {
-    bundle?: BundleOptions;
-    /**
-     * Enable using shorthand constructor.
-     * Default: true
-     */
-    useShorthandCtor?: boolean;
-    useContractsHooks?: UseContractsOptions;
-} & RenderOptions;
-
-export type BuilderFileType = 'type' | 'client' | 'recoil' | 'react-query' | 'message-composer' | 'message-builder' | 'plugin';
-
-export interface BuilderFile {
-    type: BuilderFileType;
-    pluginType?: string;
-    contract: string;
-    //filename only: Factory.client.ts
-    localname: string;
-    //full path: contracts/Factory.client.ts
-    filename: string;
-};
-
-export interface ContractFile {
-    name: string;
-    dir: string;
-}
-
-function getContract(contractOpt): ContractFile {
+;
+;
+;
+;
+function getContract(contractOpt) {
     if (typeof contractOpt === 'string') {
         const name = basename(contractOpt);
         const contractName = pascal(name);
         return {
             name: contractName,
             dir: contractOpt
-        }
+        };
     }
     return {
         name: pascal(contractOpt.name),
         dir: contractOpt.dir
     };
 }
-
 export class TSBuilder {
-    contracts: Array<ContractFile | string>;
-    outPath: string;
-    options?: TSBuilderOptions;
-    plugins: IBuilderPlugin[] = [];
-    builderContext: BuilderContext = new BuilderContext();
-
-    protected files: BuilderFile[] = [];
-
+    contracts;
+    outPath;
+    options;
+    plugins = [];
+    builderContext = new BuilderContext();
+    files = [];
     loadDefaultPlugins() {
-        [].push.apply(this.plugins, [
-            new TypesPlugin(this.options),
-            new ClientPlugin(this.options),
-            new MessageComposerPlugin(this.options),
-            new ReactQueryPlugin(this.options),
-            new RecoilPlugin(this.options),
-            new MessageBuilderPlugin(this.options),
-            new ContractsContextProviderPlugin(this.options),
-        ]);
+        this.plugins.push(new TypesPlugin(this.options), new ClientPlugin(this.options), new MessageComposerPlugin(this.options), new ReactQueryPlugin(this.options), new RecoilPlugin(this.options), new MessageBuilderPlugin(this.options), new ContractsContextProviderPlugin(this.options));
     }
-
-    constructor({ contracts, outPath, options, plugins }: TSBuilderInput) {
+    constructor({ contracts, outPath, options, plugins }) {
         this.contracts = contracts;
         this.outPath = outPath;
-        this.options = deepmerge(
-            deepmerge(
-                defaultOptions,
-                defaultOpts
-            ),
-            options ?? {}
-        );
-
+        this.options = deepmerge(deepmerge(defaultOptions, defaultOpts), options ?? {});
         this.loadDefaultPlugins();
-
         if (plugins && plugins.length) {
-            [].push.apply(this.plugins, plugins);
+            this.plugins.push(...plugins);
         }
-
-        this.plugins.forEach(plugin => plugin.setBuilder(this))
+        this.plugins.forEach(plugin => plugin.setBuilder(this));
     }
-
     async build() {
         await this.process();
         await this.after();
     }
-
     // lifecycle functions
-    private async process() {
+    async process() {
         for (const contractOpt of this.contracts) {
             const contract = getContract(contractOpt);
             //resolve contract schema.
             const contractInfo = await readSchemas({
                 schemaDir: contract.dir
             });
-
             //lifecycle and plugins.
             await this.render(contract.name, contractInfo);
         }
     }
-
-    private async render(name: string, contractInfo: ContractInfo) {
+    async render(name, contractInfo) {
         for (const plugin of this.plugins) {
             let files = await plugin.render(name, contractInfo, this.outPath);
             if (files && files.length) {
-                [].push.apply(this.files, files);
+                this.files.push(...files);
             }
         }
     }
-
-    private async after() {
-
+    async after() {
         //create useContracts bundle file
         const contractsProviderBundlePlugin = new ContractsProviderBundlePlugin(this.options);
         contractsProviderBundlePlugin.setBuilder(this);
-
         //contractContextProviders.ts
-        const files = await contractsProviderBundlePlugin.render(
-            "contractContextProviders",
-            {
-                schemas: [],
-            },
-            this.outPath
-        );
-
+        const files = await contractsProviderBundlePlugin.render("contractContextProviders", {
+            schemas: [],
+        }, this.outPath);
         if (files && files.length) {
-            [].push.apply(this.files, files);
+            this.files.push(...files);
         }
-
         const helpers = createHelpers({
             outPath: this.outPath,
             contracts: this.contracts,
             options: this.options,
             plugins: this.plugins,
         }, this.builderContext);
-
         if (helpers && helpers.length) {
-            [].push.apply(this.files, helpers);
+            this.files.push(...helpers);
         }
-
         if (this.options.bundle.enabled) {
             this.bundle();
         }
     }
-
     async bundle() {
         const allFiles = this.files;
-
         const bundleFile = this.options.bundle.bundleFile;
-        const bundlePath = join(
-            this.options?.bundle?.bundlePath ?? this.outPath,
-            bundleFile
-        );
+        const bundlePath = join(this.options?.bundle?.bundlePath ?? this.outPath, bundleFile);
         const bundleVariables = {};
         const importPaths = [];
-
         allFiles.forEach(file => {
-            createFileBundle(
-                `${this.options.bundle.scope}.${file.contract}`,
-                file.filename,
-                bundlePath,
-                importPaths,
-                bundleVariables
-            );
-
+            createFileBundle(`${this.options.bundle.scope}.${file.contract}`, file.filename, bundlePath, importPaths, bundleVariables);
         });
-
         const ast = recursiveModuleBundle(bundleVariables);
+        const nodes = [
+            ...importPaths,
+            ...ast
+        ];
+        // @ts-ignore
         let code = generate(t.program(
-            [
-                ...importPaths,
-                ...ast
-            ]
-        )).code;
-
+        // @ts-ignore
+        nodes)).code;
         if (this.options?.bundle?.bundlePath) {
             mkdirp(this.options?.bundle?.bundlePath);
         }
-
         mkdirp(this.outPath);
-
-        if (code.trim() === '') code = 'export {};'
-
+        if (code.trim() === '')
+            code = 'export {};';
         writeFileSync(bundlePath, header + code);
-
     }
 }

package/esm/builder/index.js

@@ -0,0 +1 @@
+export * from './builder';

package/esm/bundler/bundler.js

@@ -0,0 +1,47 @@
+import * as t from '@babel/types';
+import nested from 'nested-obj';
+import { relative, dirname, extname } from 'path';
+export const recursiveModuleBundle = (obj) => {
+    return Object.keys(obj).map(key => {
+        const value = obj[key];
+        if (typeof value === 'object' && value && value.__export) {
+            // e.g. abci
+            // 1. create variable for abci
+            // 2. splat ALL _0, parms into abci
+            // 3. export that variable
+            const nmspc = t.variableDeclaration('const', [t.variableDeclarator(t.identifier(key), t.objectExpression(Object.keys(obj[key])
+                    .filter(a => a !== '__export')
+                    .filter(a => a.startsWith('_'))
+                    .map(a => t.spreadElement(t.identifier(a)))))]);
+            const others = Object.keys(obj[key])
+                .filter(a => a !== '__export')
+                .filter(a => !a.startsWith('_'));
+            if (others.length) {
+                throw new Error('namespace and package not supported, yet.');
+            }
+            // return nmspc;
+            return t.exportNamedDeclaration(nmspc, []);
+        }
+        else if (typeof value === 'object' && value) {
+            // you can make a namespace for obj[key]
+            // e.g. libs
+            return t.exportNamedDeclaration(t.tsModuleDeclaration(t.identifier(key), t.tsModuleBlock(recursiveModuleBundle(obj[key]))));
+        }
+        else {
+            throw new Error('Invalid structure for BundleData');
+        }
+    });
+};
+export const importNamespace = (ident, path) => t.importDeclaration([
+    t.importNamespaceSpecifier(t.identifier(ident))
+], t.stringLiteral(path.replace(extname(path), '')));
+let counter = 0;
+export const createFileBundle = (pkg, filename, bundleFile, importPaths, bundleVariables) => {
+    let rel = relative(dirname(bundleFile), filename);
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    const variable = `_${counter++}`;
+    importPaths.push(importNamespace(variable, rel));
+    nested.set(bundleVariables, pkg + '.__export', true);
+    nested.set(bundleVariables, pkg + '.' + variable, true);
+};

package/esm/bundler/index.js

@@ -0,0 +1 @@
+export * from './bundler';

package/esm/cli.js

@@ -0,0 +1,20 @@
+import { prompt } from './utils/prompt';
+import { Commands as commands } from './cmds';
+const question = [
+    {
+        _: true,
+        type: 'fuzzy',
+        name: 'cmd',
+        message: 'what do you want to do?',
+        choices: Object.keys(commands)
+    }
+];
+export const cli = async (argv) => {
+    var { cmd } = await prompt(question, argv);
+    if (typeof commands[cmd] === 'function') {
+        await commands[cmd](argv);
+    }
+    else {
+        console.log('command not found.');
+    }
+};

package/{src → esm}/cmds.js

@@ -5,5 +5,4 @@ const Commands = {};
 Commands['create-boilerplate'] = _create_boilerplate;
 Commands['generate'] = _generate;
 Commands['install'] = _install;
-
 export { Commands };

package/{src/commands/create-boilerplate.ts → esm/commands/create-boilerplate.js}

@@ -4,14 +4,12 @@ import dargs from 'dargs';
 const glob = require('glob').sync;
 const fs = require('fs');
 const path = require('path');
-
 const repo = 'https://github.com/cosmology-tech/ts-codegen-module-boilerplate';
-export default async argv => {
+export default async (argv) => {
     if (!shell.which('git')) {
         shell.echo('Sorry, this script requires git');
         return shell.exit(1);
     }
-
     const { name } = await prompt([
         {
             type: 'string',
@@ -19,115 +17,82 @@ export default async argv => {
             message: 'Enter your new module name',
         }
     ], argv);
-
     shell.exec(`git clone ${repo} ${name}`);
     shell.cd(name);
-
     const questions = JSON.parse(fs.readFileSync(`.questions.json`));
-
     const fullname = shell
         .exec('git config --global user.name', { silent: true })
         .trim();
     const email = shell
         .exec('git config --global user.email', { silent: true })
         .trim();
-
     // @__USERNAME__/__MODULENAME__
     // __PACKAGE_IDENTIFIER__
-    const args = dargs(
-        {
-            _: [],
-            ...argv,
-            __MODULENAME__: name,
-            __USERFULLNAME__: fullname,
-            __USEREMAIL__: email,
-        },
-        { allowCamelCase: true }
-    );
-
+    const args = dargs({
+        _: [],
+        ...argv,
+        __MODULENAME__: name,
+        __USERFULLNAME__: fullname,
+        __USEREMAIL__: email,
+    }, { allowCamelCase: true });
     const results = await prompt(questions, args);
     let scopedResults;
-
-    const license = await prompt(
-        [
+    const license = await prompt([
+        {
+            name: '__LICENSE__',
+            message: 'Which license?',
+            choices: ['MIT', 'closed'],
+            type: 'list',
+            required: true,
+        },
+    ], []);
+    if (results.__ACCESS__ === 'public') {
+        scopedResults = await prompt([
             {
-                name: '__LICENSE__',
-                message: 'Which license?',
-                choices: ['MIT', 'closed'],
-                type: 'list',
+                type: 'confirm',
+                name: 'scoped',
+                message: 'use npm scopes?',
                 required: true,
             },
-        ],
-        []
-    );
-
-    if (results.__ACCESS__ === 'public') {
-        scopedResults = await prompt(
-            [
-                {
-                    type: 'confirm',
-                    name: 'scoped',
-                    message: 'use npm scopes?',
-                    required: true,
-                },
-            ],
-            []
-        );
+        ], []);
     }
-
     const files = []
         .concat(glob(process.cwd() + '/**/.*'))
         .concat(glob(process.cwd() + '/**/*'));
-
     for (let i = 0; i < files.length; i++) {
         const templateFile = files[i];
-        if (fs.lstatSync(templateFile).isDirectory()) continue;
-
+        if (fs.lstatSync(templateFile).isDirectory())
+            continue;
         let content = fs.readFileSync(templateFile).toString();
-        if (
-            path.basename(templateFile) === 'LICENSE' &&
-            license.__LICENSE__ === 'closed'
-        ) {
+        if (path.basename(templateFile) === 'LICENSE' &&
+            license.__LICENSE__ === 'closed') {
             content = `Copyright (c) 2023 __USERFULLNAME__ <__USEREMAIL__> - All Rights Reserved
 Unauthorized copying via any medium is strictly prohibited
 Proprietary and confidential`;
         }
-
         Object.keys(results).forEach(key => {
             if (/^__/.test(key)) {
                 content = content.replace(new RegExp(key, 'g'), results[key]);
             }
         });
-
         if (results.__ACCESS__ === 'public') {
             if (scopedResults.scoped) {
-                content = content.replace(
-                    /__PACKAGE_IDENTIFIER__/g,
-                    `@${results.__USERNAME__}/${results.__MODULENAME__}`
-                );
-            } else {
-                content = content.replace(
-                    /__PACKAGE_IDENTIFIER__/g,
-                    `${results.__MODULENAME__}`
-                );
+                content = content.replace(/__PACKAGE_IDENTIFIER__/g, `@${results.__USERNAME__}/${results.__MODULENAME__}`);
+            }
+            else {
+                content = content.replace(/__PACKAGE_IDENTIFIER__/g, `${results.__MODULENAME__}`);
             }
-        } else {
-            content = content.replace(
-                /__PACKAGE_IDENTIFIER__/g,
-                `@${results.__USERNAME__}/${results.__MODULENAME__}`
-            );
         }
-
+        else {
+            content = content.replace(/__PACKAGE_IDENTIFIER__/g, `@${results.__USERNAME__}/${results.__MODULENAME__}`);
+        }
         // if (path.basename(templateFile) === 'README.md') {
         //     content = `# ${results.__MODULENAME__}`;
         // }
-
         fs.writeFileSync(templateFile, content);
     }
-
     shell.rm('-rf', '.git');
     shell.rm('-rf', '.questions.json');
-
     console.log(`
 
        |||
@@ -136,4 +101,4 @@ Proprietary and confidential`;
 
   ✨ Great work!
   `);
-};
+};

package/{src/commands/generate.ts → esm/commands/generate.js}

@@ -1,7 +1,6 @@
+// @ts-nocheck
 import { prompt } from '../utils/prompt';
 import codegen from '../index';
-import { TSBuilderOptions } from '../builder';
-
 export default async (argv) => {
     const questions = [
         {
@@ -42,17 +41,16 @@ export default async (argv) => {
             default: true
         }
     ];
-
     if (argv.typesOnly) {
         argv.plugin = 'types';
     }
-
     let { schema, out, name, plugin, bundle } = await prompt(questions, argv);
-    if (!Array.isArray(plugin)) plugin = [plugin];
-
+    if (!Array.isArray(plugin))
+        plugin = [plugin];
     ///////// REACT QUERY
     const questions2 = [];
     if (plugin.includes('react-query')) {
+        // @ts-ignore
         [].push.apply(questions2, [
             {
                 type: 'confirm',
@@ -73,8 +71,9 @@ export default async (argv) => {
                 message: 'queryKeys?',
                 default: false
             },
-        ])
-    };
+        ]);
+    }
+    ;
     const { optionalClient, version, queryKeys } = await prompt(questions2, argv);
     const questions3 = [];
     if (version === 'v4') {
@@ -86,11 +85,10 @@ export default async (argv) => {
                 message: 'Generate useMutation hooks?',
                 default: false
             }
-
-        ])
-    };
+        ]);
+    }
+    ;
     const { mutations } = await prompt(questions3, argv);
-
     const queryFactoryQuestions = [];
     if (queryKeys) {
         [].push.apply(queryFactoryQuestions, [
@@ -101,11 +99,11 @@ export default async (argv) => {
                 message: 'queryFactory? ',
                 default: false
             }
-        ])
-    };
+        ]);
+    }
+    ;
     const { queryFactory } = await prompt(queryFactoryQuestions, argv);
     ///////// END REACT QUERY
-
     ///////// BUNDLE
     const questions4 = [];
     if (bundle) {
@@ -122,18 +120,17 @@ export default async (argv) => {
                 message: 'bundleScope?',
                 default: 'contracts'
             }
-        ])
-    };
+        ]);
+    }
+    ;
     const { bundleFile, bundleScope } = await prompt(questions4, argv);
     ///////// END BUNDLE
-
-    const options: TSBuilderOptions = {
+    const options = {
         types: {
             enabled: true
         },
         client: {
-            enabled:
-                plugin.includes('client') ||
+            enabled: plugin.includes('client') ||
                 plugin.includes('recoil') ||
                 plugin.includes('react-query')
         },
@@ -152,7 +149,6 @@ export default async (argv) => {
             enabled: plugin.includes('message-composer')
         },
         messageBuilder: {
-
             enabled: plugin.includes('message-builder')
         },
         bundle: {
@@ -161,7 +157,6 @@ export default async (argv) => {
             bundleFile
         }
     };
-
     await codegen({
         contracts: [
             {
@@ -171,5 +166,5 @@ export default async (argv) => {
         ],
         outPath: out,
         options
-    })
+    });
 };