@dedot/codegen 0.0.1-alpha.11

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>;
+}

package/generator/RuntimeApisGen.js

@@ -0,0 +1,116 @@
+import { findRuntimeApiSpec } from '@dedot/specs';
+import { beautifySourceCode, commentBlock, compileTemplate } from './utils';
+import { calculateRuntimeApiHash, stringSnakeCase } from '@dedot/utils';
+import { RpcGen } from './RpcGen';
+import { stringCamelCase } from '@polkadot/util';
+export class RuntimeApisGen extends RpcGen {
+    typesGen;
+    runtimeApis;
+    constructor(typesGen, runtimeApis) {
+        super(typesGen, []);
+        this.typesGen = typesGen;
+        this.runtimeApis = runtimeApis;
+    }
+    generate() {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod');
+        let runtimeCallsOut = '';
+        if (this.metadata.apis.length > 0) {
+            this.metadata.apis.forEach((runtimeApi) => {
+                const { name: runtimeApiName, methods } = runtimeApi;
+                runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${calculateRuntimeApiHash(runtimeApiName)}`);
+                runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
+            ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
+              
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
+        }`;
+            });
+        }
+        else {
+            const specsByModule = this.#runtimeApisSpecsByModule();
+            Object.values(specsByModule).forEach((specs) => {
+                specs.forEach(({ methods, runtimeApiName, runtimeApiHash, version }) => {
+                    runtimeCallsOut += commentBlock(`@runtimeapi: ${runtimeApiName} - ${runtimeApiHash}`, `@version: ${version}`);
+                    runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
+            ${Object.keys(methods)
+                        .map((methodName) => this.#generateMethodDefFromSpec({ ...methods[methodName], runtimeApiName, methodName }))
+                        .join('\n')} 
+              
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
+          }`;
+                });
+            });
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        const template = compileTemplate('runtime.hbs');
+        return beautifySourceCode(template({ importTypes, runtimeCallsOut }));
+    }
+    #isOptionalType(type) {
+        return type.startsWith('Option<') || type.endsWith('| undefined');
+    }
+    #isOptionalParam(params, type, idx) {
+        return this.#isOptionalType(type) && params.slice(idx + 1).every(({ type }) => this.#isOptionalType(type));
+    }
+    #generateMethodDefFromSpec(spec) {
+        const { docs = [], params, type, runtimeApiName, methodName } = spec;
+        const callName = `${runtimeApiName}_${stringSnakeCase(methodName)}`;
+        const defaultDocs = [`@callname: ${callName}`];
+        this.addTypeImport(type, false);
+        params.forEach(({ type }) => this.addTypeImport(type));
+        const typedParams = params.map((param, idx) => ({
+            ...param,
+            isOptional: this.#isOptionalParam(params, param.type, idx),
+            plainType: this.getGeneratedTypeName(param.type),
+        }));
+        const paramsOut = typedParams
+            .map(({ name, isOptional, plainType }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${plainType}`)
+            .join(', ');
+        const typeOut = this.getGeneratedTypeName(type, false);
+        return `${commentBlock(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
+    }
+    #generateMethodDef(runtimeApiName, methodDef) {
+        const { name: methodName, inputs, output, docs } = methodDef;
+        const callName = `${runtimeApiName}_${stringSnakeCase(methodName)}`;
+        const defaultDocs = [`@callname: ${callName}`];
+        const typeOut = this.typesGen.generateType(output, 1, true);
+        this.addTypeImport(typeOut, false);
+        const typedInputs = inputs
+            .map((input, idx) => ({
+            ...input,
+            type: this.typesGen.generateType(input.typeId, 1),
+        }))
+            .map((input, idx, inputs) => ({
+            ...input,
+            isOptional: this.#isOptionalParam(inputs, input.type, idx),
+        }));
+        this.addTypeImport(typedInputs.map((t) => t.type));
+        const paramsOut = typedInputs
+            .map(({ name, type, isOptional }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${type}`)
+            .join(', ');
+        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`))}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
+    }
+    #runtimeApisSpecsByModule() {
+        const specs = this.runtimeApis.map(([runtimeApiHash, version]) => {
+            const runtimeApiSpec = findRuntimeApiSpec(runtimeApiHash, version);
+            if (!runtimeApiSpec)
+                return;
+            return {
+                ...runtimeApiSpec,
+                runtimeApiHash,
+            };
+        });
+        return specs.reduce((o, spec) => {
+            if (!spec) {
+                return o;
+            }
+            const { moduleName } = spec;
+            if (!moduleName) {
+                return o;
+            }
+            return {
+                ...o,
+                [moduleName]: o[moduleName] ? [...o[moduleName], spec] : [spec],
+            };
+        }, {});
+    }
+}

package/generator/TxGen.d.ts

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

package/generator/TxGen.js

@@ -0,0 +1,86 @@
+import { ApiGen } from '../generator';
+import { stringCamelCase, stringPascalCase } from '@polkadot/util';
+import { beautifySourceCode, commentBlock, compileTemplate, isReservedWord } from './utils';
+export class TxGen extends ApiGen {
+    generate() {
+        const { pallets, types } = this.metadata;
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall');
+        const { callTypeId, addressTypeId, signatureTypeId } = this.metadata.extrinsic;
+        const callTypeIn = this.typesGen.generateType(callTypeId, 1);
+        const addressTypeIn = this.typesGen.generateType(addressTypeId, 1);
+        const signatureTypeIn = this.typesGen.generateType(signatureTypeId, 1);
+        this.typesGen.typeImports.addPortableType('FrameSystemEventRecord');
+        this.typesGen.typeImports.addCodecType('Extrinsic');
+        this.typesGen.addTypeImport([callTypeIn, addressTypeIn, signatureTypeIn]);
+        let txDefsOut = '';
+        for (let pallet of pallets) {
+            if (pallet.calls === undefined)
+                continue;
+            const { type } = types[pallet.calls];
+            if (type.tag !== 'Enum')
+                continue;
+            const isFlatEnum = type.value.members.every((m) => m.fields.length === 0);
+            const typedTxs = type.value.members
+                .map((one) => ({
+                functionName: stringCamelCase(one.name),
+                params: one.fields.map((f) => ({
+                    name: stringCamelCase(f.name),
+                    normalizedName: this.#normalizeParamName(f.name),
+                    type: this.typesGen.generateType(f.typeId, 1),
+                    docs: f.docs,
+                })),
+                docs: one.docs,
+            }))
+                .map((f) => {
+                return {
+                    ...f,
+                    callInput: this.#generateCallInput(stringPascalCase(pallet.name), stringPascalCase(f.functionName), !isFlatEnum ? f.params.map((p) => `${p.name}: ${p.type}`) : undefined),
+                };
+            });
+            txDefsOut += commentBlock(`Pallet \`${pallet.name}\`'s transaction calls`);
+            txDefsOut += `${stringCamelCase(pallet.name)}: {
+          ${typedTxs
+                .map(({ functionName, params, docs, callInput }) => `${commentBlock(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`))}${functionName}: GenericTxCall<(${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<${callInput}>>`)
+                .join(',\n')}
+            
+          ${commentBlock('Generic pallet tx call')}[callName: string]: GenericTxCall<TxCall>,
+        },`;
+        }
+        const importTypes = this.typesGen.typeImports.toImports();
+        // TODO make explicit separate type for Extra
+        const defTypes = `
+    export type ChainSubmittableExtrinsic<T extends IRuntimeTxCall = ${callTypeIn}> = 
+        Extrinsic<${addressTypeIn}, T, ${signatureTypeIn}, any[]> &
+        ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord>>
+        
+    export type TxCall = (...args: any[]) => ChainSubmittableExtrinsic;    
+`;
+        const template = compileTemplate('tx.hbs');
+        return beautifySourceCode(template({ importTypes, defTypes, txDefsOut }));
+    }
+    #normalizeParamName(name) {
+        name = stringCamelCase(name);
+        return isReservedWord(name) ? `${name}_` : name;
+    }
+    #generateCallInput(palletName, callName, params) {
+        if (!params) {
+            return `
+        {
+          pallet: '${palletName}',
+          palletCall: '${callName}'
+        }
+      `;
+        }
+        const paramsOut = params.length > 0 ? `params: { ${params.join(',')} }` : '';
+        return `
+      {
+        pallet: '${palletName}',
+        palletCall: {
+          name: '${callName}',
+          ${paramsOut}
+        }
+      }
+    `;
+    }
+}

package/generator/TypeImports.d.ts

@@ -0,0 +1,14 @@
+export declare class TypeImports {
+    #private;
+    portableTypes: Set<string>;
+    codecTypes: Set<string>;
+    knownTypes: Set<string>;
+    outTypes: Set<string>;
+    constructor();
+    clear(): void;
+    toImports(...excludeModules: string[]): string;
+    addPortableType(...types: string[]): void;
+    addCodecType(...types: string[]): void;
+    addKnownType(...types: string[]): void;
+    addOutType(...types: string[]): void;
+}

package/generator/TypeImports.js

@@ -0,0 +1,52 @@
+export class TypeImports {
+    // Portable types from chain/metadata
+    portableTypes;
+    // Known types that has a corresponding codec defined in @dedot/codecs
+    codecTypes;
+    // Known types that're not codecs or chain/portable types defined in @dedot/types
+    knownTypes;
+    // External types to define explicitly
+    outTypes;
+    constructor() {
+        this.portableTypes = new Set();
+        this.codecTypes = new Set();
+        this.knownTypes = new Set();
+        this.outTypes = new Set();
+    }
+    clear() {
+        this.portableTypes.clear();
+        this.codecTypes.clear();
+        this.knownTypes.clear();
+        this.outTypes.clear();
+    }
+    toImports(...excludeModules) {
+        // TODO generate outTypes!
+        const toImports = [
+            [this.knownTypes, '@dedot/types'],
+            [this.codecTypes, '@dedot/codecs'],
+            [this.portableTypes, './types'],
+        ];
+        return toImports
+            .filter(([_, module]) => !excludeModules.includes(module))
+            .map(([types, module]) => this.#toImportLine(types, module))
+            .join('\n');
+    }
+    #toImportLine(types, module) {
+        const typesToImports = [...types];
+        if (typesToImports.length === 0)
+            return '';
+        return `import type {${typesToImports.join(', ')}} from "${module}"`;
+    }
+    addPortableType(...types) {
+        types.forEach((one) => this.portableTypes.add(one));
+    }
+    addCodecType(...types) {
+        types.forEach((one) => this.codecTypes.add(one));
+    }
+    addKnownType(...types) {
+        types.forEach((one) => this.knownTypes.add(one));
+    }
+    addOutType(...types) {
+        types.forEach((one) => this.outTypes.add(one));
+    }
+}

package/generator/TypesGen.d.ts

@@ -0,0 +1,30 @@
+import { CodecRegistry, Field, MetadataLatest, PortableType, TypeId } from '@dedot/codecs';
+import { TypeImports } from './TypeImports';
+interface NamedType extends PortableType {
+    name: string;
+    nameOut: string;
+    skip?: boolean;
+    knownType?: boolean;
+    suffix?: string;
+}
+export declare const BASIC_KNOWN_TYPES: string[];
+export declare class TypesGen {
+    #private;
+    metadata: MetadataLatest;
+    /**
+     * Types will be generated its definition out.
+     */
+    includedTypes: Record<TypeId, NamedType>;
+    registry: CodecRegistry;
+    typeImports: TypeImports;
+    constructor(metadata: MetadataLatest);
+    generate(): Promise<string>;
+    typeCache: Record<string, string>;
+    clearCache(): void;
+    generateType(typeId: TypeId, nestedLevel?: number, typeOut?: boolean): string;
+    generateObjectType(fields: Field[], nestedLevel?: number, typeOut?: boolean): string;
+    eqlCache: Map<string, boolean>;
+    typeEql(idA: number, idB: number, level?: number): boolean;
+    addTypeImport(typeName: string | string[]): void;
+}
+export {};