@dedot/codegen 0.0.1-next.8d06d348.17 → 0.0.1-next.8f4b2c24.6

package/generator/RpcGen.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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.typesGen.knownCodecRegistry.findCodecType(type);
-        return toTypeIn ? typeIn : typeOut;
-    }
-}

package/helpers/KnownCodecRegistry.js

@@ -1,135 +0,0 @@
-import * as $ from '@dedot/shape';
-import * as Codecs from '@dedot/codecs';
-import { $AccountId20, $AccountId32, $Bytes, $ConsensusEngineId, $Era, $EthereumAddress, $MultiAddress, $OpaqueExtrinsic, $PrefixedStorageKey, $RawBytes, $StorageData, $StorageKey, $UncheckedExtrinsic, } from '@dedot/codecs';
-export const normalizeCodecName = (name) => {
-    return name.startsWith('$') ? name : `$${name}`;
-};
-// Known paths for codecs (primitives) that are shared between
-// different substrate-based blockchains
-const KNOWN_PATHS = [
-    'sp_core::crypto::AccountId32',
-    'sp_runtime::generic::era::Era',
-    'sp_runtime::multiaddress::MultiAddress',
-    /^sp_runtime::DispatchError$/,
-    'sp_runtime::ModuleError',
-    'sp_runtime::TokenError',
-    'sp_arithmetic::ArithmeticError',
-    'sp_runtime::TransactionalError',
-    'frame_support::dispatch::DispatchInfo',
-    'frame_system::Phase',
-    'sp_version::RuntimeVersion',
-    'fp_account::AccountId20',
-    'account::AccountId20',
-    'polkadot_runtime_common::claims::EthereumAddress',
-    'pallet_identity::types::Data',
-    'sp_runtime::generic::digest::Digest',
-    'sp_runtime::generic::digest::DigestItem',
-    'sp_runtime::generic::header::Header',
-    'sp_runtime::generic::unchecked_extrinsic::UncheckedExtrinsic',
-    /^primitive_types::\w+$/,
-    /^sp_arithmetic::per_things::\w+$/,
-    /^sp_arithmetic::fixed_point::\w+$/,
-];
-const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
-const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
-const KNOWN_WRAPPER_TYPES = ['Option', 'Vec', 'Result', 'Array'];
-/**
- * Collection of codec types with loose input types
- *
- * Loose codecs are codecs with different typeIn & typeOut,
- * E.g: Codec `$AccountId32`, we have its typeIn is `AccountId32Like` & typeOut is `AccountId32`
- *
- * This registry keep track the list of codecs which follow this convention
- */
-export const looseTypeCodecs = {
-    $AccountId20,
-    $EthereumAddress,
-    $AccountId32,
-    $ConsensusEngineId,
-    $StorageKey,
-    $StorageData,
-    $PrefixedStorageKey,
-    $Bytes,
-    $RawBytes,
-    $MultiAddress,
-    $OpaqueExtrinsic,
-    $UncheckedExtrinsic,
-    $Era,
-};
-/**
- * A codec registry for both known and portable codecs,
- */
-export class KnownCodecRegistry {
-    findCodec(name) {
-        return this.#findKnownCodec(name);
-    }
-    findCodecType(name) {
-        const normalizedName = normalizeCodecName(name);
-        const $knownCodec = looseTypeCodecs[normalizedName];
-        if ($knownCodec) {
-            return {
-                name: normalizedName,
-                $codec: $knownCodec,
-                typeIn: `${name}Like`,
-                typeOut: name,
-            };
-        }
-        const $codec = this.findCodec(name);
-        if ($codec.nativeType && $[name]) {
-            return {
-                name: normalizedName,
-                $codec,
-                typeIn: $codec.nativeType,
-                typeOut: $codec.nativeType,
-            };
-        }
-        return {
-            name: normalizedName,
-            $codec,
-            typeIn: name,
-            typeOut: name,
-        };
-    }
-    #findKnownCodec(typeName) {
-        // @ts-ignore
-        const $codec = this.#findKnownWrapperCodec(typeName) || Codecs[normalizeCodecName(typeName)] || $[typeName];
-        if (!$codec) {
-            throw new Error(`Unsupported codec - ${typeName}`);
-        }
-        // This only works with top-level $.deferred codecs
-        // We should make it work for nested $.deferred codecs as well
-        if ($codec.metadata && $codec.metadata[0].name === '$.deferred') {
-            const getShape = $codec.metadata[0].args[0];
-            return $.deferred(() => getShape(this));
-        }
-        return $codec;
-    }
-    #findKnownWrapperCodec(typeName) {
-        const matchNames = typeName.match(WRAPPER_TYPE_REGEX);
-        if (matchNames) {
-            const [_, wrapper, inner] = matchNames;
-            if (KNOWN_WRAPPER_TYPES.includes(wrapper)) {
-                // @ts-ignore
-                const $Wrapper = $[wrapper];
-                if (inner.match(TUPLE_TYPE_REGEX) || inner.match(WRAPPER_TYPE_REGEX)) {
-                    return $Wrapper(this.#findKnownWrapperCodec(inner));
-                }
-                const $inners = inner.split(',').map((one) => this.#findKnownCodec(one.trim()));
-                return $Wrapper(...$inners);
-            }
-            throw new Error(`Unknown wrapper type ${wrapper} from ${typeName}`);
-        }
-        else if (typeName.match(TUPLE_TYPE_REGEX)) {
-            const $inner = typeName
-                .slice(1, -1)
-                .split(',')
-                .filter((x) => x)
-                .map((one) => this.#findKnownCodec(one.trim()));
-            return $.Tuple(...$inner);
-        }
-    }
-    isKnownType(path) {
-        const joinedPath = Array.isArray(path) ? path.join('::') : path;
-        return KNOWN_PATHS.some((one) => joinedPath.match(one));
-    }
-}

package/helpers/index.d.ts

@@ -1 +0,0 @@
-export * from './KnownCodecRegistry';

package/helpers/index.js

@@ -1 +0,0 @@
-export * from './KnownCodecRegistry';

package/packageInfo.d.ts

@@ -1,4 +0,0 @@
-export declare const packageInfo: {
-    name: string;
-    version: string;
-};

package/packageInfo.js

@@ -1,2 +0,0 @@
-// THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
-export const packageInfo = { name: '@dedot/codegen', version: '0.0.1-alpha.26' };

package/templates/rpc.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface RpcCalls extends GenericRpcCalls {
-  {{{rpcCallsOut}}}
-}

package/types.d.ts

@@ -1,14 +0,0 @@
-import { AnyShape } from '@dedot/shape';
-export type NetworkInfo = {
-    chain: string;
-    endpoint?: string;
-    metadataHex?: string;
-    rpcMethods?: string[];
-};
-export type CodecName = `$${string}`;
-export interface CodecType {
-    name: CodecName;
-    $codec: AnyShape;
-    typeIn: string;
-    typeOut: string;
-}

package/types.js

@@ -1 +0,0 @@
-export {};