wasm-ast-types 0.26.4 → 1.0.0

package/src/message-builder/__snapshots__/message-builder.spec.ts.snap

@@ -1,270 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`execute class 1`] = `
-"export abstract class SG721MessageBuilder {
-  static transferNft = ({
-    recipient,
-    tokenId
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    transfer_nft: unknown;
-  }>[\\"transfer_nft\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      transfer_nft: ({
-        recipient,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static sendNft = ({
-    contract,
-    msg,
-    tokenId
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    send_nft: unknown;
-  }>[\\"send_nft\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      send_nft: ({
-        contract,
-        msg,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static approve = ({
-    expires,
-    spender,
-    tokenId
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    approve: unknown;
-  }>[\\"approve\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      approve: ({
-        expires,
-        spender,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static revoke = ({
-    spender,
-    tokenId
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    revoke: unknown;
-  }>[\\"revoke\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      revoke: ({
-        spender,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static approveAll = ({
-    expires,
-    operator
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    approve_all: unknown;
-  }>[\\"approve_all\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      approve_all: ({
-        expires,
-        operator
-      } as const)
-    };
-  };
-  static revokeAll = ({
-    operator
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    revoke_all: unknown;
-  }>[\\"revoke_all\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      revoke_all: ({
-        operator
-      } as const)
-    };
-  };
-  static mint = ({
-    extension,
-    owner,
-    tokenId,
-    tokenUri
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    mint: unknown;
-  }>[\\"mint\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      mint: ({
-        extension,
-        owner,
-        token_id: tokenId,
-        token_uri: tokenUri
-      } as const)
-    };
-  };
-  static burn = ({
-    tokenId
-  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
-    burn: unknown;
-  }>[\\"burn\\"]>): ExecuteMsg_for_Empty => {
-    return {
-      burn: ({
-        token_id: tokenId
-      } as const)
-    };
-  };
-}"
-`;
-
-exports[`ownership 1`] = `
-"export abstract class Ownership {
-  static setFactory = ({
-    newFactory
-  }: CamelCasedProperties<Extract<ExecuteMsg, {
-    set_factory: unknown;
-  }>[\\"set_factory\\"]>): ExecuteMsg => {
-    return {
-      set_factory: ({
-        new_factory: newFactory
-      } as const)
-    };
-  };
-  static updateOwnership = (action: Action): ExecuteMsg => {
-    return {
-      update_ownership: action
-    };
-  };
-}"
-`;
-
-exports[`query class 1`] = `
-"export abstract class SG721MessageBuilder {
-  static ownerOf = ({
-    includeExpired,
-    tokenId
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    owner_of: unknown;
-  }>[\\"owner_of\\"]>): QueryMsg => {
-    return {
-      owner_of: ({
-        include_expired: includeExpired,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static approval = ({
-    includeExpired,
-    spender,
-    tokenId
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    approval: unknown;
-  }>[\\"approval\\"]>): QueryMsg => {
-    return {
-      approval: ({
-        include_expired: includeExpired,
-        spender,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static approvals = ({
-    includeExpired,
-    tokenId
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    approvals: unknown;
-  }>[\\"approvals\\"]>): QueryMsg => {
-    return {
-      approvals: ({
-        include_expired: includeExpired,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static allOperators = ({
-    includeExpired,
-    limit,
-    owner,
-    startAfter
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    all_operators: unknown;
-  }>[\\"all_operators\\"]>): QueryMsg => {
-    return {
-      all_operators: ({
-        include_expired: includeExpired,
-        limit,
-        owner,
-        start_after: startAfter
-      } as const)
-    };
-  };
-  static numTokens = (): QueryMsg => {
-    return {
-      num_tokens: ({} as const)
-    };
-  };
-  static contractInfo = (): QueryMsg => {
-    return {
-      contract_info: ({} as const)
-    };
-  };
-  static nftInfo = ({
-    tokenId
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    nft_info: unknown;
-  }>[\\"nft_info\\"]>): QueryMsg => {
-    return {
-      nft_info: ({
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static allNftInfo = ({
-    includeExpired,
-    tokenId
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    all_nft_info: unknown;
-  }>[\\"all_nft_info\\"]>): QueryMsg => {
-    return {
-      all_nft_info: ({
-        include_expired: includeExpired,
-        token_id: tokenId
-      } as const)
-    };
-  };
-  static tokens = ({
-    limit,
-    owner,
-    startAfter
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    tokens: unknown;
-  }>[\\"tokens\\"]>): QueryMsg => {
-    return {
-      tokens: ({
-        limit,
-        owner,
-        start_after: startAfter
-      } as const)
-    };
-  };
-  static allTokens = ({
-    limit,
-    startAfter
-  }: CamelCasedProperties<Extract<QueryMsg, {
-    all_tokens: unknown;
-  }>[\\"all_tokens\\"]>): QueryMsg => {
-    return {
-      all_tokens: ({
-        limit,
-        start_after: startAfter
-      } as const)
-    };
-  };
-  static minter = (): QueryMsg => {
-    return {
-      minter: ({} as const)
-    };
-  };
-  static collectionInfo = (): QueryMsg => {
-    return {
-      collection_info: ({} as const)
-    };
-  };
-}"
-`;

package/src/message-builder/message-builder.spec.ts

@@ -1,24 +0,0 @@
-import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
-import query_msg from '../../../../__fixtures__/basic/query_msg.json';
-import ownership from '../../../../__fixtures__/basic/ownership.json';
-
-import {
-  createMessageBuilderClass,
-} from './message-builder'
-import { expectCode, makeContext } from '../../test-utils';
-
-it('execute class', () => {
-  const ctx = makeContext(execute_msg);
-  expectCode(createMessageBuilderClass(ctx, 'SG721MessageBuilder', execute_msg))
-});
-
-
-it('query class', () => {
-  const ctx = makeContext(query_msg);
-  expectCode(createMessageBuilderClass(ctx, 'SG721MessageBuilder', query_msg))
-});
-
-it('ownership', () => {
-  const ctx = makeContext(ownership);
-  expectCode(createMessageBuilderClass(ctx, 'Ownership', ownership))
-});

package/src/message-builder/message-builder.ts

@@ -1,119 +0,0 @@
-import * as t from '@babel/types';
-import { camel } from 'case';
-import { abstractClassDeclaration, arrowFunctionExpression, getMessageProperties } from '../utils';
-import { ExecuteMsg, QueryMsg } from '../types';
-import { createTypedObjectParams } from '../utils/types';
-import { RenderContext } from '../context';
-import { getWasmMethodArgs } from '../client/client';
-import { Expression } from '@babel/types';
-
-export const createMessageBuilderClass = (
-  context: RenderContext,
-  className: string,
-  msg: ExecuteMsg | QueryMsg
-): t.ExportNamedDeclaration => {
-  const staticMethods = getMessageProperties(msg).map((schema) => {
-    return createStaticExecMethodMessageBuilder(context, schema, msg.title);
-  });
-
-  // const blockStmt = bindings;
-
-  return t.exportNamedDeclaration(
-    abstractClassDeclaration(className, staticMethods, [], null)
-  );
-};
-
-/**
- * CamelCasedProperties<Extract<ExecuteMsg, { exec_on_module: unknown }>['exec_on_module']>
- */
-function createExtractTypeAnnotation(underscoreName: string, msgTitle: string) {
-  return t.tsTypeAnnotation(
-    t.tsTypeReference(
-      t.identifier('CamelCasedProperties'),
-      t.tsTypeParameterInstantiation([
-        t.tsIndexedAccessType(
-          t.tsTypeReference(t.identifier('Extract'),
-            t.tsTypeParameterInstantiation([
-              t.tsTypeReference(t.identifier(msgTitle)),
-              t.tsTypeLiteral([
-                t.tsPropertySignature(
-                  t.identifier(underscoreName),
-                  t.tsTypeAnnotation(t.tsUnknownKeyword())
-                )
-              ])
-            ])
-          ),
-          t.tsLiteralType(t.stringLiteral(underscoreName))
-        )
-      ])
-    )
-  );
-}
-
-const createStaticExecMethodMessageBuilder = (
-  context: RenderContext,
-  jsonschema: any,
-  msgTitle: string
-) => {
-  const underscoreName = Object.keys(jsonschema.properties)[0];
-  const methodName = camel(underscoreName);
-  const param = createTypedObjectParams(
-    context,
-    jsonschema.properties[underscoreName]
-  );
-  const args = getWasmMethodArgs(
-    context,
-    jsonschema.properties[underscoreName]
-  );
-
-  // what the underscore named property in the message is assigned to
-  let actionValue: Expression
-  if (param?.type === 'Identifier') {
-    actionValue = t.identifier(param.name);
-  } else {
-    actionValue = t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')));
-  }
-
-
-  // TODO: this is a hack to get the type annotation to work
-  // all type annotations in the future should be the extracted and camelized type
-  if (
-    param &&
-    param.typeAnnotation.type === 'TSTypeAnnotation' &&
-    param.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral'
-  ) {
-    param.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
-  }
-
-  return t.classProperty(
-    t.identifier(methodName),
-    arrowFunctionExpression(
-      // params
-      param
-        ? [
-          // props
-          param
-        ]
-        : [],
-      // body
-      t.blockStatement([
-        t.returnStatement(
-          t.objectExpression([
-            t.objectProperty(
-              t.identifier(underscoreName),
-              actionValue
-            )
-          ])
-        )
-      ]),
-      // return type
-      t.tsTypeAnnotation(t.tsTypeReference(t.identifier(msgTitle))),
-      false
-    ),
-    null,
-    null,
-    false,
-    // static
-    true
-  );
-};