From 762b16ea13f18d869937c0515a2101a24b694b0a Mon Sep 17 00:00:00 2001 From: Xiliang Chen Date: Wed, 4 Dec 2019 10:04:41 +1300 Subject: [PATCH] make ts generate script more reusable (#1610) * make ts generate script more reusable * avoid use global definitions * fix error * fix formatting * seems working --- .../types/src/scripts/generateTypes/consts.ts | 9 +- .../generateTypes/interfaceRegistry.ts | 34 ++- .../types/src/scripts/generateTypes/query.ts | 45 ++-- .../types/src/scripts/generateTypes/rpc.ts | 13 +- .../types/src/scripts/generateTypes/tsDef.ts | 217 ++++++------------ packages/types/src/scripts/util/derived.ts | 48 ++-- packages/types/src/scripts/util/formatting.ts | 53 +++-- packages/types/src/scripts/util/imports.ts | 35 ++- 8 files changed, 221 insertions(+), 233 deletions(-) diff --git a/packages/types/src/scripts/generateTypes/consts.ts b/packages/types/src/scripts/generateTypes/consts.ts index 9118685568..6b42e694d5 100644 --- a/packages/types/src/scripts/generateTypes/consts.ts +++ b/packages/types/src/scripts/generateTypes/consts.ts @@ -3,6 +3,7 @@ // of the Apache-2.0 license. See the LICENSE file for details. import { ModuleMetadataLatest } from '../../interfaces/metadata'; +import * as definitions from '../../interfaces/definitions'; import fs from 'fs'; import staticData from '@polkadot/metadata/Metadata/static'; @@ -17,14 +18,14 @@ function generateModule (modul: ModuleMetadataLatest, imports: TypeImports): str return []; } - setImports(imports, ['Codec']); + setImports(definitions, imports, ['Codec']); return [indent(4)(`${stringCamelCase(modul.name.toString())}: {`)] .concat(indent(6)('[index: string]: Codec;')) .concat( modul.constants .map((constant): string => { - setImports(imports, [constant.type.toString()]); + setImports(definitions, imports, [constant.type.toString()]); return indent(6)(`${stringCamelCase(constant.name.toString())}: ${constant.type} & ConstantCodec;`); }) @@ -32,12 +33,12 @@ function generateModule (modul: ModuleMetadataLatest, imports: TypeImports): str .concat([indent(4)('};')]); } -// Generate `packages/types-jsonrpc/src/jsonrpc.types.ts` for a particular +// Generate `packages/api/src/consts.types.ts` for a particular // metadata function generateForMeta (meta: Metadata): void { console.log('Writing packages/api/src/consts.types.ts'); - const imports = createImports(); // Will hold all needed imports + const imports = createImports({ '@polkadot/types/interfaces': definitions }); // Will hold all needed imports const body = meta.asLatest.modules.reduce((acc, modul): string[] => { const storageEntries = generateModule(modul, imports); diff --git a/packages/types/src/scripts/generateTypes/interfaceRegistry.ts b/packages/types/src/scripts/generateTypes/interfaceRegistry.ts index 7d2964aa19..045e53a777 100644 --- a/packages/types/src/scripts/generateTypes/interfaceRegistry.ts +++ b/packages/types/src/scripts/generateTypes/interfaceRegistry.ts @@ -4,7 +4,7 @@ import fs from 'fs'; -import * as definitions from '../../interfaces/definitions'; +import * as defaultDefinitions from '../../interfaces/definitions'; import * as primitiveClasses from '../../primitive'; import { createImportCode, createImports, @@ -15,32 +15,34 @@ import { setImports } from '../util'; -// Generate `packages/types/src/interfaceRegistry.ts`, the registry of all interfaces -export default function generateInterfaceRegistry (): void { - console.log('Writing interfaceRegistry.ts'); +export function generateInterfaceRegistry (importDefinitions: { [importPath: string]: object }, output: string): void { + console.log(`Writing ${output}`); - const imports = createImports(); + Object.entries(importDefinitions).reduce((acc, def) => Object.assign(acc, def), {} as object); + + const imports = createImports(importDefinitions); + const definitions = imports.definitions; const primitives = Object .keys(primitiveClasses) .filter((name): boolean => !!name.indexOf('Generic')) .reduce((accumulator, primitiveName): string => { - setImports(imports, [primitiveName]); + setImports(definitions, imports, [primitiveName]); return [ accumulator, - getDerivedTypes(primitiveName, primitiveName, imports).map(indent(2)).join('\n') + getDerivedTypes(definitions, primitiveName, primitiveName, imports).map(indent(2)).join('\n') ].join('\n'); }, ''); // eslint-disable-next-line @typescript-eslint/no-unused-vars const srml = Object.entries(definitions).reduce((accumulator, [_defName, { types }]): string => { - setImports(imports, Object.keys(types)); + setImports(definitions, imports, Object.keys(types)); return [ accumulator, ...Object.keys(types).map((type): string => - getDerivedTypes(type, (types as any)[type], imports).map(indent(2)).join('\n') + getDerivedTypes(definitions, type, types[type], imports).map(indent(2)).join('\n') ) ].join('\n'); }, ''); @@ -55,7 +57,7 @@ export default function generateInterfaceRegistry (): void { types: Object.keys(imports.primitiveTypes) }, ...Object.keys(imports.localTypes).map((moduleName): { file: string; types: string[] } => ({ - file: `@polkadot/types/interfaces/${moduleName}`, + file: `${imports.moduleToPackage[moduleName]}/${moduleName}`, types: Object.keys(imports.localTypes[moduleName]) })) ]); @@ -64,8 +66,18 @@ export default function generateInterfaceRegistry (): void { const interfaceEnd = '\n}'; fs.writeFileSync( - 'packages/types/src/interfaceRegistry.ts', + output, header.concat(interfaceStart).concat(primitives).concat(srml).concat(interfaceEnd).concat(FOOTER) , { flag: 'w' } ); } + +// Generate `packages/types/src/interfaceRegistry.ts`, the registry of all interfaces +export default function generateDefaultInterfaceRegistry (): void { + generateInterfaceRegistry( + { + '@polkadot/types/interfaces': defaultDefinitions + }, + 'packages/types/src/interfaceRegistry.ts' + ); +} diff --git a/packages/types/src/scripts/generateTypes/query.ts b/packages/types/src/scripts/generateTypes/query.ts index 2e7797df80..90b2bbf222 100644 --- a/packages/types/src/scripts/generateTypes/query.ts +++ b/packages/types/src/scripts/generateTypes/query.ts @@ -4,6 +4,7 @@ import { ModuleMetadataLatest, StorageEntryMetadataLatest } from '../../interfaces/metadata'; import { Registry } from '../../types'; +import * as defaultDefinitions from '../../interfaces/definitions'; import fs from 'fs'; import staticData from '@polkadot/metadata/Metadata/static'; @@ -14,41 +15,41 @@ import { TypeRegistry } from '../../codec'; import { createImportCode, createImports, FOOTER, formatType, getSimilarTypes, HEADER, indent, setImports, TypeImports } from '../util'; // From a storage entry metadata, we return [args, returnType] -function entrySignature (registry: Registry, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [string, string] { +function entrySignature (definitions: object, registry: Registry, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [string, string] { if (storageEntry.type.isPlain) { - setImports(imports, [storageEntry.type.asPlain.toString()]); + setImports(definitions, imports, [storageEntry.type.asPlain.toString()]); - return ['', formatType(storageEntry.type.asPlain.toString(), imports)]; + return ['', formatType(definitions, storageEntry.type.asPlain.toString(), imports)]; } else if (storageEntry.type.isMap) { // Find similar types of the `key` type - const similarTypes = getSimilarTypes(registry, storageEntry.type.asMap.key.toString(), imports); + const similarTypes = getSimilarTypes(definitions, registry, storageEntry.type.asMap.key.toString(), imports); - setImports(imports, [ + setImports(definitions, imports, [ ...similarTypes, storageEntry.type.asMap.value.toString() ]); return [ - `arg: ${similarTypes.map((type) => formatType(type, imports)).join(' | ')}`, - formatType(storageEntry.type.asMap.value.toString(), imports) + `arg: ${similarTypes.map((type) => formatType(definitions, type, imports)).join(' | ')}`, + formatType(definitions, storageEntry.type.asMap.value.toString(), imports) ]; } else if (storageEntry.type.isDoubleMap) { // Find similartypes of `key1` and `key2` types - const similarTypes1 = getSimilarTypes(registry, storageEntry.type.asDoubleMap.key1.toString(), imports); - const similarTypes2 = getSimilarTypes(registry, storageEntry.type.asDoubleMap.key2.toString(), imports); + const similarTypes1 = getSimilarTypes(definitions, registry, storageEntry.type.asDoubleMap.key1.toString(), imports); + const similarTypes2 = getSimilarTypes(definitions, registry, storageEntry.type.asDoubleMap.key2.toString(), imports); - setImports(imports, [ + setImports(definitions, imports, [ ...similarTypes1, ...similarTypes2, storageEntry.type.asDoubleMap.value.toString() ]); - const key1Types = similarTypes1.map((type) => formatType(type, imports)).join(' | '); - const key2Types = similarTypes2.map((type) => formatType(type, imports)).join(' | '); + const key1Types = similarTypes1.map((type) => formatType(definitions, type, imports)).join(' | '); + const key2Types = similarTypes2.map((type) => formatType(definitions, type, imports)).join(' | '); return [ `key1: ${key1Types}, key2: ${key2Types}`, - formatType(storageEntry.type.asDoubleMap.value.toString(), imports) + formatType(definitions, storageEntry.type.asDoubleMap.value.toString(), imports) ]; } @@ -56,8 +57,8 @@ function entrySignature (registry: Registry, storageEntry: StorageEntryMetadataL } // Generate types for one storage entry in a module -function generateEntry (registry: Registry, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): string[] { - const [args, returnType] = entrySignature(registry, storageEntry, imports); +function generateEntry (definitions: object, registry: Registry, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): string[] { + const [args, returnType] = entrySignature(definitions, registry, storageEntry, imports); return [ `${stringLowerFirst(storageEntry.name.toString())}: StorageEntryExact Observable<${returnType}>> & QueryableStorageEntry;` @@ -65,7 +66,7 @@ function generateEntry (registry: Registry, storageEntry: StorageEntryMetadataLa } // Generate types for one module -function generateModule (registry: Registry, modul: ModuleMetadataLatest, imports: TypeImports): string[] { +function generateModule (definitions: object, registry: Registry, modul: ModuleMetadataLatest, imports: TypeImports): string[] { if (modul.storage.isNone) { return []; } @@ -75,22 +76,22 @@ function generateModule (registry: Registry, modul: ModuleMetadataLatest, import .concat( modul.storage.unwrap().items .reduce((acc, storageEntry): string[] => { - return acc.concat(generateEntry(registry, storageEntry, imports).map(indent(6))); + return acc.concat(generateEntry(definitions, registry, storageEntry, imports).map(indent(6))); }, [] as string[]) .join('\n') ) .concat([indent(4)('};')]); } -// Generate `packages/types-jsonrpc/src/jsonrpc.types.ts` for a particular +// Generate `packages/api/src/query.types.ts` for a particular // metadata -function generateForMeta (registry: Registry, meta: Metadata): void { +function generateForMeta (definitions: object, registry: Registry, meta: Metadata): void { console.log('Writing packages/api/src/query.types.ts'); - const imports = createImports(); // Will hold all needed imports + const imports = createImports({ '@polkadot/types/interfaces': definitions }); // Will hold all needed imports const body = meta.asLatest.modules.reduce((acc, modul): string[] => { - const storageEntries = generateModule(registry, modul, imports); + const storageEntries = generateModule(definitions, registry, modul, imports); return acc.concat(storageEntries); }, [] as string[]); @@ -140,5 +141,5 @@ function generateForMeta (registry: Registry, meta: Metadata): void { export default function generateQuery (): void { const registry = new TypeRegistry(); - return generateForMeta(registry, new Metadata(registry, staticData)); + return generateForMeta(defaultDefinitions, registry, new Metadata(registry, staticData)); } diff --git a/packages/types/src/scripts/generateTypes/rpc.ts b/packages/types/src/scripts/generateTypes/rpc.ts index 2a8505e6c5..47135b4a22 100644 --- a/packages/types/src/scripts/generateTypes/rpc.ts +++ b/packages/types/src/scripts/generateTypes/rpc.ts @@ -5,26 +5,27 @@ import fs from 'fs'; import interfaces from '../../../../type-jsonrpc/src'; +import * as definitions from '../../interfaces/definitions'; import { TypeRegistry } from '../../codec/create'; import { createImportCode, createImports, FOOTER, getSimilarTypes, HEADER, setImports } from '../util'; -// Generate `packages/types-jsonrpc/src/jsonrpc.types.ts` +// Generate `packages/rpc-core/jsonrpc.types.ts` export default function generateRpcTypes (): void { console.log('Writing packages/rpc-core/jsonrpc.types.ts'); const registry = new TypeRegistry(); - const imports = createImports(); + const imports = createImports({ '@polkadot/types/interfaces': definitions }); const body = Object.keys(interfaces).sort().reduce((allSections, section): string[] => { const allMethods = Object.keys(interfaces[section].methods).sort().map((key): string => { const method = interfaces[section].methods[key]; - setImports(imports, [method.type]); + setImports(definitions, imports, [method.type]); // FIXME These 2 are too hard to type, I give up if (section === 'state') { if (method.method === 'getStorage') { - setImports(imports, ['Codec']); + setImports(definitions, imports, ['Codec']); return ' getStorage(key: any, block?: Hash | Uint8Array | string): Observable;'; } else if (method.method === 'subscribeStorage') { return ' subscribeStorage(keys: any[]): Observable;'; @@ -32,8 +33,8 @@ export default function generateRpcTypes (): void { } const args = method.params.map((param): string => { - const similarTypes = getSimilarTypes(registry, param.type, imports); - setImports(imports, [param.type, ...similarTypes]); + const similarTypes = getSimilarTypes(definitions, registry, param.type, imports); + setImports(definitions, imports, [param.type, ...similarTypes]); return `${param.name}${param.isOptional ? '?' : ''}: ${similarTypes.join(' | ')}`; }); diff --git a/packages/types/src/scripts/generateTypes/tsDef.ts b/packages/types/src/scripts/generateTypes/tsDef.ts index 49b14fa78a..b12a68a4aa 100644 --- a/packages/types/src/scripts/generateTypes/tsDef.ts +++ b/packages/types/src/scripts/generateTypes/tsDef.ts @@ -5,59 +5,47 @@ import { TypeDef, TypeDefInfo, TypeDefExtVecFixed } from '../../codec/types'; import fs from 'fs'; +import path from 'path'; import { isString, stringCamelCase, stringUpperFirst } from '@polkadot/util'; import { getTypeDef } from '../../codec/create'; -import * as definitions from '../../interfaces/definitions'; -import { createImportCode, createImports, exportInterface, exportType, formatBTreeMap, formatCompact, formatOption, formatResult, formatTuple, formatVec, FOOTER, HEADER, setImports, TypeImports } from '../util'; +import * as defaultDefinitions from '../../interfaces/definitions'; +import { createImportCode, createImports, exportInterface, exportType, formatType, FOOTER, HEADER, setImports, TypeImports } from '../util'; interface Imports extends TypeImports { interfaces: [string, string][]; } // helper to generate a `readonly : ;` getter -export function createGetter (name = '', type: string, imports: TypeImports, doc?: string): string { - setImports(imports, [type]); +export function createGetter (definitions: object, name = '', type: string, imports: TypeImports, doc?: string): string { + setImports(definitions, imports, [type]); return ` /** ${doc || type} */\n readonly ${name}: ${type};\n`; } // eslint-disable-next-line @typescript-eslint/no-unused-vars -function errorUnhandled (def: TypeDef, imports: TypeImports): string { +function errorUnhandled (definitions: object, def: TypeDef, imports: TypeImports): string { throw new Error(`Generate: ${name}: Unhandled type ${TypeDefInfo[def.info]}`); } -function tsBTreeMap ({ name: resultName, sub, type }: TypeDef, imports: TypeImports): string { - const [keyDef, valDef] = (sub as TypeDef[]); - - setImports(imports, [type]); - - return exportInterface(resultName, formatBTreeMap(keyDef.type, valDef.type)); +function tsExport (definitions: object, def: TypeDef, imports: TypeImports): string { + return exportInterface(def.name, formatType(definitions, def, imports)); } -function tsCompact ({ name: compactName, sub }: TypeDef, imports: TypeImports): string { - const def = (sub as TypeDef); +const tsBTreeMap = tsExport; +const tsCompact = tsExport; +const tsOption = tsExport; +const tsPlain = tsExport; +const tsTuple = tsExport; - setImports(imports, ['Compact']); - - switch (def.info) { - case TypeDefInfo.Plain: - setImports(imports, [def.type]); - return exportType(compactName, formatCompact(def.type)); - - default: - throw new Error(`Enum: ${compactName}: Unhandled type ${TypeDefInfo[def.info]}`); - } -} - -function tsEnum ({ name: enumName, sub }: TypeDef, imports: TypeImports): string { - setImports(imports, ['Enum']); +function tsEnum (definitions: object, { name: enumName, sub }: TypeDef, imports: TypeImports): string { + setImports(definitions, imports, ['Enum']); const keys = (sub as TypeDef[]).map(({ info, name = '', type }, index): string => { const getter = stringUpperFirst(stringCamelCase(name.replace(' ', '_'))); const [enumType, asGetter] = type === 'Null' ? ['', ''] - : [`(${type})`, createGetter(`as${getter}`, type, imports)]; - const isGetter = createGetter(`is${getter}`, 'boolean', imports, `${index}:: ${name}${enumType}`); + : [`(${type})`, createGetter(definitions, `as${getter}`, type, imports)]; + const isGetter = createGetter(definitions, `is${getter}`, 'boolean', imports, `${index}:: ${name}${enumType}`); switch (info) { case TypeDefInfo.Plain: @@ -72,32 +60,11 @@ function tsEnum ({ name: enumName, sub }: TypeDef, imports: TypeImports): string return exportInterface(enumName, 'Enum', keys.join('')); } -function tsOption ({ name: optionName, sub }: TypeDef, imports: TypeImports): string { - const def = (sub as TypeDef); - - setImports(imports, ['Option']); - - switch (def.info) { - case TypeDefInfo.Plain: - setImports(imports, [def.type]); - return exportType(optionName, formatOption(def.type)); - - default: - throw new Error(`Enum: ${optionName}: Unhandled type ${TypeDefInfo[def.info]}`); - } -} - -function tsPlain ({ name: plainName, type }: TypeDef, imports: TypeImports): string { - setImports(imports, [type]); - - return exportType(plainName, type); -} - -function tsResultGetter (resultName = '', getter: 'Ok' | 'Error', { info, name = '', type }: TypeDef, imports: TypeImports): string { +function tsResultGetter (definitions: object, resultName = '', getter: 'Ok' | 'Error', { info, name = '', type }: TypeDef, imports: TypeImports): string { const [resultType, asGetter] = type === 'Null' ? ['', ''] - : [`(${type})`, createGetter(`as${getter}`, type, imports)]; - const isGetter = createGetter(`is${getter}`, 'boolean', imports, `${getter}:: ${name}${resultType}`); + : [`(${type})`, createGetter(definitions, `as${getter}`, type, imports)]; + const isGetter = createGetter(definitions, `is${getter}`, 'boolean', imports, `${getter}:: ${name}${resultType}`); switch (info) { case TypeDefInfo.Plain: @@ -109,119 +76,57 @@ function tsResultGetter (resultName = '', getter: 'Ok' | 'Error', { info, name = } } -function tsResult ({ name: resultName, sub, type }: TypeDef, imports: TypeImports): string { - const [okDef, errorDef] = (sub as TypeDef[]); +function tsResult (definitions: object, def: TypeDef, imports: TypeImports): string { + const [okDef, errorDef] = (def.sub as TypeDef[]); const inner = [ - tsResultGetter(resultName, 'Error', errorDef, imports), - tsResultGetter(resultName, 'Ok', okDef, imports) + tsResultGetter(definitions, def.name, 'Error', errorDef, imports), + tsResultGetter(definitions, def.name, 'Ok', okDef, imports) ].join(''); - setImports(imports, [type]); + setImports(definitions, imports, [def.type]); - return exportInterface(resultName, formatResult(okDef.type, errorDef.type), inner); + return exportInterface(def.name, formatType(definitions, def, imports), inner); } -function _tsStructGetterType (structName: string | undefined, { info, sub, type }: TypeDef, imports: TypeImports): [string, string] { - let _type; - - switch (info) { - case TypeDefInfo.Compact: - _type = (sub as TypeDef).type; - - setImports(imports, ['Compact']); - - return [_type, formatCompact(_type)]; - - case TypeDefInfo.Option: - _type = (sub as TypeDef).type; - - setImports(imports, ['Option']); - - return [_type, formatOption(_type)]; - - case TypeDefInfo.Plain: - return [type, type]; - - case TypeDefInfo.Vec: - _type = (sub as TypeDef).type; - - setImports(imports, ['Vec']); - - return [_type, formatVec(_type)]; - - default: - throw new Error(`Struct: ${structName}: Unhandled type ${TypeDefInfo[info]}`); - } -} - -function tsSet ({ name: setName, sub }: TypeDef, imports: TypeImports): string { - setImports(imports, ['Set']); +function tsSet (definitions: object, { name: setName, sub }: TypeDef, imports: TypeImports): string { + setImports(definitions, imports, ['Set']); const types = (sub as TypeDef[]).map(({ name }): string => - createGetter(`is${name}`, 'boolean', imports) + createGetter(definitions, `is${name}`, 'boolean', imports) ); return exportInterface(setName, 'Set', types.join('')); } -function tsStruct ({ name: structName, sub }: TypeDef, imports: TypeImports): string { +function tsStruct (definitions: object, { name: structName, sub }: TypeDef, imports: TypeImports): string { + setImports(definitions, imports, ['Struct']); + const keys = (sub as TypeDef[]).map((typedef): string => { - const [embedType, returnType] = _tsStructGetterType(structName, typedef, imports); + const returnType = formatType(definitions, typedef, imports); - setImports(imports, ['Struct', embedType]); - - return createGetter(typedef.name, returnType, imports); + return createGetter(definitions, typedef.name, returnType, imports); }); return exportInterface(structName, 'Struct', keys.join('')); } -function _tsTupleGetterType (tupleName: string | undefined, { info, sub, type }: TypeDef, imports: TypeImports): string { - switch (info) { - case TypeDefInfo.Option: - setImports(imports, ['Option', (sub as TypeDef).type]); - - return type; - - case TypeDefInfo.Plain: - setImports(imports, [type]); - - return type; - - default: - throw new Error(`Struct: ${tupleName}: Unhandled type ${TypeDefInfo[info]}`); - } -} - -function tsTuple ({ name: tupleName, sub }: TypeDef, imports: TypeImports): string { - setImports(imports, ['ITuple']); - - const types = (sub as TypeDef[]).map((typedef): string => - _tsTupleGetterType(tupleName, typedef, imports) - ); - - return exportType(tupleName, formatTuple(types)); -} - -function tsVec ({ ext, info, name: vectorName, sub }: TypeDef, imports: TypeImports): string { - const type = info === TypeDefInfo.VecFixed - ? (ext as TypeDefExtVecFixed).type - : (sub as TypeDef).type; +function tsVec (definitions: object, def: TypeDef, imports: TypeImports): string { + const type = def.info === TypeDefInfo.VecFixed + ? (def.ext as TypeDefExtVecFixed).type + : (def.sub as TypeDef).type; // FIXME This should be a VecFixed // FIXME Technically Vec has length prefix, so for others this is not 100% - if (info === TypeDefInfo.VecFixed && type === 'u8') { - setImports(imports, ['Codec']); + if (def.info === TypeDefInfo.VecFixed && type === 'u8') { + setImports(definitions, imports, ['Codec']); - return exportType(vectorName, 'Uint8Array, Codec'); + return exportType(def.name, 'Uint8Array, Codec'); } - setImports(imports, ['Vec', type]); - - return exportType(vectorName, formatVec(type)); + return exportInterface(def.name, formatType(definitions, def, imports)); } -function generateInterfaces ({ types }: { types: Record }, imports: Imports): [string, string][] { +function generateInterfaces (definitions: object, { types }: { types: Record }, imports: Imports): [string, string][] { // handlers are defined externally to use - this means that when we do a // `generators[typedef.info](...)` TS will show any unhandled types. Rather // we are being explicit in having no handlers where we do not support (yet) @@ -244,13 +149,14 @@ function generateInterfaces ({ types }: { types: Record }, imports: return Object.entries(types).map(([name, type]): [string, string] => { const def = getTypeDef(isString(type) ? type.toString() : JSON.stringify(type), { name }); - return [name, generators[def.info](def, imports)]; + return [name, generators[def.info](definitions, def, imports)]; }); } -function generateTsDefFor (defName: string, { types }: { types: Record }): void { - const imports = { ...createImports({ types }), interfaces: [] } as Imports; - const interfaces = generateInterfaces({ types }, imports); +function generateTsDefFor (importDefinitions: { [importPath: string]: object }, defName: string, { types }: { types: Record }, outputDir: string): void { + const imports = { ...createImports(importDefinitions, { types }), interfaces: [] } as Imports; + const definitions = imports.definitions; + const interfaces = generateInterfaces(definitions, { types }, imports); const sortedDefs = interfaces.sort((a, b): number => a[0].localeCompare(b[0])).map(([, definition]): string => definition).join('\n\n'); const header = createImportCode(HEADER, [ @@ -267,7 +173,7 @@ function generateTsDefFor (defName: string, { types }: { types: Record ({ - file: `@polkadot/types/interfaces/${moduleName}`, + file: `${imports.moduleToPackage[moduleName]}/${moduleName}`, types: Object.keys(imports.localTypes[moduleName]) })) ]); @@ -280,19 +186,30 @@ function generateTsDefFor (defName: string, { types }: { types: Record { console.log(`Extracting interfaces for ${defName}`); - generateTsDefFor(defName, obj); + generateTsDefFor(importDefinitions, defName, obj, outputDir); }); - console.log('Writing interfaces/types.ts'); + console.log(`Writing ${outputDir}`); - fs.writeFileSync('packages/types/src/interfaces/types.ts', HEADER.concat(Object.keys(definitions).map((moduleName): string => `export * from './${moduleName}/types';`).join('\n')).concat(FOOTER), { flag: 'w' }); - fs.writeFileSync('packages/types/src/interfaces/index.ts', HEADER.concat('export * from \'./types\';').concat(FOOTER), { flag: 'w' }); + fs.writeFileSync(path.join(outputDir, 'types.ts'), HEADER.concat(Object.keys(definitions).map((moduleName): string => `export * from './${moduleName}/types';`).join('\n')).concat(FOOTER), { flag: 'w' }); + fs.writeFileSync(path.join(outputDir, 'index.ts'), HEADER.concat('export * from \'./types\';').concat(FOOTER), { flag: 'w' }); +} + +export default function generateTsDefDefault (): void { + generateTsDef( + { + '@polkadot/types/interfaces': defaultDefinitions + }, + 'packages/types/src/interfaces', + '@polkadot/types/interfaces' + ); } diff --git a/packages/types/src/scripts/util/derived.ts b/packages/types/src/scripts/util/derived.ts index 0399a4b628..630f7540fa 100644 --- a/packages/types/src/scripts/util/derived.ts +++ b/packages/types/src/scripts/util/derived.ts @@ -2,48 +2,64 @@ // This software may be modified and distributed under the terms // of the Apache-2.0 license. See the LICENSE file for details. -import { TypeDef } from '../../codec/types'; +import { TypeDef, TypeDefInfo } from '../../codec/types'; import { Constructor, Registry } from '../../types'; import { isChildClass, isCompactEncodable } from './class'; import { ClassOfUnsafe, getTypeDef } from '../../codec/create'; import AbstractInt from '../../codec/AbstractInt'; import Vec from '../../codec/Vec'; -import { formatCompact, formatOption, formatVec } from './formatting'; +import { formatType } from './formatting'; import { setImports, TypeImports } from './imports'; import * as primitiveClasses from '../../primitive'; // From `T`, generate `Compact, Option, Vec` -export function getDerivedTypes (type: string, primitiveName: string, imports: TypeImports): string[] { +export function getDerivedTypes (definitions: object, type: string, primitiveName: string, imports: TypeImports): string[] { // `primitiveName` represents the actual primitive type our type is mapped to const isCompact = isCompactEncodable((primitiveClasses as any)[primitiveName]); + const def = getTypeDef(type); - setImports(imports, ['Option', 'Vec', isCompact ? 'Compact' : '']); + setImports(definitions, imports, ['Option', 'Vec', isCompact ? 'Compact' : '']); - return [ - `${type}: ${type};`, - isCompact - ? `'${formatCompact(type)}': ${formatCompact(type)};` - : '', - `'${formatOption(type)}': ${formatOption(type)};`, - `'${formatVec(type)}': ${formatVec(type)};` - ] - .filter((x): boolean => !!x); + const types = [ + { + info: TypeDefInfo.Option, + type, + sub: def + }, + { + info: TypeDefInfo.Vec, + type, + sub: def + } + ]; + if (isCompact) { + types.unshift({ + info: TypeDefInfo.Compact, + type, + sub: def + }); + } + + const result = types.map(t => formatType(definitions, t, imports)).map(t => `'${t}': ${t};`); + result.unshift(`${type}: ${type};`); + + return result; } // Make types a little bit more flexible // - if param instanceof AbstractInt, then param: u64 | Uint8array | string | number // etc -export function getSimilarTypes (registry: Registry, type: string, imports: TypeImports): string[] { +export function getSimilarTypes (definitions: object, registry: Registry, type: string, imports: TypeImports): string[] { const possibleTypes = [type]; if (type === 'Extrinsic') { - setImports(imports, ['IExtrinsic']); + setImports(definitions, imports, ['IExtrinsic']); return ['IExtrinsic']; } if (isChildClass(Vec, ClassOfUnsafe(registry, type))) { - return [`(${getSimilarTypes(registry, ((getTypeDef(type).sub) as TypeDef).type, imports).join(' | ')})[]`]; + return [`(${getSimilarTypes(definitions, registry, ((getTypeDef(type).sub) as TypeDef).type, imports).join(' | ')})[]`]; } // FIXME This is a hack, it's hard to correctly type StorageKeys in the diff --git a/packages/types/src/scripts/util/formatting.ts b/packages/types/src/scripts/util/formatting.ts index 0a6e1f0889..ddab706b20 100644 --- a/packages/types/src/scripts/util/formatting.ts +++ b/packages/types/src/scripts/util/formatting.ts @@ -2,7 +2,7 @@ // This software may be modified and distributed under the terms // of the Apache-2.0 license. See the LICENSE file for details. -import { TypeDef, TypeDefInfo } from '../../codec/types'; +import { TypeDef, TypeDefInfo, TypeDefExtVecFixed } from '../../codec/types'; import { getTypeDef } from '../../codec/create'; import { paramsNotation } from '../../codec/utils'; @@ -37,83 +37,102 @@ export function exportType (name = '', base: string): string { /** * Given the inner `K` & `V`, return a `BTreeMap` string */ -export function formatBTreeMap (key: string, val: string): string { +function formatBTreeMap (key: string, val: string): string { return `BTreeMap<${key}, ${val}>`; } /** * Given the inner `T`, return a `Compact` string */ -export function formatCompact (inner: string): string { +function formatCompact (inner: string): string { return paramsNotation('Compact', inner); } /** * Given the inner `O` & `E`, return a `Result` string */ -export function formatResult (innerOk: string, innerError: string): string { +function formatResult (innerOk: string, innerError: string): string { return `Result<${innerOk}, ${innerError}>`; } /** * Given the inner `T`, return a `Option` string */ -export function formatOption (inner: string): string { +function formatOption (inner: string): string { return paramsNotation('Option', inner); } /** * Given the inners `T[]`, return a `ITuple<...T>` string */ -export function formatTuple (inners: string[]): string { +function formatTuple (inners: string[]): string { return paramsNotation('ITuple', `[${inners.join(', ')}]`); } /** * Given the inner `T`, return a `Vec` string */ -export function formatVec (inner: string): string { +function formatVec (inner: string): string { return paramsNotation('Vec', inner); } /** * Correctly format a given type */ -export function formatType (type: string | TypeDef, imports: TypeImports): string { - let typeDef; +export function formatType (definitions: object, type: string | TypeDef, imports: TypeImports): string { + let typeDef: TypeDef; if (typeof type === 'string') { typeDef = getTypeDef(type); } else { typeDef = type; } + setImports(definitions, imports, [typeDef.type]); + switch (typeDef.info) { case TypeDefInfo.Compact: { - return formatCompact(formatType((typeDef.sub as TypeDef).type, imports)); + setImports(definitions, imports, ['Compact']); + return formatCompact(formatType(definitions, (typeDef.sub as TypeDef).type, imports)); } case TypeDefInfo.Option: { - return formatOption(formatType((typeDef.sub as TypeDef).type, imports)); + setImports(definitions, imports, ['Option']); + return formatOption(formatType(definitions, (typeDef.sub as TypeDef).type, imports)); } case TypeDefInfo.Plain: { return typeDef.type; } case TypeDefInfo.Vec: { - return formatVec(formatType((typeDef.sub as TypeDef).type, imports)); + setImports(definitions, imports, ['Vec']); + return formatVec(formatType(definitions, (typeDef.sub as TypeDef).type, imports)); } case TypeDefInfo.Tuple: { - setImports(imports, ['ITuple']); + setImports(definitions, imports, ['ITuple']); // `(a,b)` gets transformed into `ITuple<[a, b]>` return formatTuple( ((typeDef.sub as TypeDef[]) - .map((sub): string => formatType(sub.type, imports))) + .map((sub): string => formatType(definitions, sub.type, imports))) ); } case TypeDefInfo.VecFixed: { - setImports(imports, ['U8a']); + if ((typeDef.ext as TypeDefExtVecFixed).type === 'u8') { + setImports(definitions, imports, ['U8a']); - // `[u8, 32]` gets transformed into U8a - return 'U8a'; + // `[u8, 32]` gets transformed into U8a + return 'U8a'; + } + setImports(definitions, imports, ['Vec']); + return formatVec(formatType(definitions, (typeDef.ext as TypeDefExtVecFixed).type, imports)); + } + case TypeDefInfo.BTreeMap: { + setImports(definitions, imports, ['BTreeMap']); + const [keyDef, valDef] = (typeDef.sub as TypeDef[]); + return formatBTreeMap(formatType(definitions, keyDef.type, imports), formatType(definitions, valDef.type, imports)); + } + case TypeDefInfo.Result: { + setImports(definitions, imports, ['Result']); + const [okDef, errorDef] = (typeDef.sub as TypeDef[]); + return formatResult(formatType(definitions, okDef.type, imports), formatType(definitions, errorDef.type, imports)); } default: { throw new Error(`Cannot format ${type}.`); diff --git a/packages/types/src/scripts/util/imports.ts b/packages/types/src/scripts/util/imports.ts index 3622e53759..8ae5cc9758 100644 --- a/packages/types/src/scripts/util/imports.ts +++ b/packages/types/src/scripts/util/imports.ts @@ -5,7 +5,6 @@ import * as codecClasses from '../../codec'; import { getTypeDef } from '../../codec/create'; import { TypeDefInfo } from '../../codec/types'; -import * as definitions from '../../interfaces/definitions'; import * as primitiveClasses from '../../primitive'; // these map all the codec and primitive types for import, see the TypeImports below. If @@ -22,11 +21,14 @@ export interface TypeImports { ignoredTypes: string[]; // No need to import these types primitiveTypes: TypeExist; // `import {} from '@polkadot/types/primitive` typesTypes: TypeExist; // `import {} from '@polkadot/types/types` + definitions: object; // all definitions + typeToModule: Record; + moduleToPackage: Record; } // Maps the types as found to the source location. This is used to generate the // imports in the output file, dep-duped and sorted -export function setImports (imports: TypeImports, types: string[]): void { +export function setImports (definitions: object, imports: TypeImports, types: string[]): void { const { codecTypes, localTypes, ignoredTypes, primitiveTypes, typesTypes } = imports; types.forEach((type): void => { @@ -42,14 +44,14 @@ export function setImports (imports: TypeImports, types: string[]): void { // If the type is a bit special (tuple, fixed u8, nested type...), then we // need to parse it with `getTypeDef`. const typeDef = getTypeDef(type); - setImports(imports, [TypeDefInfo[typeDef.info]]); + setImports(definitions, imports, [TypeDefInfo[typeDef.info]]); // TypeDef.sub is a `TypeDef | TypeDef[]` if (Array.isArray(typeDef.sub)) { - typeDef.sub.forEach((subType): void => setImports(imports, [subType.type])); + typeDef.sub.forEach((subType): void => setImports(definitions, imports, [subType.type])); } else if (typeDef.sub) { // typeDef.sub is a TypeDef in this case - setImports(imports, [typeDef.sub.type]); + setImports(definitions, imports, [typeDef.sub.type]); } } else { // find this module inside the exports from the rest @@ -65,7 +67,26 @@ export function setImports (imports: TypeImports, types: string[]): void { } // Create an Imports object, can be prefilled with `ignoredTypes` -export function createImports ({ types }: { types: Record } = { types: {} }): TypeImports { +export function createImports (importDefinitions: { [importPath: string]: object }, { types }: { types: Record } = { types: {} }): TypeImports { + const definitions = {} as Record; + const typeToModule = {} as Record; + const moduleToPackage = {} as Record; + for (const [packagePath, packageDef] of Object.entries(importDefinitions)) { + for (const [name, moduleDef] of Object.entries(packageDef)) { + if (definitions[name]) { + throw new Error(`Duplicated module: ${name}. Packages: ${packagePath}, ${moduleToPackage[name]}`); + } + definitions[name] = moduleDef; + moduleToPackage[name] = packagePath; + for (const type of Object.keys(moduleDef.types)) { + if (typeToModule[type]) { + throw new Error(`Duplicated type: ${type}. Modules: ${name}, ${typeToModule[type]}`); + } + typeToModule[type] = name; + } + } + } + const codecTypes: TypeExist = {}; const localTypes: TypeExistMap = Object.keys(definitions).reduce((localTypes: Record, moduleName): Record => { localTypes[moduleName] = {}; @@ -76,7 +97,7 @@ export function createImports ({ types }: { types: Record } = { typ const primitiveTypes: TypeExist = {}; const typesTypes: TypeExist = {}; - const imports = { codecTypes, localTypes, ignoredTypes, primitiveTypes, typesTypes }; + const imports = { codecTypes, localTypes, ignoredTypes, primitiveTypes, typesTypes, definitions, typeToModule, moduleToPackage }; return imports; }