@dedot/codegen 0.0.1-alpha.22

package/generator/ApiGen.d.ts

@@ -0,0 +1,138 @@
+import { TypesGen } from '../generator';
+export declare abstract class ApiGen {
+    readonly typesGen: TypesGen;
+    constructor(typesGen: TypesGen);
+    get metadata(): {
+        types: {
+            id: number;
+            path: string[];
+            params: {
+                name: string;
+                typeId: number | undefined;
+            }[];
+            type: {
+                tag: "Struct";
+                value: {
+                    fields: import("@dedot/codecs").Field[];
+                };
+            } | {
+                tag: "Enum";
+                value: {
+                    members: {
+                        name: string;
+                        fields: import("@dedot/codecs").Field[];
+                        index: number;
+                        docs: string[];
+                    }[];
+                };
+            } | {
+                tag: "Sequence";
+                value: {
+                    typeParam: number;
+                };
+            } | {
+                tag: "SizedVec";
+                value: {
+                    len: number;
+                    typeParam: number;
+                };
+            } | {
+                tag: "Tuple";
+                value: {
+                    fields: number[];
+                };
+            } | {
+                tag: "Primitive";
+                value: {
+                    kind: "bool" | "char" | "str" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "i8" | "i16" | "i32" | "i64" | "i128" | "i256";
+                };
+            } | {
+                tag: "Compact";
+                value: {
+                    typeParam: number;
+                };
+            } | {
+                tag: "BitSequence";
+                value: {
+                    bitOrderType: number;
+                    bitStoreType: number;
+                };
+            };
+            docs: string[];
+        }[];
+        pallets: {
+            name: string;
+            storage: {
+                prefix: string;
+                entries: {
+                    name: string;
+                    modifier: string;
+                    type: {
+                        tag: "Plain";
+                        value: {
+                            valueTypeId: number;
+                        };
+                    } | {
+                        tag: "Map";
+                        value: {
+                            hashers: ("identity" | "blake2_128" | "blake2_256" | "blake2_128Concat" | "twox128" | "twox256" | "twox64Concat")[];
+                            keyTypeId: number;
+                            valueTypeId: number;
+                        };
+                    };
+                    default: `0x${string}`;
+                    docs: string[];
+                }[];
+            } | undefined;
+            calls: number | undefined;
+            event: number | undefined;
+            constants: {
+                name: string;
+                typeId: number;
+                value: `0x${string}`;
+                docs: string[];
+            }[];
+            error: number | undefined;
+            index: number;
+            docs: string[];
+        }[];
+        extrinsic: {
+            version: number;
+            addressTypeId: number;
+            callTypeId: number;
+            signatureTypeId: number;
+            extraTypeId: number;
+            signedExtensions: {
+                ident: string;
+                typeId: number;
+                additionalSigned: number;
+            }[];
+        };
+        runtimeType: number;
+        apis: {
+            name: string;
+            methods: {
+                name: string;
+                inputs: {
+                    name: string;
+                    typeId: number;
+                }[];
+                output: number;
+                docs: string[];
+            }[];
+            docs: string[];
+        }[];
+        outerEnums: {
+            callEnumTypeId: number;
+            eventEnumTypeId: number;
+            errorEnumTypeId: number;
+        };
+        custom: {
+            map: ReadonlyMap<string, {
+                typeId: number;
+                value: `0x${string}`;
+            }>;
+        };
+    };
+    get registry(): import("@dedot/codecs").CodecRegistry;
+}

package/generator/ApiGen.js

@@ -0,0 +1,12 @@
+export class ApiGen {
+    typesGen;
+    constructor(typesGen) {
+        this.typesGen = typesGen;
+    }
+    get metadata() {
+        return this.typesGen.metadata;
+    }
+    get registry() {
+        return this.typesGen.registry;
+    }
+}

package/generator/ConstsGen.d.ts

@@ -0,0 +1,4 @@
+import { ApiGen } from '../generator';
+export declare class ConstsGen extends ApiGen {
+    generate(): Promise<string>;
+}

package/generator/ConstsGen.js

@@ -0,0 +1,28 @@
+import { stringLowerFirst } from '@polkadot/util';
+import { normalizeName } from '@dedot/utils';
+import { ApiGen } from '../generator';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+export class ConstsGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainConsts');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const typedConstants = pallet.constants.map((one) => ({
+                name: normalizeName(one.name),
+                type: this.typesGen.generateType(one.typeId, 1, true),
+                docs: one.docs,
+            }));
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s constants`);
+            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+        ${typedConstants.map(({ name, type, docs }) => `${commentBlock(docs)}${name}: ${type}`).join(',\n')}
+          
+        ${commentBlock('Generic pallet constant')}[name: string]: any,
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('consts.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+}

package/generator/ErrorsGen.d.ts

@@ -0,0 +1,5 @@
+import { ApiGen } from './ApiGen';
+export declare class ErrorsGen extends ApiGen {
+    #private;
+    generate(): Promise<string>;
+}

package/generator/ErrorsGen.js

@@ -0,0 +1,37 @@
+import { ApiGen } from './ApiGen';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { stringCamelCase, stringPascalCase } from '@polkadot/util';
+import { assert } from '@dedot/utils';
+export class ErrorsGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const errorTypeId = pallet.error;
+            if (!errorTypeId) {
+                continue;
+            }
+            const errorDefs = this.#getErrorDefs(errorTypeId);
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s errors`);
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
+        ${errorDefs
+                .map(({ name, docs }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletError`)
+                .join(',\n')}
+          
+        ${commentBlock('Generic pallet error')}[error: string]: GenericPalletError,
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('errors.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    #getErrorDefs(errorTypeId) {
+        const def = this.metadata.types[errorTypeId];
+        assert(def, `Error def not found for id ${errorTypeId}`);
+        const { tag, value } = def.type;
+        assert(tag === 'Enum', `Invalid pallet error type!`);
+        return value.members;
+    }
+}

package/generator/EventsGen.d.ts

@@ -0,0 +1,5 @@
+import { ApiGen } from './ApiGen';
+export declare class EventsGen extends ApiGen {
+    #private;
+    generate(): Promise<string>;
+}

package/generator/EventsGen.js

@@ -0,0 +1,64 @@
+import { ApiGen } from './ApiGen';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { stringCamelCase, stringPascalCase } from '@polkadot/util';
+import { assert } from '@dedot/utils';
+export class EventsGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const eventTypeId = pallet.event;
+            if (!eventTypeId) {
+                continue;
+            }
+            const eventDefs = this.#getEventDefs(eventTypeId);
+            const flatMembers = eventDefs.every((d) => d.fields.length === 0);
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s events`);
+            defTypeOut += `${stringCamelCase(pallet.name)}: {
+        ${eventDefs
+                .map((def) => {
+                const genericParts = [`'${pallet.name}'`, `'${def.name}'`];
+                const eventDataPart = this.#generateMemberDefType(def.fields);
+                if (eventDataPart) {
+                    genericParts.push(eventDataPart);
+                }
+                else {
+                    genericParts.push(flatMembers ? 'undefined' : 'null');
+                }
+                return { ...def, genericParts };
+            })
+                .map(({ name, docs, fields, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
+                .join(',\n')}
+          
+        ${commentBlock('Generic pallet event')}[prop: string]: GenericPalletEvent,
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('events.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    #getEventDefs(typeId) {
+        const def = this.metadata.types[typeId];
+        assert(def, `Event def not found for id ${typeId}`);
+        const { tag, value } = def.type;
+        assert(tag === 'Enum', 'Invalid pallet event type!');
+        return value.members;
+    }
+    #generateMemberDefType(fields) {
+        if (fields.length === 0) {
+            return null;
+        }
+        else if (fields[0].name === undefined) {
+            return fields.length === 1
+                ? this.typesGen.generateType(fields[0].typeId, 1, true)
+                : `[${fields
+                    .map(({ typeId, docs }) => `${commentBlock(docs)}${this.typesGen.generateType(typeId, 1, true)}`)
+                    .join(', ')}]`;
+        }
+        else {
+            return this.typesGen.generateObjectType(fields, 1, true);
+        }
+    }
+}

package/generator/IndexGen.d.ts

@@ -0,0 +1,6 @@
+import { NetworkInfo } from '../types';
+export declare class IndexGen {
+    readonly networkInfo: NetworkInfo;
+    constructor(networkInfo: NetworkInfo);
+    generate(): Promise<string>;
+}

package/generator/IndexGen.js

@@ -0,0 +1,14 @@
+import { beautifySourceCode, compileTemplate } from './utils';
+import { stringPascalCase } from '@polkadot/util';
+export class IndexGen {
+    networkInfo;
+    constructor(networkInfo) {
+        this.networkInfo = networkInfo;
+    }
+    async generate() {
+        const { chain } = this.networkInfo;
+        const interfaceName = stringPascalCase(chain);
+        const template = compileTemplate('index.hbs');
+        return beautifySourceCode(template({ interfaceName }));
+    }
+}

package/generator/QueryGen.d.ts

@@ -0,0 +1,5 @@
+import { ApiGen } from '../generator';
+export declare class QueryGen extends ApiGen {
+    #private;
+    generate(): Promise<string>;
+}

package/generator/QueryGen.js

@@ -0,0 +1,55 @@
+import { stringLowerFirst } from '@polkadot/util';
+import { normalizeName } from '@dedot/utils';
+import { ApiGen } from '../generator';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+export class QueryGen extends ApiGen {
+    generate() {
+        const { pallets } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback');
+        let defTypeOut = '';
+        for (let pallet of pallets) {
+            const storage = pallet.storage;
+            if (!storage)
+                continue;
+            const queries = storage.entries.map((one) => this.#generateEntry(one));
+            const queryDefs = queries.map(({ name, valueType, keyType, docs }) => `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`);
+            defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s storage queries`);
+            defTypeOut += `${stringLowerFirst(pallet.name)}: {
+        ${queryDefs.join(',\n')}
+        
+        ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
+      },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('query.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+    #generateEntry(entry) {
+        const { name, type, docs, modifier } = entry;
+        let valueType, keyType;
+        if (type.tag === 'Plain') {
+            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
+        }
+        else if (type.tag === 'Map') {
+            valueType = this.typesGen.generateType(type.value.valueTypeId, 1, true);
+            keyType = this.typesGen.generateType(type.value.keyTypeId, 1);
+        }
+        else {
+            throw Error('Invalid entry type!');
+        }
+        const isOptional = modifier === 'Optional';
+        valueType = `${valueType}${isOptional ? ' | undefined' : ''}`;
+        docs.push('\n');
+        if (keyType) {
+            docs.push(`@param {${keyType}} arg`);
+        }
+        docs.push(`@param {Callback<${valueType}> =} callback`);
+        return {
+            name: normalizeName(name),
+            valueType,
+            keyType: keyType ? `arg: ${keyType}` : '',
+            docs,
+        };
+    }
+}

package/generator/RpcGen.d.ts

@@ -0,0 +1,10 @@
+import { ApiGen, TypesGen } from '../generator';
+export declare class RpcGen extends ApiGen {
+    #private;
+    readonly typesGen: TypesGen;
+    readonly rpcMethods: string[];
+    constructor(typesGen: TypesGen, rpcMethods: string[]);
+    generate(): Promise<string>;
+    addTypeImport(type: string | string[], toTypeIn?: boolean): void;
+    getGeneratedTypeName(type: string, toTypeIn?: boolean): string;
+}

package/generator/RpcGen.js

@@ -0,0 +1,171 @@
+import { findAliasRpcSpec, findRpcSpec, isUnsubscribeMethod } from '@dedot/specs';
+import { isNativeType } from '@dedot/utils';
+import { ApiGen } from '../generator';
+import { beautifySourceCode, commentBlock, compileTemplate, TUPLE_TYPE_REGEX, WRAPPER_TYPE_REGEX } from './utils';
+const HIDDEN_RPCS = [
+    // Ref: https://github.com/paritytech/polkadot-sdk/blob/43415ef58c143b985e09015cd000dbd65f6d3997/substrate/client/rpc-servers/src/lib.rs#L152C9-L158
+    'rpc_methods',
+];
+export class RpcGen extends ApiGen {
+    typesGen;
+    rpcMethods;
+    constructor(typesGen, rpcMethods) {
+        super(typesGen);
+        this.typesGen = typesGen;
+        this.rpcMethods = rpcMethods;
+        HIDDEN_RPCS.filter((one) => !rpcMethods.includes(one)).forEach((one) => rpcMethods.push(one));
+        rpcMethods.sort();
+    }
+    generate() {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericRpcCalls', 'Unsub', 'Callback', 'GenericRpcCall');
+        const specsByModule = this.rpcMethods
+            .filter((one) => !findAliasRpcSpec(one)) // we'll ignore  alias rpc for now if defined in the specs! TODO should we generate alias rpc as well?
+            .filter((one) => !isUnsubscribeMethod(one)) // we'll ignore unsubscribe method as well
+            .map((one) => {
+            const spec = findRpcSpec(one);
+            if (spec) {
+                return spec;
+            }
+            const [module, ...methodParts] = one.split('_');
+            const method = methodParts.join('_');
+            return {
+                params: [],
+                type: 'GenericRpcCall',
+                module,
+                method,
+            };
+        })
+            .reduce((o, spec) => {
+            const { module, method } = spec;
+            // ignore if rpc name does not confront with the general convention
+            if (!module || !method) {
+                return o;
+            }
+            return {
+                ...o,
+                [module]: o[module] ? [...o[module], spec] : [spec],
+            };
+        }, {});
+        let rpcCallsOut = '';
+        Object.keys(specsByModule).forEach((module) => {
+            const specs = specsByModule[module];
+            // TODO add alias info to docs block!
+            rpcCallsOut += `${module}: {
+      ${specs.map((spec) => this.#generateMethodDef(spec)).join(',\n')},
+
+      [method: string]: GenericRpcCall,
+    },`;
+        });
+        // TODO include & define external types
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('rpc.hbs');
+        return beautifySourceCode(template({ importTypes, rpcCallsOut }));
+    }
+    #generateMethodDef(spec) {
+        const { name, type, module, method, docs = [], params, pubsub, deprecated } = spec;
+        const rpcName = name || `${module}_${method}`;
+        let defaultDocs = [`@rpcname: ${rpcName}`];
+        if (deprecated) {
+            defaultDocs.push(`@deprecated: ${deprecated}`);
+        }
+        if (type === 'GenericRpcCall' && params.length === 0) {
+            return `${commentBlock(defaultDocs)}${method}: GenericRpcCall`;
+        }
+        this.addTypeImport(type, false);
+        params.forEach(({ type, isScale }) => {
+            this.addTypeImport(type, !!isScale);
+        });
+        const typedParams = params.map((param) => ({
+            ...param,
+            plainType: this.getGeneratedTypeName(param.type, !!param.isScale),
+        }));
+        const isSubscription = !!pubsub;
+        const paramsOut = typedParams.map(({ name, type, isOptional, isScale, plainType }) => `${name}${isOptional ? '?' : ''}: ${plainType}`);
+        const paramsDoc = typedParams.map(({ name, plainType }) => `@param {${plainType}} ${name}`);
+        const typeOut = this.getGeneratedTypeName(type, false);
+        if (isSubscription) {
+            defaultDocs.shift();
+            defaultDocs.unshift(`@pubsub: ${pubsub?.join(', ')}`);
+            paramsOut.push(`callback: Callback<${typeOut}>`);
+            return `${commentBlock(docs, '\n', defaultDocs, paramsDoc)}${method}: GenericRpcCall<(${paramsOut.join(', ')}) => Promise<Unsub>>`;
+        }
+        else {
+            return `${commentBlock(docs, '\n', defaultDocs, paramsDoc)}${method}: GenericRpcCall<(${paramsOut.join(', ')}) => Promise<${typeOut}>>`;
+        }
+    }
+    // TODO check typeIn, typeOut if param type, or rpc type isScale
+    addTypeImport(type, toTypeIn = true) {
+        if (Array.isArray(type)) {
+            type.forEach((one) => this.addTypeImport(one, toTypeIn));
+            return;
+        }
+        type = type.trim();
+        if (isNativeType(type)) {
+            return;
+        }
+        // Handle generic wrapper types
+        const matchArray = type.match(WRAPPER_TYPE_REGEX);
+        if (matchArray) {
+            const [_, $1, $2] = matchArray;
+            this.addTypeImport($1, toTypeIn);
+            if ($2.match(WRAPPER_TYPE_REGEX) || $2.match(TUPLE_TYPE_REGEX)) {
+                this.addTypeImport($2, toTypeIn);
+            }
+            else {
+                this.addTypeImport($2.split(','), toTypeIn);
+            }
+            return;
+        }
+        // Check tuple type
+        if (type.match(TUPLE_TYPE_REGEX)) {
+            this.addTypeImport(type.slice(1, -1).split(','), toTypeIn);
+            return;
+        }
+        if (type.includes(' | ')) {
+            this.addTypeImport(type.split(' | ').map((one) => one.trim()), toTypeIn);
+            return;
+        }
+        try {
+            const codecType = this.#getCodecType(type, toTypeIn);
+            if (isNativeType(codecType))
+                return;
+            this.typesGen.typeImports.addCodecType(codecType);
+            return;
+        }
+        catch (e) { }
+        this.typesGen.addTypeImport(type);
+    }
+    getGeneratedTypeName(type, toTypeIn = true) {
+        try {
+            const matchArray = type.match(WRAPPER_TYPE_REGEX);
+            if (matchArray) {
+                const [_, $1, $2] = matchArray;
+                const wrapperTypeName = this.#getCodecType($1, toTypeIn);
+                if ($2.match(WRAPPER_TYPE_REGEX) || $2.match(TUPLE_TYPE_REGEX)) {
+                    return `${wrapperTypeName}<${this.getGeneratedTypeName($2, toTypeIn)}>`;
+                }
+                const innerTypeNames = $2
+                    .split(',')
+                    .map((one) => this.getGeneratedTypeName(one.trim(), toTypeIn))
+                    .join(', ');
+                return `${wrapperTypeName}<${innerTypeNames}>`;
+            }
+            else if (type.match(TUPLE_TYPE_REGEX)) {
+                const innerTypeNames = type
+                    .slice(1, -1)
+                    .split(',')
+                    .map((one) => this.getGeneratedTypeName(one.trim(), toTypeIn))
+                    .join(', ');
+                return `[${innerTypeNames}]`;
+            }
+            return this.#getCodecType(type, toTypeIn);
+        }
+        catch (e) { }
+        return type;
+    }
+    #getCodecType(type, toTypeIn = true) {
+        const { typeIn, typeOut } = this.registry.findCodecType(type);
+        return toTypeIn ? typeIn : typeOut;
+    }
+}

package/generator/RuntimeApisGen.d.ts

@@ -0,0 +1,9 @@
+import { TypesGen } from './TypesGen';
+import { RpcGen } from './RpcGen';
+export declare class RuntimeApisGen extends RpcGen {
+    #private;
+    readonly typesGen: TypesGen;
+    readonly runtimeApis: [string, number][];
+    constructor(typesGen: TypesGen, runtimeApis: [string, number][]);
+    generate(): Promise<string>;
+}