Generated code support for readonly transactions and return values (#31)

* Initial testing.gm for return values * Failing test * Fixed contract name * Updated contract kit * The updated test * The changes we need added to code generation * chore: implementing return values codegen (#32) * chore: implementing return values codegen * enhancement: making data param on readonly method optional --------- Co-authored-by: Daniel Fugere <[email protected]>
wharfkit · Jan 17, 2024 · 54fb057 · 54fb057
1 parent a43b105
commit 54fb057
Show file tree

Hide file tree

Showing 14 changed files with 1,118 additions and 20 deletions.
diff --git a/Makefile b/Makefile
@@ -31,6 +31,7 @@ update_mock_contracts: node_modules clean lib
 	node lib/cli.js generate eosio.token -u https://jungle4.greymass.com -j test/data/abis/eosio.token.json -f test/data/contracts/mock-eosio.token.ts -e .eslintrc
 	node lib/cli.js generate hegemon.hgm -u https://jungle4.greymass.com -j test/data/abis/hegemon.hgm.json -f test/data/contracts/mock-hegemon.hgm.ts -e .eslintrc
 	node lib/cli.js generate rewards.gm -u https://jungle4.greymass.com -j test/data/abis/rewards.gm.json -f test/data/contracts/mock-rewards.gm.ts -e .eslintrc
+	node lib/cli.js generate testing.gm -u https://jungle4.greymass.com -j test/data/abis/testing.gm.json -f test/data/contracts/mock-testing.gm.ts -e .eslintrc
 
 .PHONY: check
 check: node_modules

diff --git a/package.json b/package.json
@@ -27,7 +27,7 @@
     "dependencies": {
         "@wharfkit/antelope": "^1.0.0",
         "@wharfkit/common": "^1.2.0",
-        "@wharfkit/contract": "^1.1.1",
+        "@wharfkit/contract": "^1.1.4",
         "commander": "^11.0.0",
         "eslint": "^8.48.0",
         "node-fetch": "^2.6.1",

diff --git a/src/commands/contract/class.ts b/src/commands/contract/class.ts
@@ -47,6 +47,11 @@ export async function generateContractClass(contractName: string, abi: ABI.Def)
         classMembers.push(actionMethod)
     }
 
+    if (abi.action_results.length) {
+        const readonlyMethod = generateReadonlyMethod()
+        classMembers.push(readonlyMethod)
+    }
+
     if (abi.tables.length) {
         const tableMethod = generateTableMethod()
 
@@ -168,6 +173,81 @@ function generateActionMethod(): ts.MethodDeclaration {
     )
 }
 
+function generateReadonlyMethod(): ts.MethodDeclaration {
+    // Create the generic type parameter 'T' with a constraint to 'ActionReturnNames'
+    const typeParameter = ts.factory.createTypeParameterDeclaration(
+        undefined,
+        'T',
+        ts.factory.createTypeReferenceNode('ActionReturnNames')
+    )
+
+    // Create the function parameters.
+    const nameParameter = ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        'name',
+        undefined,
+        ts.factory.createTypeReferenceNode('T'),
+        undefined
+    )
+
+    const dataParameter = ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        'data',
+        ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+        ts.factory.createIndexedAccessTypeNode(
+            ts.factory.createTypeReferenceNode('ActionNameParams'),
+            ts.factory.createTypeReferenceNode('T')
+        ),
+        undefined
+    )
+
+    // Generate the function body.
+    const methodBody = ts.factory.createBlock(
+        [
+            ts.factory.createReturnStatement(
+                ts.factory.createAsExpression(
+                    ts.factory.createAsExpression(
+                        ts.factory.createCallExpression(
+                            ts.factory.createPropertyAccessExpression(
+                                ts.factory.createSuper(),
+                                'readonly'
+                            ),
+                            undefined,
+                            [
+                                ts.factory.createIdentifier('name'),
+                                ts.factory.createIdentifier('data'),
+                            ]
+                        ),
+                        ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)
+                    ),
+                    ts.factory.createIndexedAccessTypeNode(
+                        ts.factory.createTypeReferenceNode('ActionReturnValues'),
+                        ts.factory.createTypeReferenceNode('T')
+                    )
+                )
+            ),
+        ],
+        true
+    )
+
+    // Create the method declaration
+    return ts.factory.createMethodDeclaration(
+        undefined,
+        undefined,
+        'readonly',
+        undefined,
+        [typeParameter],
+        [nameParameter, dataParameter],
+        ts.factory.createIndexedAccessTypeNode(
+            ts.factory.createTypeReferenceNode('ActionReturnValues'),
+            ts.factory.createTypeReferenceNode('T')
+        ),
+        methodBody
+    )
+}
+
 export function generateTableMethod(): ts.MethodDeclaration {
     // Create the generic type parameter 'T' with a constraint to 'tables'
     const typeParameter = ts.factory.createTypeParameterDeclaration(

diff --git a/src/commands/contract/helpers.ts b/src/commands/contract/helpers.ts
@@ -46,7 +46,7 @@ export function getCoreImports(abi: ABI.Def) {
         }
     }
 
-    if (abi.variants.length != 0) {
+    if (abi.variants.length) {
         coreImports.push('Variant')
         for (const variant of abi.variants) {
             variant.types.forEach((typeString) => {
@@ -59,6 +59,16 @@ export function getCoreImports(abi: ABI.Def) {
         }
     }
 
+    if (abi.action_results.length) {
+        for (const actionResult of abi.action_results) {
+            const {type: abiType} = findAbiType(actionResult.result_type, abi)
+            const coreClass = findCoreClassImport(abiType)
+            if (coreClass) {
+                coreImports.push(coreClass)
+            }
+        }
+    }
+
     return {
         classes: coreImports.filter((value, index, self) => self.indexOf(value) === index),
         types: coreTypes

diff --git a/src/commands/contract/index.ts b/src/commands/contract/index.ts
@@ -9,11 +9,16 @@ import {abiToBlob, ContractKit} from '@wharfkit/contract'
 import {log, makeClient} from '../../utils'
 import {generateContractClass} from './class'
 import {generateImportStatement, getCoreImports} from './helpers'
-import {generateActionNamesInterface, generateActionsNamespace} from './interfaces'
+import {
+    generateActionNamesInterface,
+    generateActionReturnValuesInterface,
+    generateActionsNamespace,
+} from './interfaces'
 import {generateTableMap, generateTableTypesInterface} from './maps'
 import {generateNamespace} from './namespace'
 import {generateStructClasses} from './structs'
 import {generateActionsTypeAlias, generateRowType, generateTablesTypeAlias} from './types'
+import {generateActionReturnNamesType} from './interfaces'
 
 const printer = ts.createPrinter()
 
@@ -161,6 +166,14 @@ export async function generateContract(contractName: string, abi: ABI, eslintrc?
         const actionsTypeAlias = generateActionsTypeAlias()
         const rowTypeAlias = generateRowType()
 
+        let actionResultValuesInterface: ts.InterfaceDeclaration | undefined
+        let actionResultsNamesType: ts.TypeAliasDeclaration | undefined
+
+        if (abi.action_results.length) {
+            actionResultValuesInterface = generateActionReturnValuesInterface(abi)
+            actionResultsNamesType = generateActionReturnNamesType()
+        }
+
         const sourceFile = ts.factory.createSourceFile(
             [
                 importAntelopeTypesStatement,
@@ -178,6 +191,8 @@ export async function generateContract(contractName: string, abi: ABI, eslintrc?
                 rowTypeAlias,
                 actionsTypeAlias,
                 tablesTypeAlias,
+                ...(actionResultValuesInterface ? [actionResultValuesInterface] : []),
+                ...(actionResultsNamesType ? [actionResultsNamesType] : []),
             ],
             ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
             ts.NodeFlags.None

diff --git a/src/commands/contract/interfaces.ts b/src/commands/contract/interfaces.ts
@@ -1,7 +1,7 @@
 import type {ABI} from '@wharfkit/antelope'
 import ts from 'typescript'
 import {parseType, removeCommas, removeDuplicateInterfaces} from './helpers'
-import {getActionFieldFromAbi} from './structs'
+import {findFieldTypeString, getActionFieldFromAbi} from './structs'
 import {findAbiStruct, findExternalType, findTypeFromAlias, findVariant} from './finders'
 
 export function generateActionNamesInterface(abi: ABI.Def): ts.InterfaceDeclaration {
@@ -157,3 +157,40 @@ function findParamTypeString(typeString: string, namespace = '', abi: ABI.Def):
 
     return parseType(fieldType)
 }
+
+export function generateActionReturnValuesInterface(abi: ABI.Def): ts.InterfaceDeclaration {
+    const actionResults: ABI.ActionResult[] = abi.action_results
+    const members = actionResults.map((result) => {
+        return ts.factory.createPropertySignature(
+            undefined,
+            String(result.name),
+            undefined,
+            ts.factory.createTypeReferenceNode(
+                findFieldTypeString(result.result_type, 'Types.', abi),
+                undefined
+            )
+        )
+    })
+
+    return ts.factory.createInterfaceDeclaration(
+        undefined,
+        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        'ActionReturnValues',
+        undefined,
+        undefined,
+        members
+    )
+}
+
+export function generateActionReturnNamesType(): ts.TypeAliasDeclaration {
+    return ts.factory.createTypeAliasDeclaration(
+        undefined,
+        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        'ActionReturnNames',
+        undefined,
+        ts.factory.createTypeOperatorNode(
+            ts.SyntaxKind.KeyOfKeyword,
+            ts.factory.createTypeReferenceNode('ActionReturnValues', undefined)
+        )
+    )
+}
diff --git a/src/commands/contract/structs.ts b/src/commands/contract/structs.ts
@@ -101,9 +101,7 @@ export function generateVariant(variant, abi: any, isExport = false): ts.ClassDe
         ts.factory.createUnionTypeNode(
             variant.fields.map((field) => {
                 return ts.factory.createTypeReferenceNode(
-                    ts.factory.createIdentifier(
-                        findFieldStructTypeString(field.type, undefined, abi)
-                    ),
+                    ts.factory.createIdentifier(findFieldTypeString(field.type, undefined, abi)),
                     undefined
                 )
             })
@@ -178,7 +176,7 @@ export function generateField(
         findFieldStructType(field.type, namespace, abi),
     ]
 
-    const structTypeString = findFieldStructTypeString(field.type, namespace, abi)
+    const structTypeString = findFieldTypeString(field.type, namespace, abi)
     isArray = isArray || structTypeString.endsWith('[]')
 
     // Build the options object if needed
@@ -304,7 +302,7 @@ function findVariantStructType(
     namespace: string | undefined,
     abi: ABI.Def
 ): ts.Identifier | ts.StringLiteral | ts.ObjectLiteralExpression {
-    const variantTypeString = findFieldStructTypeString(typeString, namespace, abi)
+    const variantTypeString = findFieldTypeString(typeString, namespace, abi)
 
     if (['string', 'string[]', 'boolean', 'boolean[]'].includes(variantTypeString.toLowerCase())) {
         return ts.factory.createStringLiteral(formatFieldString(variantTypeString))
@@ -337,9 +335,7 @@ function findFieldStructType(
     namespace: string | undefined,
     abi: ABI.Def
 ): ts.Identifier | ts.StringLiteral {
-    const fieldTypeString = extractDecorator(
-        findFieldStructTypeString(typeString, namespace, abi)
-    ).type
+    const fieldTypeString = extractDecorator(findFieldTypeString(typeString, namespace, abi)).type
 
     if (['string', 'string[]', 'boolean', 'boolean[]'].includes(fieldTypeString.toLowerCase())) {
         return ts.factory.createStringLiteral(formatFieldString(fieldTypeString))
@@ -348,7 +344,7 @@ function findFieldStructType(
     return ts.factory.createIdentifier(fieldTypeString)
 }
 
-function findFieldStructTypeString(
+export function findFieldTypeString(
     typeString: string,
     namespace: string | undefined,
     abi: ABI.Def