From d7ffc654015464d197844a917777bdce9814ae95 Mon Sep 17 00:00:00 2001 From: Valentin Fernandez <33705477+valentinfernandez1@users.noreply.github.com> Date: Wed, 29 Jan 2025 17:11:02 -0300 Subject: [PATCH] Fix typegen adding invalid imports (#6082) * ignore Unused types * add ignoreUnusedLookups to other generate functionalities * lint --- packages/typegen/src/generate/consts.ts | 10 +++++++++ packages/typegen/src/generate/events.ts | 17 +++++++++++++++- packages/typegen/src/generate/lookup.ts | 15 +++++++++++++- packages/typegen/src/generate/query.ts | 27 ++++++++++++++++--------- packages/typegen/src/generate/tx.ts | 10 +++++++++ 5 files changed, 67 insertions(+), 12 deletions(-) diff --git a/packages/typegen/src/generate/consts.ts b/packages/typegen/src/generate/consts.ts index 311068ba35..89e7ba3dc0 100644 --- a/packages/typegen/src/generate/consts.ts +++ b/packages/typegen/src/generate/consts.ts @@ -13,6 +13,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions'; import { stringCamelCase } from '@polkadot/util'; import { compareName, createImports, formatType, initMeta, readTemplate, setImports, writeFile } from '../util/index.js'; +import { ignoreUnusedLookups } from './lookup.js'; const generateForMetaTemplate = Handlebars.compile(readTemplate('consts')); @@ -34,6 +35,7 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs); }, {}); const { lookup, pallets, registry } = meta.asLatest; + const usedTypes = new Set([]); const modules = pallets .filter(({ constants }) => constants.length > 0) @@ -47,6 +49,11 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, const typeDef = lookup.getTypeDef(type); const returnType = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports); + // Add the type to the list of used types + if (!(imports.primitiveTypes[returnType])) { + usedTypes.add(returnType); + } + setImports(allDefs, imports, [returnType]); return { @@ -64,6 +71,9 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, }) .sort(compareName); + // filter out the unused lookup types from imports + ignoreUnusedLookups([...usedTypes], imports); + return generateForMetaTemplate({ headerType: 'chain', imports, diff --git a/packages/typegen/src/generate/events.ts b/packages/typegen/src/generate/events.ts index 9272b849ba..f292c7a862 100644 --- a/packages/typegen/src/generate/events.ts +++ b/packages/typegen/src/generate/events.ts @@ -13,6 +13,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions'; import { stringCamelCase } from '@polkadot/util'; import { compareName, createImports, formatType, initMeta, readTemplate, setImports, writeFile } from '../util/index.js'; +import { ignoreUnusedLookups } from './lookup.js'; const generateForMetaTemplate = Handlebars.compile(readTemplate('events')); @@ -78,6 +79,7 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs); }, {}); const { lookup, pallets, registry } = meta.asLatest; + const usedTypes = new Set([]); const modules = pallets .filter(({ events }) => events.isSome) .map(({ events, name }) => ({ @@ -85,7 +87,17 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, .map(({ docs, fields, name }) => { const args = fields .map(({ type }) => lookup.getTypeDef(type)) - .map((typeDef) => typeDef.lookupName || formatType(registry, allDefs, typeDef, imports)); + .map((typeDef) => { + const arg = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports); + + // Add the type to the list of used types + if (!(imports.primitiveTypes[arg])) { + usedTypes.add(arg); + } + + return arg; + }); + const names = fields .map(({ name }) => registry.lookup.sanitizeField(name)[0]) .filter((n): n is string => !!n); @@ -105,6 +117,9 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, })) .sort(compareName); + // filter out the unused lookup types from imports + ignoreUnusedLookups([...usedTypes], imports); + return generateForMetaTemplate({ headerType: 'chain', imports, diff --git a/packages/typegen/src/generate/lookup.ts b/packages/typegen/src/generate/lookup.ts index 47c0b305fb..76a9663889 100644 --- a/packages/typegen/src/generate/lookup.ts +++ b/packages/typegen/src/generate/lookup.ts @@ -16,7 +16,7 @@ import staticPolkadot from '@polkadot/types-support/metadata/v15/polkadot-hex'; import staticSubstrate from '@polkadot/types-support/metadata/v15/substrate-hex'; import { isString, stringify } from '@polkadot/util'; -import { createImports, exportInterface, initMeta, readTemplate, writeFile } from '../util/index.js'; +import { createImports, exportInterface, initMeta, readTemplate, type TypeImports, writeFile } from '../util/index.js'; import { typeEncoders } from './tsDef.js'; // Record @@ -275,3 +275,16 @@ export function generateDefaultLookup (destDir = 'packages/types-augment/src/loo ] ); } + +// Based on a list of types, it filters out the lookup types that are not needed. +export function ignoreUnusedLookups (usedTypes: string[], imports: TypeImports) { + const usedStringified = usedTypes.toString(); + + const [lookupKey, typeDefinitions] = Object.entries(imports.localTypes).find(([typeModule, _]) => typeModule.includes('/lookup')) || ['', {}]; + + Object.keys(typeDefinitions).forEach((typeDef) => { + if (!(usedStringified.includes(typeDef))) { + delete (imports.localTypes[lookupKey])[typeDef]; + } + }); +} diff --git a/packages/typegen/src/generate/query.ts b/packages/typegen/src/generate/query.ts index 1e074f7824..eee498dd77 100644 --- a/packages/typegen/src/generate/query.ts +++ b/packages/typegen/src/generate/query.ts @@ -5,8 +5,7 @@ import type { StorageEntryMetadataLatest } from '@polkadot/types/interfaces'; import type { Metadata, PortableRegistry } from '@polkadot/types/metadata'; import type { Definitions, Registry } from '@polkadot/types/types'; import type { HexString } from '@polkadot/util/types'; -import type { ModuleTypes } from '../util/imports.js'; -import type { TypeImports } from '../util/index.js'; +import type { ModuleTypes, TypeImports } from '../util/imports.js'; import type { ExtraTypes } from './types.js'; import Handlebars from 'handlebars'; @@ -17,6 +16,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions'; import { stringCamelCase } from '@polkadot/util'; import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js'; +import { ignoreUnusedLookups } from './lookup.js'; const generateForMetaTemplate = Handlebars.compile(readTemplate('query')); @@ -82,24 +82,28 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr ...extraTypes }; - // Incorrect type assignment in StagingXcmV4Xcm. - // Temporarily ignore this type to prevent import errors. - // - // See https://github.com/polkadot-js/api/issues/5977 - // for more details - const ignoreTypes = { types: { StagingXcmV4Xcm: undefined } }; - - const imports = createImports(allTypes, ignoreTypes); + const imports = createImports(allTypes); const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => { return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs); }, {}); const { lookup, pallets } = meta.asLatest; + const usedTypes = new Set([]); const modules = pallets .filter(({ storage }) => storage.isSome) .map(({ name, storage }) => { const items = storage.unwrap().items .map((storageEntry) => { const [isOptional, args, params, _returnType] = entrySignature(lookup, allDefs, registry, name.toString(), storageEntry, imports); + + // Add the type and args to the list of used types + if (!(imports.primitiveTypes[_returnType])) { + usedTypes.add(_returnType); + } + + if (!(imports.primitiveTypes[args])) { + usedTypes.add(args); + } + const returnType = isOptional ? `Option<${_returnType}>` : _returnType; @@ -124,6 +128,9 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr imports.typesTypes['Observable'] = true; + // filter out the unused lookup types from imports + ignoreUnusedLookups([...usedTypes], imports); + return generateForMetaTemplate({ headerType: 'chain', imports, diff --git a/packages/typegen/src/generate/tx.ts b/packages/typegen/src/generate/tx.ts index eb8426f530..00a123c141 100644 --- a/packages/typegen/src/generate/tx.ts +++ b/packages/typegen/src/generate/tx.ts @@ -14,6 +14,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions'; import { stringCamelCase } from '@polkadot/util'; import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js'; +import { ignoreUnusedLookups } from './lookup.js'; const MAPPED_NAMES: Record = { class: 'clazz', @@ -46,6 +47,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs); }, {}); const { lookup, pallets } = meta.asLatest; + const usedTypes = new Set([]); const modules = pallets .sort(compareName) .filter(({ calls }) => calls.isSome) @@ -76,6 +78,11 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr setImports(allDefs, imports, [typeStr, ...similarTypes]); + // Add the type to the list of used types + if (!(imports.primitiveTypes[typeStr])) { + usedTypes.add(typeStr); + } + return `${name}: ${similarTypes.join(' | ')}`; }) .join(', '); @@ -98,6 +105,9 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr }) .sort(compareName); + // filter out the unused lookup types from imports + ignoreUnusedLookups([...usedTypes], imports); + return generateForMetaTemplate({ headerType: 'chain', imports,