@cosmwasm/ts-codegen 0.16.5 → 0.18.0

package/src/commands/install.ts

@@ -0,0 +1,118 @@
+import { resolve, join, dirname, basename, extname } from 'path';
+import { sync as mkdirp } from 'mkdirp';
+import { sync as glob } from 'glob';
+import { sync as rimraf } from 'rimraf';
+import { exec } from 'shelljs';
+import { prompt } from '../utils/prompt';
+import { parse } from 'parse-package-name';
+import { tmpdir } from 'os';
+import { readFileSync, writeFileSync } from 'fs';
+
+const TMPDIR = 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 } = parse(pkg);
+        return `${name}@${version}`
+    }).join(' ');
+};
+
+export 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(readFileSync(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 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 = join(TMPDIR, rnd());
+    mkdirp(tmp);
+    process.chdir(tmp);
+    exec(`npm install ${getPackages(pkg)} --production --prefix ./smart-contracts`);
+
+    // protos
+    const pkgs = glob('./smart-contracts/**/package.json');
+    const cmds = pkgs
+        .filter((f) => { return f !== './smart-contracts/package.json' })
+        .map((f) => resolve(join(tmp, f)))
+        .map((conf) => {
+            const extDir = dirname(conf);
+            const dir = extDir.split('node_modules/')[1];
+            const dst = basename(dir);
+
+            const files = glob(`${extDir}/**/*`, { nodir: true });
+            files.forEach(f => {
+                if (extname(f) === '.json'
+                    || f === 'package.json'
+                    || /license/i.test(f)
+                    || /readme/i.test(f)) return;
+                rimraf(f);
+            });
+            return [extDir, resolve(join(cur, 'contracts', dst)), dir];
+        });
+
+    // move protos 
+    for (const [src, dst, pkg] of cmds) {
+        rimraf(dst);
+        console.log(`installing ${pkg}...`);
+        mkdirp(dirname(dst));
+        exec(`mv ${src} ${dst}`);
+    }
+
+    // package
+    const packageInfo = JSON.parse(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());
+
+    writeFileSync(join(cur, 'package.json'), JSON.stringify(thisPackage, null, 2));
+
+    // cleanup
+    rimraf(tmp);
+    process.chdir(cur);
+};

package/src/file.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { prompt } from './utils/prompt';
+import { cli } from './cli';
+import { readFileSync } from 'fs';
+const argv = require('minimist')(process.argv.slice(2));
+
+const question = [
+  {
+    _: true,
+    type: 'string',
+    name: 'file',
+    message: 'file'
+  }
+];
+
+(async () => {
+  const { file } = await prompt(question, argv);
+  const argvv = JSON.parse(readFileSync(file, 'utf-8'));
+  await cli(argvv);
+})();

package/src/generators/client.ts

@@ -0,0 +1,108 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { ContractInfo, getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { RenderContext, TSClientOptions } from "wasm-ast-types";
+import { BuilderFile } from "../builder";
+
+export default async (
+  name: string,
+  contractInfo: ContractInfo,
+  outPath: string,
+  tsClientOptions?: TSClientOptions
+): Promise<BuilderFile[]> => {
+
+  const { schemas } = contractInfo;
+  const context = new RenderContext(contractInfo, {
+    client: tsClientOptions ?? {}
+  });
+  // const options = context.options.client;
+
+  const localname = pascal(name) + '.client.ts';
+  const TypesFile = pascal(name) + '.types'
+  const QueryMsg = findQueryMsg(schemas);
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+
+  let Client = null;
+  let Instance = null;
+  let QueryClient = null;
+  let ReadOnlyInstance = null;
+
+  const body = [];
+
+  body.push(
+    w.importStmt(Object.keys(typeHash), `./${TypesFile}`)
+  );
+
+  // query messages
+  if (QueryMsg) {
+
+    QueryClient = pascal(`${name}QueryClient`);
+    ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+
+    body.push(
+      w.createQueryInterface(context, ReadOnlyInstance, QueryMsg)
+    );
+    body.push(
+      w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg)
+    );
+  }
+
+  // execute messages
+  if (ExecuteMsg) {
+    const children = getMessageProperties(ExecuteMsg);
+    if (children.length > 0) {
+      Client = pascal(`${name}Client`);
+      Instance = pascal(`${name}Interface`);
+
+      body.push(
+        w.createExecuteInterface(
+          context,
+          Instance,
+          ReadOnlyInstance,
+          ExecuteMsg
+        )
+      );
+      body.push(
+        w.createExecuteClass(
+          context,
+          Client,
+          Instance,
+          QueryClient,
+          ExecuteMsg
+        )
+      );
+    }
+  }
+
+  if (typeHash.hasOwnProperty('Coin')) {
+    // @ts-ignore
+    delete context.utils.Coin;
+  }
+  const imports = context.getImports();
+  const code = header + generate(
+    t.program([
+      ...imports,
+      ...body
+    ])
+  ).code;
+
+  mkdirp(outPath);
+  writeFileSync(join(outPath, localname), code);
+
+  return [
+    {
+      type: 'client',
+      contract: name,
+      localname,
+      filename: join(outPath, localname),
+    }
+  ]
+};

package/src/generators/message-composer.ts

@@ -0,0 +1,86 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { ContractInfo, getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg } from "../utils";
+import { RenderContext, MessageComposerOptions } from "wasm-ast-types";
+import { BuilderFile } from "../builder";
+
+export default async (
+  name: string,
+  contractInfo: ContractInfo,
+  outPath: string,
+  messageComposerOptions?: MessageComposerOptions
+): Promise<BuilderFile[]> => {
+
+  const { schemas } = contractInfo;
+  const context = new RenderContext(contractInfo, {
+    messageComposer: messageComposerOptions ?? {}
+  });
+  // const options = context.options.messageComposer;
+
+  const localname = pascal(name) + '.message-composer.ts';
+  const TypesFile = pascal(name) + '.types';
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+
+  const body = [];
+
+  body.push(
+    w.importStmt(Object.keys(typeHash), `./${TypesFile}`)
+  );
+
+  // execute messages
+  if (ExecuteMsg) {
+    const children = getMessageProperties(ExecuteMsg);
+    if (children.length > 0) {
+      const TheClass = pascal(`${name}MessageComposer`);
+      const Interface = pascal(`${name}Message`);
+
+      body.push(
+        w.createMessageComposerInterface(
+          context,
+          Interface,
+          ExecuteMsg
+        )
+      );
+      body.push(
+        w.createMessageComposerClass(
+          context,
+          TheClass,
+          Interface,
+          ExecuteMsg
+        )
+      );
+    }
+  }
+
+  if (typeHash.hasOwnProperty('Coin')) {
+    // @ts-ignore
+    delete context.utils.Coin;
+  }
+  const imports = context.getImports();
+  const code = header + generate(
+    t.program([
+      ...imports,
+      ...body
+    ])
+  ).code;
+
+  mkdirp(outPath);
+  writeFileSync(join(outPath, localname), code);
+
+  return [
+    {
+      type: 'message-composer',
+      contract: name,
+      localname,
+      filename: join(outPath, localname),
+    }
+  ]
+};

package/src/generators/react-query.ts

@@ -0,0 +1,102 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import { RenderContext } from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { getMessageProperties, ReactQueryOptions, ContractInfo } from "wasm-ast-types";
+import { BuilderFile } from "../builder";
+
+export default async (
+  contractName: string,
+  contractInfo: ContractInfo,
+  outPath: string,
+  reactQueryOptions?: ReactQueryOptions
+): Promise<BuilderFile[]> => {
+  const { schemas } = contractInfo;
+  const context = new RenderContext(contractInfo, {
+    reactQuery: reactQueryOptions ?? {}
+  });
+  const options = context.options.reactQuery;
+
+  const localname = pascal(`${contractName}`) + '.react-query.ts';
+  const ContractFile = pascal(`${contractName}`) + '.client';
+  const TypesFile = pascal(`${contractName}`) + '.types';
+
+  const QueryMsg = findQueryMsg(schemas);
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+
+  const ExecuteClient = pascal(`${contractName}Client`);
+  const QueryClient = pascal(`${contractName}QueryClient`);
+
+  const body = [];
+
+  const clientImports = []
+
+  QueryMsg && clientImports.push(QueryClient)
+
+  // check that there are commands within the exec msg
+  const shouldGenerateMutationHooks = ExecuteMsg && options?.version === 'v4' && options?.mutations && getMessageProperties(ExecuteMsg).length > 0
+
+  if (shouldGenerateMutationHooks) {
+    clientImports.push(ExecuteClient)
+  }
+
+  // general contract imports
+  body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+
+  // client imports
+  body.push(w.importStmt(clientImports, `./${ContractFile}`));
+
+  // query messages
+  if (QueryMsg) {
+    [].push.apply(body,
+      w.createReactQueryHooks({
+        context,
+        queryMsg: QueryMsg,
+        contractName: contractName,
+        QueryClient
+      })
+    );
+  }
+
+  if (shouldGenerateMutationHooks) {
+    [].push.apply(body,
+      w.createReactQueryMutationHooks({
+        context,
+        execMsg: ExecuteMsg,
+        contractName: contractName,
+        ExecuteClient
+      })
+    );
+  }
+
+  if (typeHash.hasOwnProperty('Coin')) {
+    // @ts-ignore
+    delete context.utils.Coin;
+  }
+  const imports = context.getImports();
+  const code = header + generate(
+    t.program([
+      ...imports,
+      ...body
+    ])
+  ).code;
+
+  mkdirp(outPath);
+  writeFileSync(join(outPath, localname), code);
+
+  return [
+    {
+      type: 'react-query',
+      contract: contractName,
+      localname,
+      filename: join(outPath, localname),
+    }
+  ]
+};

package/src/generators/recoil.ts

@@ -0,0 +1,92 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { findAndParseTypes, findQueryMsg } from "../utils";
+import { ContractInfo, RenderContext, RecoilOptions } from "wasm-ast-types";
+import { BuilderFile } from "../builder";
+
+export default async (
+  name: string,
+  contractInfo: ContractInfo,
+  outPath: string,
+  recoilOptions?: RecoilOptions
+): Promise<BuilderFile[]> => {
+
+  const { schemas } = contractInfo;
+  const context = new RenderContext(contractInfo, {
+    recoil: recoilOptions ?? {}
+  });
+  const options = context.options.recoil;
+
+  const localname = pascal(name) + '.recoil.ts';
+  const ContractFile = pascal(name) + '.client';
+  const TypesFile = pascal(name) + '.types';
+
+  const QueryMsg = findQueryMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+
+  let QueryClient = null;
+  let ReadOnlyInstance = null;
+
+  const body = [];
+
+  body.push(
+    w.importStmt(['cosmWasmClient'], './chain')
+  );
+
+  body.push(
+    w.importStmt(Object.keys(typeHash), `./${TypesFile}`)
+  );
+
+  // query messages
+  if (QueryMsg) {
+
+    QueryClient = pascal(`${name}QueryClient`);
+    ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+
+    body.push(
+      w.importStmt([QueryClient], `./${ContractFile}`)
+    );
+
+    body.push(w.createRecoilQueryClientType());
+    body.push(w.createRecoilQueryClient(
+      context,
+      name,
+      QueryClient
+    ));
+
+    [].push.apply(body,
+      w.createRecoilSelectors(context, name, QueryClient, QueryMsg)
+    );
+
+  }
+
+  if (typeHash.hasOwnProperty('Coin')) {
+    // @ts-ignore
+    delete context.utils.Coin;
+  }
+  const imports = context.getImports();
+  const code = header + generate(
+    t.program([
+      ...imports,
+      ...body
+    ])
+  ).code;
+
+  mkdirp(outPath);
+  writeFileSync(join(outPath, localname), code);
+
+  return [
+    {
+      type: 'recoil',
+      contract: name,
+      localname,
+      filename: join(outPath, localname),
+    }
+  ]
+};

package/src/generators/types.ts

@@ -0,0 +1,72 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { clean } from "../utils/clean";
+import { findAndParseTypes, findExecuteMsg } from '../utils';
+import { ContractInfo, RenderContext, TSTypesOptions } from "wasm-ast-types";
+import { BuilderFile } from "../builder";
+
+export default async (
+  name: string,
+  contractInfo: ContractInfo,
+  outPath: string,
+  tsTypesOptions?: TSTypesOptions
+): Promise<BuilderFile[]> => {
+
+  const { schemas } = contractInfo;
+  const context = new RenderContext(contractInfo, {
+    types: tsTypesOptions ?? {}
+  });
+  const options = context.options.types;
+
+  const localname = pascal(name) + '.types.ts';
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+
+  const body = [];
+
+  // TYPES
+  Object.values(typeHash).forEach((type: t.Node) => {
+    body.push(
+      clean(type)
+    )
+  });
+
+  // alias the ExecuteMsg
+  if (options.aliasExecuteMsg && ExecuteMsg) {
+    body.push(
+      t.exportNamedDeclaration(
+        t.tsTypeAliasDeclaration(
+          t.identifier(`${name}ExecuteMsg`),
+          null,
+          t.tsTypeReference(t.identifier('ExecuteMsg'))
+        )
+      )
+    );
+  }
+
+  const imports = context.getImports();
+  const code = header + generate(
+    t.program([
+      ...imports,
+      ...body
+    ])
+  ).code;
+
+  mkdirp(outPath);
+  const filename = join(outPath, localname);
+  writeFileSync(filename, code);
+
+  return [
+    {
+      type: 'type',
+      contract: name,
+      localname,
+      filename,
+    }
+  ]
+};

package/src/index.ts

@@ -0,0 +1,16 @@
+import { TSBuilder, TSBuilderInput } from './builder';
+
+export { default as generateTypes } from './generators/types';
+export { default as generateClient } from './generators/client';
+export { default as generateMessageComposer } from './generators/message-composer';
+export { default as generateReactQuery } from './generators/react-query';
+export { default as generateRecoil } from './generators/recoil';
+
+export * from './utils';
+export * from './builder';
+export * from './bundler';
+
+export default async (input: TSBuilderInput) => {
+    const builder = new TSBuilder(input);
+    await builder.build();
+};

package/src/ts-codegen.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { cli } from './cli';
+var argv = require('minimist')(process.argv.slice(2));
+
+(async () => {
+  await cli(argv);
+})();

package/src/utils/clean.ts

@@ -0,0 +1,45 @@
+export const clean = (obj) => {
+    var copy;
+    // Handle the 3 simple types, and null or undefined
+    if (null == obj || 'object' != typeof obj) return obj;
+
+    // Handle Date
+    if (obj instanceof Date) {
+        copy = new Date();
+        copy.setTime(obj.getTime());
+        return copy;
+    }
+
+    // Handle Array
+    if (obj instanceof Array) {
+        copy = [];
+        for (var i = 0, len = obj.length; i < len; i++) {
+            copy[i] = clean(obj[i]);
+        }
+        return copy;
+    }
+
+    // Handle Object
+    if (obj instanceof Object || typeof obj === 'object') {
+        copy = {};
+        for (var attr in obj) {
+            if (obj.hasOwnProperty(attr)) {
+                switch (attr) {
+                    case 'leadingComments':
+                    case 'trailingComments':
+                    case 'loc':
+                    case 'start':
+                    case 'end':
+                        break;
+                    default:
+                        copy[attr] = clean(obj[attr]);
+                }
+            } else {
+                copy[attr] = clean(obj[attr]);
+            }
+        }
+        return copy;
+    }
+
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};