@cosmwasm/ts-codegen 0.35.7 → 1.1.0

package/commands/install.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const glob_1 = require("glob");
+const rimraf_1 = require("rimraf");
+const shelljs_1 = require("shelljs");
+const prompt_1 = require("../utils/prompt");
+const parse_package_name_1 = require("parse-package-name");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const TMPDIR = (0, os_1.tmpdir)();
+const rnd = () => Math.random().toString(36).substring(2, 15) +
+    Math.random().toString(36).substring(2, 15);
+const getPackages = (names) => {
+    return names.map(pkg => {
+        const { name, version } = (0, parse_package_name_1.parse)(pkg);
+        return `${name}@${version}`;
+    }).join(' ');
+};
+exports.default = async (argv) => {
+    // don't prompt if we got this...
+    if (argv._.length) {
+        argv.pkg = argv._;
+    }
+    // current dir/package
+    const cur = process.cwd();
+    let thisPackage;
+    try {
+        thisPackage = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(cur, 'package.json'), 'utf-8'));
+    }
+    catch (e) {
+        throw new Error('make sure you are inside of a telescope package!');
+    }
+    // what are we installing?
+    let { pkg } = await (0, prompt_1.prompt)([
+        {
+            type: 'checkbox',
+            name: 'pkg',
+            message: 'which chain contracts do you want to support?',
+            choices: [
+                'stargaze-base-factory',
+                'stargaze-base-minter',
+                'stargaze-sg721-base',
+                'stargaze-sg721-metdata-onchain',
+                'stargaze-sg721-nt',
+                'stargaze-splits',
+                'stargaze-vending-factory',
+                'stargaze-vending-minter',
+                'stargaze-whitelist',
+                'wasmswap'
+            ].map(name => {
+                return {
+                    name,
+                    value: `@cosmjson/${name}`
+                };
+            })
+        }
+    ], argv);
+    // install
+    if (!Array.isArray(pkg))
+        pkg = [pkg];
+    const tmp = (0, path_1.join)(TMPDIR, rnd());
+    (0, mkdirp_1.sync)(tmp);
+    process.chdir(tmp);
+    (0, shelljs_1.exec)(`npm install ${getPackages(pkg)} --production --prefix ./smart-contracts`);
+    // protos
+    const pkgs = (0, glob_1.sync)('./smart-contracts/**/package.json');
+    const cmds = pkgs
+        .filter((f) => { return f !== './smart-contracts/package.json'; })
+        .map((f) => (0, path_1.resolve)((0, path_1.join)(tmp, f)))
+        .map((conf) => {
+        const extDir = (0, path_1.dirname)(conf);
+        const dir = extDir.split('node_modules/')[1];
+        const dst = (0, path_1.basename)(dir);
+        const files = (0, glob_1.sync)(`${extDir}/**/*`, { nodir: true });
+        files.forEach(f => {
+            if ((0, path_1.extname)(f) === '.json'
+                || f === 'package.json'
+                || /license/i.test(f)
+                || /readme/i.test(f))
+                return;
+            (0, rimraf_1.sync)(f);
+        });
+        return [extDir, (0, path_1.resolve)((0, path_1.join)(cur, 'contracts', dst)), dir];
+    });
+    // move protos 
+    for (const [src, dst, pkg] of cmds) {
+        (0, rimraf_1.sync)(dst);
+        console.log(`installing ${pkg}...`);
+        (0, mkdirp_1.sync)((0, path_1.dirname)(dst));
+        (0, shelljs_1.exec)(`mv ${src} ${dst}`);
+    }
+    // package
+    const packageInfo = JSON.parse((0, fs_1.readFileSync)('./smart-contracts/package.json', 'utf-8'));
+    const deps = packageInfo.dependencies ?? {};
+    thisPackage.devDependencies = thisPackage.devDependencies ?? {};
+    thisPackage.devDependencies = {
+        ...thisPackage.devDependencies,
+        ...deps
+    };
+    thisPackage.devDependencies = Object.fromEntries(Object.entries(thisPackage.devDependencies).sort());
+    (0, fs_1.writeFileSync)((0, path_1.join)(cur, 'package.json'), JSON.stringify(thisPackage, null, 2));
+    // cleanup
+    (0, rimraf_1.sync)(tmp);
+    process.chdir(cur);
+};

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!
   `);
-};
+};