@dedot/codegen 0.0.1-next.fecbe32d.13 → 0.1.0

package/typink/generator/QueryGen.d.ts

@@ -0,0 +1,12 @@
+import { ContractMetadata, ContractMessage, ContractMessageArg } from '@dedot/contracts';
+import { TypesGen } from './TypesGen.js';
+export declare class QueryGen {
+    contractMetadata: ContractMetadata;
+    typesGen: TypesGen;
+    constructor(contractMetadata: ContractMetadata, typeGen: TypesGen);
+    generate(useSubPaths?: boolean): Promise<string>;
+    doGenerate(messages: ContractMessage[], optionsTypeName?: string): string;
+    generateMethodDef(def: ContractMessage): string;
+    generateParamsOut(args: ContractMessageArg[]): string;
+    importType(typeId: number): any;
+}

package/typink/generator/QueryGen.js

@@ -0,0 +1,68 @@
+import { normalizeContractTypeDef, normalizeLabel, } from '@dedot/contracts';
+import { stringCamelCase } from '@dedot/utils';
+import { beautifySourceCode, commentBlock, compileTemplate } from '../../utils.js';
+export class QueryGen {
+    contractMetadata;
+    typesGen;
+    constructor(contractMetadata, typeGen) {
+        this.contractMetadata = contractMetadata;
+        this.typesGen = typeGen;
+    }
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractQuery', 'GenericContractQueryCall', 'ContractCallOptions', 'GenericContractCallResult', 'ContractCallResult');
+        const { messages } = this.contractMetadata.spec;
+        const queryCallsOut = this.doGenerate(messages, 'ContractCallOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('typink/templates/query.hbs');
+        return beautifySourceCode(template({ importTypes, queryCallsOut }));
+    }
+    doGenerate(messages, optionsTypeName) {
+        let callsOut = '';
+        messages.forEach((messageDef) => {
+            const { label, docs, selector, args } = messageDef;
+            callsOut += `${commentBlock(docs, '\n', args.map((arg) => `@param {${this.typesGen.generateType(arg.type.type, 1)}} ${stringCamelCase(arg.label)}`), optionsTypeName ? `@param {${optionsTypeName}} options` : '', '\n', `@selector ${selector}`)}`;
+            callsOut += `${normalizeLabel(label)}: ${this.generateMethodDef(messageDef)};\n\n`;
+        });
+        return callsOut;
+    }
+    generateMethodDef(def) {
+        const { args, returnType } = def;
+        this.importType(returnType.type);
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        const typeOut = this.typesGen.generateType(returnType.type, 0, true);
+        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>>`;
+    }
+    generateParamsOut(args) {
+        return args
+            .map(({ type: { type }, label }) => `${stringCamelCase(label)}: ${this.typesGen.generateType(type, 1)}`)
+            .join(', ');
+    }
+    importType(typeId) {
+        const contractType = this.contractMetadata.types[typeId];
+        const typeDef = normalizeContractTypeDef(this.contractMetadata.types[typeId].type.def);
+        if (this.typesGen.includedTypes[contractType.id]) {
+            this.typesGen.addTypeImport(this.typesGen.includedTypes[contractType.id].name);
+            return;
+        }
+        const { type, value } = typeDef;
+        switch (type) {
+            case 'Compact':
+            case 'Primitive':
+            case 'BitSequence':
+                return;
+            case 'Struct':
+                return value.fields.forEach(({ typeId }) => this.importType(typeId));
+            case 'Enum':
+                return value.members.forEach(({ fields }) => fields.map(({ typeId }) => this.importType(typeId)).flat());
+            case 'Tuple':
+                return value.fields.forEach((typeId) => this.importType(typeId));
+            case 'SizedVec':
+                return this.importType(value.typeParam);
+            case 'Sequence':
+                return this.importType(value.typeParam);
+        }
+    }
+}

package/typink/generator/TxGen.d.ts

@@ -0,0 +1,6 @@
+import { ContractMessage } from '@dedot/contracts';
+import { QueryGen } from './QueryGen.js';
+export declare class TxGen extends QueryGen {
+    generate(useSubPaths?: boolean): Promise<string>;
+    generateMethodDef(def: ContractMessage): string;
+}

package/typink/generator/TxGen.js

@@ -0,0 +1,21 @@
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+import { QueryGen } from './QueryGen.js';
+export class TxGen extends QueryGen {
+    generate(useSubPaths = false) {
+        this.typesGen.clearCache();
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi');
+        this.typesGen.typeImports.addContractType('GenericContractTx', 'GenericContractTxCall', 'ContractTxOptions', 'ContractSubmittableExtrinsic');
+        const { messages } = this.contractMetadata.spec;
+        const txMessages = messages.filter((one) => one.mutates);
+        const txCallsOut = this.doGenerate(txMessages, 'ContractTxOptions');
+        const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
+        const template = compileTemplate('typink/templates/tx.hbs');
+        return beautifySourceCode(template({ importTypes, txCallsOut }));
+    }
+    generateMethodDef(def) {
+        const { args } = def;
+        args.forEach(({ type: { type } }) => this.importType(type));
+        const paramsOut = this.generateParamsOut(args);
+        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} options: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>>`;
+    }
+}

package/typink/generator/TypesGen.d.ts

@@ -0,0 +1,7 @@
+import { ContractMetadata } from '@dedot/contracts';
+import { BaseTypesGen } from '../../shared/index.js';
+export declare class TypesGen extends BaseTypesGen {
+    contractMetadata: ContractMetadata;
+    constructor(contractMetadata: ContractMetadata);
+    generate(useSubPaths?: boolean): Promise<string>;
+}

package/typink/generator/TypesGen.js

@@ -0,0 +1,24 @@
+import { extractContractTypes } from '@dedot/contracts';
+import { BaseTypesGen } from '../../shared/index.js';
+import { beautifySourceCode, compileTemplate } from '../../utils.js';
+const SKIP_TYPES = ['Result', 'Option'];
+export class TypesGen extends BaseTypesGen {
+    contractMetadata;
+    constructor(contractMetadata) {
+        super(extractContractTypes(contractMetadata));
+        this.contractMetadata = contractMetadata;
+        this.skipTypes = SKIP_TYPES;
+        this.includedTypes = this.includeTypes();
+    }
+    generate(useSubPaths = false) {
+        let defTypeOut = '';
+        Object.values(this.includedTypes)
+            .filter(({ skip, knownType }) => !(skip || knownType))
+            .forEach(({ nameOut, id }) => {
+            defTypeOut += `export type ${nameOut} = ${this.generateType(id, 0, true)};\n\n`;
+        });
+        const importTypes = this.typeImports.toImports({ excludeModules: ['./types'], useSubPaths });
+        const template = compileTemplate('typink/templates/types.hbs');
+        return beautifySourceCode(template({ importTypes, defTypeOut }));
+    }
+}

package/typink/generator/index.d.ts

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+export * from './TypesGen.js';
+export * from './TxGen.js';
+export * from './ConstructorTxGen.js';
+export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/typink/generator/index.js

@@ -0,0 +1,7 @@
+export * from './IndexGen.js';
+export * from './QueryGen.js';
+export * from './TypesGen.js';
+export * from './TxGen.js';
+export * from './ConstructorTxGen.js';
+export * from './ConstructorQueryGen.js';
+export * from './EventsGen.js';

package/typink/index.d.ts

@@ -0,0 +1,2 @@
+import { ContractMetadata } from '@dedot/contracts';
+export declare function generateContractTypes(metadata: ContractMetadata | string, contract?: string, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<void>;

package/typink/index.js

@@ -0,0 +1,33 @@
+import { parseRawMetadata } from '@dedot/contracts';
+import fs from 'fs';
+import path from 'path';
+import { IndexGen, QueryGen, EventsGen, TxGen, TypesGen, ConstructorTxGen, ConstructorQueryGen, } from './generator/index.js';
+export async function generateContractTypes(metadata, contract, outDir = '.', extension = 'd.ts', useSubPaths = false) {
+    let contractMetadata = typeof metadata === 'string' ? parseRawMetadata(metadata) : metadata;
+    contract = contract || contractMetadata.contract.name;
+    const dirPath = path.resolve(outDir, contract);
+    const typesFileName = path.join(dirPath, `types.${extension}`);
+    const queryTypesFileName = path.join(dirPath, `query.${extension}`);
+    const txTypesFileName = path.join(dirPath, `tx.${extension}`);
+    const constructorTxTypesFileName = path.join(dirPath, `constructor-tx.${extension}`);
+    const constructorQueryTypesFileName = path.join(dirPath, `constructor-query.${extension}`);
+    const eventsTypesFile = path.join(dirPath, `events.${extension}`);
+    const indexTypesFileName = path.join(dirPath, `index.${extension}`);
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    const typesGen = new TypesGen(contractMetadata);
+    const queryGen = new QueryGen(contractMetadata, typesGen);
+    const txGen = new TxGen(contractMetadata, typesGen);
+    const constructorTxGen = new ConstructorTxGen(contractMetadata, typesGen);
+    const constructorQueryGen = new ConstructorQueryGen(contractMetadata, typesGen);
+    const eventsGen = new EventsGen(contractMetadata, typesGen);
+    const indexGen = new IndexGen(contractMetadata);
+    fs.writeFileSync(typesFileName, await typesGen.generate(useSubPaths));
+    fs.writeFileSync(queryTypesFileName, await queryGen.generate(useSubPaths));
+    fs.writeFileSync(txTypesFileName, await txGen.generate(useSubPaths));
+    fs.writeFileSync(constructorQueryTypesFileName, await constructorQueryGen.generate(useSubPaths));
+    fs.writeFileSync(constructorTxTypesFileName, await constructorTxGen.generate(useSubPaths));
+    fs.writeFileSync(eventsTypesFile, await eventsGen.generate(useSubPaths));
+    fs.writeFileSync(indexTypesFileName, await indexGen.generate(useSubPaths));
+}

package/typink/templates/constructor-query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorQuery<ChainApi extends GenericSubstrateApi> extends GenericConstructorQuery<ChainApi> {
+    {{{ constructorsOut }}}
+}

package/typink/templates/constructor-tx.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ConstructorTx<ChainApi extends GenericSubstrateApi> extends GenericConstructorTx<ChainApi> {
+    {{{ constructorsOut }}}
+}

package/typink/templates/events.hbs

@@ -0,0 +1,8 @@
+// Generated by dedot cli
+
+import { GenericSubstrateApi } from '@dedot/types';
+{{{ importTypes }}}
+
+export interface ContractEvents<ChainApi extends GenericSubstrateApi> extends GenericContractEvents<ChainApi> {
+    {{{ eventsOut }}}
+}

package/typink/templates/index.hbs

@@ -0,0 +1,16 @@
+// Generated by dedot cli
+
+{{{importTypes}}}
+import { ContractQuery } from './query';
+import { ContractTx } from './tx';
+import { ConstructorQuery } from './constructor-query';
+import { ConstructorTx } from './constructor-tx';
+import { ContractEvents } from './events'
+
+export interface {{{contractName}}}<Rv extends RpcVersion = RpcV2, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi> {
+    query: ContractQuery<ChainApi[Rv]>;
+    tx: ContractTx<ChainApi[Rv]>;
+    constructorQuery: ConstructorQuery<ChainApi[Rv]>;
+    constructorTx: ConstructorTx<ChainApi[Rv]>;
+    events: ContractEvents<ChainApi[Rv]>;
+}

package/typink/templates/query.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractQuery<ChainApi extends GenericSubstrateApi> extends GenericContractQuery<ChainApi> {
+    {{{ queryCallsOut }}}
+}

package/typink/templates/tx.hbs

@@ -0,0 +1,7 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+export interface ContractTx<ChainApi extends GenericSubstrateApi> extends GenericContractTx<ChainApi> {
+    {{{ txCallsOut }}}
+}

package/typink/templates/types.hbs

@@ -0,0 +1,5 @@
+// Generated by dedot cli
+
+{{{ importTypes }}}
+
+{{{ defTypeOut }}}

package/{generator/utils.d.ts → utils.d.ts}

@@ -2,7 +2,7 @@ export declare const WRAPPER_TYPE_REGEX: RegExp;
 export declare const TUPLE_TYPE_REGEX: RegExp;
 export declare const commentBlock: (...docs: (string | string[])[]) => string;
 export declare const beautifySourceCode: (source: string) => Promise<string>;
-export declare const compileTemplate: (templateFileName: string) => HandlebarsTemplateDelegate<any>;
+export declare const compileTemplate: (templateFile: string) => HandlebarsTemplateDelegate<any>;
 /**
  * Check if a word is TypeScript/JavaScript reserved
  * @param word

package/{generator/utils.js → utils.js}

@@ -7,7 +7,7 @@ export const WRAPPER_TYPE_REGEX = /^(\w+)<(.*)>$/;
 export const TUPLE_TYPE_REGEX = /^\[(.*)]$/;
 export const commentBlock = (...docs) => {
     const flatLines = docs.flat();
-    if (flatLines.length === 0) {
+    if (flatLines.length === 0 || !flatLines.some((o) => !!o)) {
         return '';
     }
     else {
@@ -19,11 +19,11 @@ ${flatLines.map((line) => `* ${line.replaceAll(/\s+/g, ' ').trim()}`).join('\n')
     }
 };
 export const beautifySourceCode = async (source) => {
-    const prettierOptions = await prettier.resolveConfig(path.resolve(currentDirname(), '../../../../.prettierrc.js'));
+    const prettierOptions = await prettier.resolveConfig(path.resolve(currentDirname(), '../../../.prettierrc.cjs'));
     return prettier.format(source, { parser: 'babel-ts', ...prettierOptions });
 };
-export const compileTemplate = (templateFileName) => {
-    const templateFilePath = path.resolve(currentDirname(), `../templates/${templateFileName}`);
+export const compileTemplate = (templateFile) => {
+    const templateFilePath = path.resolve(currentDirname(), templateFile);
     return handlebars.compile(fs.readFileSync(templateFilePath, 'utf8'));
 };
 // TODO add more reserved words

package/cjs/generator/IndexGen.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IndexGen = void 0;
-const utils_1 = require("@dedot/utils");
-const utils_js_1 = require("./utils.js");
-class IndexGen {
-    chain;
-    constructor(chain) {
-        this.chain = chain;
-    }
-    async generate() {
-        const interfaceName = (0, utils_1.stringPascalCase)(this.chain);
-        const template = (0, utils_js_1.compileTemplate)('index.hbs');
-        return (0, utils_js_1.beautifySourceCode)(template({ interfaceName }));
-    }
-}
-exports.IndexGen = IndexGen;

package/cjs/templates/consts.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainConsts extends GenericChainConsts {
-  {{{ defTypeOut }}}
-}

package/cjs/templates/errors.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainErrors extends GenericChainErrors {
-  {{{ defTypeOut }}}
-}

package/cjs/templates/events.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainEvents extends GenericChainEvents {
-  {{{ defTypeOut }}}
-}

package/cjs/templates/index.hbs

@@ -1,22 +0,0 @@
-// Generated by @dedot/codegen
-
-import { GenericSubstrateApi } from '@dedot/types';
-import { ChainConsts } from './consts';
-import { ChainStorage } from './query';
-import { ChainJsonRpcApis } from './json-rpc';
-import { ChainErrors } from './errors';
-import { ChainEvents } from './events';
-import { RuntimeApis } from './runtime';
-import { ChainTx } from './tx';
-
-export * from './types';
-
-export interface {{{interfaceName}}}Api extends GenericSubstrateApi {
-  rpc: ChainJsonRpcApis;
-  consts: ChainConsts;
-  query: ChainStorage;
-  errors: ChainErrors;
-  events: ChainEvents;
-  call: RuntimeApis;
-  tx: ChainTx;
-}

package/cjs/templates/json-rpc.hbs

@@ -1,5 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export type ChainJsonRpcApis = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis;

package/cjs/templates/query.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainStorage extends GenericChainStorage {
-  {{{ defTypeOut }}}
-}

package/cjs/templates/runtime.hbs

@@ -1,8 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface RuntimeApis extends GenericRuntimeApis {
-{{{ runtimeCallsOut }}}
-}
-

package/cjs/templates/tx.hbs

@@ -1,9 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-{{{ defTypes }}}
-
-export interface ChainTx extends GenericChainTx<TxCall> {
-  {{{ txDefsOut }}}
-}

package/generator/IndexGen.js

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

package/templates/consts.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainConsts extends GenericChainConsts {
-  {{{ defTypeOut }}}
-}

package/templates/errors.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainErrors extends GenericChainErrors {
-  {{{ defTypeOut }}}
-}

package/templates/events.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainEvents extends GenericChainEvents {
-  {{{ defTypeOut }}}
-}

package/templates/index.hbs

@@ -1,22 +0,0 @@
-// Generated by @dedot/codegen
-
-import { GenericSubstrateApi } from '@dedot/types';
-import { ChainConsts } from './consts';
-import { ChainStorage } from './query';
-import { ChainJsonRpcApis } from './json-rpc';
-import { ChainErrors } from './errors';
-import { ChainEvents } from './events';
-import { RuntimeApis } from './runtime';
-import { ChainTx } from './tx';
-
-export * from './types';
-
-export interface {{{interfaceName}}}Api extends GenericSubstrateApi {
-  rpc: ChainJsonRpcApis;
-  consts: ChainConsts;
-  query: ChainStorage;
-  errors: ChainErrors;
-  events: ChainEvents;
-  call: RuntimeApis;
-  tx: ChainTx;
-}

package/templates/json-rpc.hbs

@@ -1,5 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export type ChainJsonRpcApis = Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis;

package/templates/query.hbs

@@ -1,7 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface ChainStorage extends GenericChainStorage {
-  {{{ defTypeOut }}}
-}

package/templates/runtime.hbs

@@ -1,8 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-export interface RuntimeApis extends GenericRuntimeApis {
-{{{ runtimeCallsOut }}}
-}
-

package/templates/tx.hbs

@@ -1,9 +0,0 @@
-// Generated by @dedot/codegen
-
-{{{ importTypes }}}
-
-{{{ defTypes }}}
-
-export interface ChainTx extends GenericChainTx<TxCall> {
-  {{{ txDefsOut }}}
-}