Dedupe wss:// handling in polkadot-types-from-{chain, defs} (#4804)

Author: jacogr

CHANGELOG.md

@@ -6,6 +6,7 @@ Changes:
 
 - Added support for typegen over `Range/RangeInclusive` types
 - Add explicit support for `Call` typegen (inclusive of non-defaults)
+- Deupe `wss://` handling in `polkadot-types-from-{chain, defs}`
 
 
 ## 8.3.2 May 8, 2022

packages/typegen/src/fromChain.ts

@@ -8,10 +8,9 @@ import yargs from 'yargs';
 
 import { Definitions } from '@polkadot/types/types';
 import { formatNumber } from '@polkadot/util';
-import { WebSocket } from '@polkadot/x-ws';
 
 import { generateDefaultConsts, generateDefaultErrors, generateDefaultEvents, generateDefaultQuery, generateDefaultRpc, generateDefaultTx } from './generate';
-import { HEADER, writeFile } from './util';
+import { getMetadataViaWs, HEADER, writeFile } from './util';
 
 function generate (metaHex: HexString, pkg: string | undefined, output: string, isStrict?: boolean): void {
   console.log(`Generating from metadata, ${formatNumber((metaHex.length - 2) / 2)} bytes`);
@@ -78,30 +77,9 @@ export function main (): void {
   }).argv as ArgV;
 
   if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
-    try {
-      const websocket = new WebSocket(endpoint);
-
-      websocket.onclose = (event: { code: number; reason: string }): void => {
-        console.error(`disconnected, code: '${event.code}' reason: '${event.reason}'`);
-        process.exit(1);
-      };
-
-      websocket.onerror = (event: unknown): void => {
-        console.error(event);
-        process.exit(1);
-      };
-
-      websocket.onopen = (): void => {
-        console.log('connected');
-        websocket.send('{"id":"1","jsonrpc":"2.0","method":"state_getMetadata","params":[]}');
-      };
-
-      websocket.onmessage = (message: unknown): void => {
-        generate((JSON.parse((message as Record<string, string>).data) as Record<string, HexString>).result, pkg, output, isStrict);
-      };
-    } catch (error) {
-      process.exit(1);
-    }
+    getMetadataViaWs(endpoint)
+      .then((metadata) => generate(metadata, pkg, output, isStrict))
+      .catch(() => process.exit(1));
   } else {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     generate((require(path.join(process.cwd(), endpoint)) as Record<string, HexString>).result, pkg, output, isStrict);

packages/typegen/src/fromDefs.ts

@@ -7,11 +7,11 @@ import path from 'path';
 import yargs from 'yargs';
 
 import * as substrateDefs from '@polkadot/types/interfaces/definitions';
-import { WebSocket } from '@polkadot/x-ws';
 
 import { generateInterfaceTypes } from './generate/interfaceRegistry';
 import { generateTsDef } from './generate/tsDef';
 import { generateDefaultLookup } from './generate';
+import { getMetadataViaWs } from './util';
 
 type ArgV = { input: string; package: string; endpoint?: string; };
 
@@ -57,42 +57,21 @@ export function main (): void {
     '@polkadot/types/interfaces': filteredBase,
     [pkg]: userDefs
   };
+  const inputPath = path.join(process.cwd(), input);
 
-  generateTsDef(allDefs, path.join(process.cwd(), input), pkg);
-  generateInterfaceTypes(allDefs, path.join(process.cwd(), input, 'augment-types.ts'));
+  generateTsDef(allDefs, inputPath, pkg);
+  generateInterfaceTypes(allDefs, path.join(inputPath, 'augment-types.ts'));
 
   if (endpoint) {
     if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
-      try {
-        const websocket = new WebSocket(endpoint);
-
-        websocket.onclose = (event: { code: number; reason: string }): void => {
-          console.error(`disconnected, code: '${event.code}' reason: '${event.reason}'`);
-          process.exit(1);
-        };
-
-        websocket.onerror = (event: unknown): void => {
-          console.error(event);
-          process.exit(1);
-        };
-
-        websocket.onopen = (): void => {
-          console.log('connected');
-          websocket.send('{"id":"1","jsonrpc":"2.0","method":"state_getMetadata","params":[]}');
-        };
-
-        websocket.onmessage = (message: unknown): void => {
-          generateDefaultLookup(path.join(process.cwd(), input), (JSON.parse((message as Record<string, string>).data) as Record<string, HexString>).result);
-          process.exit(0);
-        };
-      } catch (error) {
-        process.exit(1);
-      }
+      getMetadataViaWs(endpoint)
+        .then((metadata) => generateDefaultLookup(inputPath, metadata))
+        .catch(() => process.exit(1));
     } else {
       // eslint-disable-next-line @typescript-eslint/no-var-requires
       const metaHex = (require(path.join(process.cwd(), endpoint)) as Record<string, HexString>).result;
 
-      generateDefaultLookup(path.join(process.cwd(), input), metaHex);
+      generateDefaultLookup(inputPath, metaHex);
     }
   }
 }

packages/typegen/src/util/index.ts

@@ -8,6 +8,7 @@ export * from './formatting';
 export * from './imports';
 export * from './initMeta';
 export * from './register';
+export * from './wsMeta';
 
 type Cmp = { name: { toString(): string } };
 

packages/typegen/src/util/wsMeta.ts

@@ -0,0 +1,35 @@
+// Copyright 2017-2022 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { HexString } from '@polkadot/util/types';
+
+import { WebSocket } from '@polkadot/x-ws';
+
+export async function getMetadataViaWs (endpoint: string): Promise<HexString> {
+  return new Promise((resolve): void => {
+    try {
+      const websocket = new WebSocket(endpoint);
+
+      websocket.onclose = (event: { code: number; reason: string }): void => {
+        console.error(`disconnected, code: '${event.code}' reason: '${event.reason}'`);
+        process.exit(1);
+      };
+
+      websocket.onerror = (event: unknown): void => {
+        console.error(event);
+        process.exit(1);
+      };
+
+      websocket.onopen = (): void => {
+        console.log('connected');
+        websocket.send('{"id":"1","jsonrpc":"2.0","method":"state_getMetadata","params":[]}');
+      };
+
+      websocket.onmessage = (message: { data: string }): void => {
+        resolve((JSON.parse(message.data) as { result: HexString }).result);
+      };
+    } catch (error) {
+      process.exit(1);
+    }
+  });
+}