@dedot/codegen 0.0.1-alpha.22

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