fix: typegen generic configurables

.changeset/strange-moose-eat.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/abi-typegen": patch
+---
+
+fix: typegen generic configurables

packages/abi-typegen/src/abi/Abi.test.ts

@@ -6,7 +6,6 @@ import {
 } from '../../test/fixtures/forc-projects/index';
 import { ProgramTypeEnum } from '../types/enums/ProgramTypeEnum';
 import type { JsonAbiType } from '../types/interfaces/JsonAbi';
-import * as parseConfigurablesMod from '../utils/parseConfigurables';
 import * as parseFunctionsMod from '../utils/parseFunctions';
 import * as parseTypesMod from '../utils/parseTypes';
 
@@ -29,14 +28,9 @@ describe('Abi.ts', () => {
       .spyOn(parseFunctionsMod, 'parseFunctions')
       .mockImplementation(() => []);
 
-    const parseConfigurables = vi
-      .spyOn(parseConfigurablesMod, 'parseConfigurables')
-      .mockImplementation(() => []);
-
     return {
       parseTypes,
       parseFunctions,
-      parseConfigurables,
     };
   }
 
@@ -78,13 +72,12 @@ describe('Abi.ts', () => {
   test('should create a new abi instance and parse root nodes', () => {
     const {
       abi,
-      mocks: { parseTypes, parseFunctions, parseConfigurables },
+      mocks: { parseTypes, parseFunctions },
     } = getMockedAbi();
 
     expect(abi).toBeTruthy();
     expect(parseTypes).toHaveBeenCalledTimes(1);
     expect(parseFunctions).toHaveBeenCalledTimes(1);
-    expect(parseConfigurables).toHaveBeenCalledTimes(1);
   });
 
   test('should compute array of custom types in use', () => {

packages/abi-typegen/src/abi/Abi.ts

@@ -6,10 +6,11 @@ import type { IConfigurable } from '../types/interfaces/IConfigurable';
 import type { IFunction } from '../types/interfaces/IFunction';
 import type { IType } from '../types/interfaces/IType';
 import type { JsonAbi } from '../types/interfaces/JsonAbi';
-import { parseConfigurables } from '../utils/parseConfigurables';
 import { parseFunctions } from '../utils/parseFunctions';
 import { parseTypes } from '../utils/parseTypes';
 
+import { Configurable } from './configurable/Configurable';
+
 /*
   Manages many instances of Types and Functions
 */
@@ -88,7 +89,9 @@ export class Abi {
 
     const types = parseTypes({ rawAbiTypes });
     const functions = parseFunctions({ rawAbiFunctions, types });
-    const configurables = parseConfigurables({ rawAbiConfigurables, types });
+    const configurables = rawAbiConfigurables.map(
+      (rawAbiConfigurable) => new Configurable({ types, rawAbiConfigurable })
+    );
 
     return {
       types,

packages/abi-typegen/src/abi/configurable/Configurable.test.ts

@@ -54,7 +54,6 @@ describe('Configurable.ts', () => {
 
     expect(findType).toHaveBeenCalledTimes(1);
     expect(configurable.name).toEqual('FEE');
-    expect(configurable.type).toEqual(type);
-    expect(configurable.rawAbiConfigurable).toEqual(rawAbiConfigurable);
+    expect(configurable.inputLabel).toEqual('mockType');
   });
 });

packages/abi-typegen/src/abi/configurable/Configurable.ts

@@ -1,18 +1,23 @@
 import type { IConfigurable } from '../../types/interfaces/IConfigurable';
 import type { IType } from '../../types/interfaces/IType';
 import type { JsonAbiConfigurable } from '../../types/interfaces/JsonAbi';
-import { findType } from '../../utils/findType';
+import { resolveInputLabel } from '../../utils/getTypeDeclaration';
 
 export class Configurable implements IConfigurable {
   public name: string;
-  public type: IType;
-  public rawAbiConfigurable: JsonAbiConfigurable;
+  public inputLabel: string;
 
   constructor(params: { types: IType[]; rawAbiConfigurable: JsonAbiConfigurable }) {
-    const { types, rawAbiConfigurable } = params;
+    const {
+      types,
+      rawAbiConfigurable: {
+        name,
+        configurableType: { type, typeArguments },
+      },
+    } = params;
 
-    this.name = rawAbiConfigurable.name;
-    this.rawAbiConfigurable = rawAbiConfigurable;
-    this.type = findType({ types, typeId: rawAbiConfigurable.configurableType.type });
+    this.name = name;
+
+    this.inputLabel = resolveInputLabel(types, type, typeArguments);
   }
 }

packages/abi-typegen/src/abi/functions/Function.ts

@@ -2,6 +2,7 @@ import type { IFunction, JsonAbiFunction, IFunctionAttributes } from '../../inde
 import { TargetEnum } from '../../types/enums/TargetEnum';
 import type { IType } from '../../types/interfaces/IType';
 import { findType } from '../../utils/findType';
+import { resolveInputLabel } from '../../utils/getTypeDeclaration';
 import { parseTypeArguments } from '../../utils/parseTypeArguments';
 import { EmptyType } from '../types/EmptyType';
 
@@ -35,22 +36,7 @@ export class Function implements IFunction {
       .map((input) => {
         const { name, type: typeId, typeArguments } = input;
 
-        const type = findType({ types, typeId });
-
-        let typeDecl: string;
-
-        if (typeArguments) {
-          // recursively process child `typeArguments`
-          typeDecl = parseTypeArguments({
-            types,
-            target: TargetEnum.INPUT,
-            parentTypeId: typeId,
-            typeArguments,
-          });
-        } else {
-          // or just collect type declaration
-          typeDecl = type.attributes.inputLabel;
-        }
+        const typeDecl = resolveInputLabel(types, typeId, typeArguments);
 
         // assemble it in `[key: string]: <Type>` fashion
         if (shouldPrefixParams) {

packages/abi-typegen/src/templates/contract/dts.hbs

@@ -40,10 +40,10 @@ export type {{structName}}Output{{typeAnnotations}} = { {{outputValues}} };
 {{/if}}
 {{/each}}
 
-{{#if formattedConfigurables}}
+{{#if configurables}}
 export type {{capitalizedName}}Configurables = Partial<{
-{{#each formattedConfigurables}}
-  {{configurableName}}: {{configurableType}};
+{{#each configurables}}
+  {{name}}: {{inputLabel}};
 {{/each}}
 }>;
 {{/if}}

packages/abi-typegen/src/templates/contract/dts.ts

@@ -1,6 +1,5 @@
 import type { Abi } from '../../abi/Abi';
 import { renderHbsTemplate } from '../renderHbsTemplate';
-import { formatConfigurables } from '../utils/formatConfigurables';
 import { formatEnums } from '../utils/formatEnums';
 import { formatImports } from '../utils/formatImports';
 import { formatStructs } from '../utils/formatStructs';
@@ -39,7 +38,6 @@ export function renderDtsTemplate(params: { abi: Abi }) {
       'InvokeFunction',
     ],
   });
-  const { formattedConfigurables } = formatConfigurables({ configurables });
 
   /*
     And finally render template
@@ -56,7 +54,7 @@ export function renderDtsTemplate(params: { abi: Abi }) {
       structs,
       enums,
       imports,
-      formattedConfigurables,
+      configurables,
     },
   });
 

packages/abi-typegen/src/templates/predicate/factory.hbs

@@ -41,8 +41,8 @@ export type {{structName}}Output{{typeAnnotations}} = { {{outputValues}} };
 {{/each}}
 
 export type {{capitalizedName}}Configurables = Partial<{
-{{#each formattedConfigurables}}
-  {{configurableName}}: {{configurableType}};
+{{#each configurables}}
+  {{name}}: {{inputLabel}};
 {{/each}}
 }>;
 

packages/abi-typegen/src/templates/predicate/factory.ts

@@ -2,7 +2,6 @@ import { ErrorCode, FuelError } from '@fuel-ts/errors';
 
 import type { Abi } from '../../abi/Abi';
 import { renderHbsTemplate } from '../renderHbsTemplate';
-import { formatConfigurables } from '../utils/formatConfigurables';
 import { formatEnums } from '../utils/formatEnums';
 import { formatImports } from '../utils/formatImports';
 import { formatStructs } from '../utils/formatStructs';
@@ -35,7 +34,6 @@ export function renderFactoryTemplate(params: { abi: Abi }) {
     types,
     baseMembers: ['Predicate', 'Provider', 'InputValue'],
   });
-  const { formattedConfigurables } = formatConfigurables({ configurables });
 
   const { prefixedInputs: inputs, output } = func.attributes;
 
@@ -50,7 +48,7 @@ export function renderFactoryTemplate(params: { abi: Abi }) {
       hexlifiedBinString,
       capitalizedName,
       imports,
-      formattedConfigurables,
+      configurables,
       commonTypesInUse: commonTypesInUse.join(', '),
     },
   });

packages/abi-typegen/src/templates/script/factory.hbs

@@ -43,10 +43,10 @@ export type {{structName}}Output{{typeAnnotations}} = { {{outputValues}} };
 type {{capitalizedName}}Inputs = [{{inputs}}];
 type {{capitalizedName}}Output = {{output}};
 
-{{#if formattedConfigurables}}
+{{#if configurables}}
 export type {{capitalizedName}}Configurables = Partial<{
-{{#each formattedConfigurables}}
-  {{configurableName}}: {{configurableType}};
+{{#each configurables}}
+  {{name}}: {{inputLabel}};
 {{/each}}
 }>;
 {{/if}}

packages/abi-typegen/src/templates/script/factory.ts

@@ -2,7 +2,6 @@ import { ErrorCode, FuelError } from '@fuel-ts/errors';
 
 import type { Abi } from '../../abi/Abi';
 import { renderHbsTemplate } from '../renderHbsTemplate';
-import { formatConfigurables } from '../utils/formatConfigurables';
 import { formatEnums } from '../utils/formatEnums';
 import { formatImports } from '../utils/formatImports';
 import { formatStructs } from '../utils/formatStructs';
@@ -32,7 +31,6 @@ export function renderFactoryTemplate(params: { abi: Abi }) {
   const { enums } = formatEnums({ types });
   const { structs } = formatStructs({ types });
   const { imports } = formatImports({ types, baseMembers: ['Script', 'Account'] });
-  const { formattedConfigurables } = formatConfigurables({ configurables });
 
   const { prefixedInputs: inputs, output } = func.attributes;
 
@@ -47,7 +45,7 @@ export function renderFactoryTemplate(params: { abi: Abi }) {
       hexlifiedBinString,
       capitalizedName,
       imports,
-      formattedConfigurables,
+      configurables,
       commonTypesInUse: commonTypesInUse.join(', '),
     },
   });

packages/abi-typegen/src/types/interfaces/IConfigurable.ts

@@ -1,8 +1,4 @@
-import type { IType } from './IType';
-import type { JsonAbiConfigurable } from './JsonAbi';
-
 export interface IConfigurable {
   name: string;
-  type: IType;
-  rawAbiConfigurable: JsonAbiConfigurable;
+  inputLabel: string;
 }

packages/abi-typegen/src/utils/getTypeDeclaration.ts

@@ -0,0 +1,31 @@
+import { TargetEnum } from '../types/enums/TargetEnum';
+import type { IType } from '../types/interfaces/IType';
+import type { JsonAbiArgument } from '../types/interfaces/JsonAbi';
+
+import { findType } from './findType';
+import { parseTypeArguments } from './parseTypeArguments';
+
+export function resolveInputLabel(
+  types: IType[],
+  typeId: number,
+  typeArguments: JsonAbiArgument['typeArguments']
+) {
+  const type = findType({ types, typeId });
+
+  let typeDecl: string;
+
+  if (typeArguments) {
+    // recursively process child `typeArguments`
+    typeDecl = parseTypeArguments({
+      types,
+      target: TargetEnum.INPUT,
+      parentTypeId: typeId,
+      typeArguments,
+    });
+  } else {
+    // or just collect type declaration
+    typeDecl = type.attributes.inputLabel;
+  }
+
+  return typeDecl;
+}