chore: added action method to generated Contract class

wharfkit · Aug 16, 2023 · 767ae7b · 767ae7b
1 parent 3e443a7
commit 767ae7b
Show file tree

Hide file tree

Showing 3 changed files with 120 additions and 34 deletions.
diff --git a/src/codegen.ts b/src/codegen.ts
@@ -44,7 +44,7 @@ export async function codegen(contractName, abi) {
             '@wharfkit/session'
         )
 
-        const {classDeclaration} = await generateContractClass(namespaceName, contractName)
+        const {classDeclaration} = await generateContractClass(contractName, abi)
 
         // Iterate through structs and create struct classes with fields
         const structDeclarations = generateStructClasses(abi)

diff --git a/src/codegen/contract.ts b/src/codegen/contract.ts
@@ -1,8 +1,9 @@
+import { ABI } from '@wharfkit/session'
 import * as ts from 'typescript'
 
 import {generateClassDeclaration} from './helpers'
 
-export async function generateContractClass(namespaceName: string, contractName: string) {
+export async function generateContractClass(contractName: string, abi: ABI.Def) {
     // Prepare the member fields of the class
     const classMembers: ts.ClassElement[] = []
 
@@ -30,37 +31,7 @@ export async function generateContractClass(namespaceName: string, contractName:
 
     const constructorBody = ts.factory.createBlock(
         [
-            ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(ts.factory.createSuper(), undefined, [
-                    ts.factory.createObjectLiteralExpression(
-                        [
-                            ts.factory.createPropertyAssignment(
-                                'client',
-                                ts.factory.createPropertyAccessExpression(
-                                    ts.factory.createIdentifier('args'),
-                                    'client'
-                                )
-                            ),
-                            ts.factory.createPropertyAssignment(
-                                'abi',
-                                ts.factory.createIdentifier('abi')
-                            ),
-                            ts.factory.createPropertyAssignment(
-                                'account',
-                                ts.factory.createCallExpression(
-                                    ts.factory.createPropertyAccessExpression(
-                                        ts.factory.createIdentifier('Name'),
-                                        'from'
-                                    ),
-                                    undefined,
-                                    [ts.factory.createStringLiteral(contractName)]
-                                )
-                            ),
-                        ],
-                        true
-                    ),
-                ])
-            ),
+            generateConstructorFunction(contractName),
         ],
         true
     )
@@ -71,9 +42,14 @@ export async function generateContractClass(namespaceName: string, contractName:
         constructorParams,
         constructorBody
     )
-
+    
     classMembers.push(constructorMember)
 
+    const actionMethod = generateActionFunction(abi)
+
+    classMembers.push(actionMethod)
+
+
     // Construct class declaration
     const classDeclaration = generateClassDeclaration('Contract', classMembers, {
         parent: 'BaseContract',
@@ -82,3 +58,106 @@ export async function generateContractClass(namespaceName: string, contractName:
 
     return {classDeclaration}
 }
+
+function generateConstructorFunction(contractName): ts.ExpressionStatement {
+    return ts.factory.createExpressionStatement(
+        ts.factory.createCallExpression(ts.factory.createSuper(), undefined, [
+            ts.factory.createObjectLiteralExpression(
+                [
+                    ts.factory.createPropertyAssignment(
+                        'client',
+                        ts.factory.createPropertyAccessExpression(
+                            ts.factory.createIdentifier('args'),
+                            'client'
+                        )
+                    ),
+                    ts.factory.createPropertyAssignment(
+                        'abi',
+                        ts.factory.createIdentifier('abi')
+                    ),
+                    ts.factory.createPropertyAssignment(
+                        'account',
+                        ts.factory.createCallExpression(
+                            ts.factory.createPropertyAccessExpression(
+                                ts.factory.createIdentifier('Name'),
+                                'from'
+                            ),
+                            undefined,
+                            [ts.factory.createStringLiteral(contractName)]
+                        )
+                    ),
+                ],
+                true
+            ),
+        ])
+    )
+}
+
+function generateActionFunction(abi: ABI.Def): ts.MethodDeclaration {
+    console.log({abi})
+    const typeParameter = ts.factory.createTypeParameterDeclaration(
+        "T",
+        ts.factory.createUnionTypeNode(
+            abi.actions.map(action =>
+                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(String(action.name)))
+            )
+        )
+    );
+
+    // 3. Create the function parameters.
+    const nameParameter = ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        undefined,
+        "name",
+        undefined,
+        ts.factory.createTypeReferenceNode("T"),
+        undefined
+    );
+
+    const dataParameter = ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        undefined,
+        "data",
+        undefined,
+        ts.factory.createTypeReferenceNode("ActionNameParams", [ts.factory.createTypeReferenceNode("T")]),
+        undefined
+    );
+
+    const optionsParameter = ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        undefined,
+        "options",
+        ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+        ts.factory.createTypeReferenceNode("ActionOptions"),
+        undefined
+    );
+
+    // 4. Generate the function body.
+    const functionBody = ts.factory.createBlock([
+        ts.factory.createReturnStatement(
+            ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(
+                    ts.factory.createSuper(),
+                    ts.factory.createIdentifier("action")
+                ),
+                undefined,
+                [ts.factory.createIdentifier("name"), ts.factory.createIdentifier("data"), ts.factory.createIdentifier("options")]
+            )
+        )
+    ], true);
+
+    return ts.factory.createMethodDeclaration(
+        undefined,
+        undefined,
+        undefined,
+        'action',
+        undefined,
+        [typeParameter],
+        [nameParameter, dataParameter, optionsParameter],
+        ts.factory.createTypeReferenceNode("Action"),
+        functionBody
+    );
+}
diff --git a/test/tmp/rewards.gm.ts b/test/tmp/rewards.gm.ts
@@ -26,6 +26,13 @@ export namespace RewardsGm {
                 account: Name.from('rewards.gm'),
             })
         }
+        action<T extends 'adduser' | 'claim' | 'configure' | 'deluser' | 'receipt' | 'updateuser'>(
+            name: T,
+            data: ActionNameParams<T>,
+            options?: ActionOptions
+        ): Action {
+            return super.action(name, data, options)
+        }
     }
     export namespace Types {
         @Struct.type('adduser')