@pezkuwi/typegen 16.5.18 → 16.5.31

package/src/generate/query.ts

@@ -1,169 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { StorageEntryMetadataLatest } from '@pezkuwi/types/interfaces';
-import type { Metadata, PortableRegistry } from '@pezkuwi/types/metadata';
-import type { Definitions, Registry } from '@pezkuwi/types/types';
-import type { HexString } from '@pezkuwi/util/types';
-import type { ModuleTypes, TypeImports } from '../util/imports.js';
-
-import Handlebars from 'handlebars';
-
-import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
-import { unwrapStorageSi } from '@pezkuwi/types/util';
-import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
-import { stringCamelCase } from '@pezkuwi/util';
-
-import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
-import { ignoreUnusedLookups } from './lookup.js';
-import { type ExtraTypes, getDeprecationNotice } from './types.js';
-
-const generateForMetaTemplate = Handlebars.compile(readTemplate('query'));
-
-// From a storage entry metadata, we return [args, returnType]
-/** @internal */
-function entrySignature (lookup: PortableRegistry, allDefs: Record<string, ModuleTypes>, registry: Registry, section: string, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [boolean, string, string, string] {
-  try {
-    const outputType = lookup.getTypeDef(unwrapStorageSi(storageEntry.type));
-
-    if (storageEntry.type.isPlain) {
-      const typeDef = lookup.getTypeDef(storageEntry.type.asPlain);
-
-      setImports(allDefs, imports, [
-        rebrandTypeName(typeDef.lookupName || typeDef.type),
-        storageEntry.modifier.isOptional
-          ? 'Option'
-          : null
-      ]);
-
-      return [storageEntry.modifier.isOptional, '', '', formatType(registry, allDefs, outputType, imports)];
-    } else if (storageEntry.type.isMap) {
-      const { hashers, key, value } = storageEntry.type.asMap;
-      const keyDefs = hashers.length === 1
-        ? [lookup.getTypeDef(key)]
-        : lookup.getSiType(key).def.asTuple.map((k) => lookup.getTypeDef(k));
-      const similarTypes = keyDefs.map((k) => getSimilarTypes(registry, allDefs, k.lookupName || k.type, imports));
-      const keyTypes = similarTypes.map((t) => t.join(' | '));
-      const defValue = lookup.getTypeDef(value);
-
-      setImports(allDefs, imports, [
-        ...similarTypes.reduce<string[]>((all, t) => all.concat(t), []),
-        storageEntry.modifier.isOptional
-          ? 'Option'
-          : null,
-        rebrandTypeName(defValue.lookupName || defValue.type)
-      ]);
-
-      return [
-        storageEntry.modifier.isOptional,
-        keyDefs.map((k) => formatType(registry, allDefs, k.lookupName || k.type, imports)).join(', '),
-        keyTypes.map((t, i) => `arg${keyTypes.length === 1 ? '' : (i + 1)}: ${t}`).join(', '),
-        rebrandTypeName(outputType.lookupName || '') || formatType(registry, allDefs, outputType, imports)
-      ];
-    }
-
-    throw new Error(`Expected Plain or Map type, found ${storageEntry.type.type}`);
-  } catch (error) {
-    throw new Error(`entrySignature: Cannot create signature for query ${section}.${storageEntry.name.toString()}:: ${(error as Error).message}`);
-  }
-}
-
-/** @internal */
-function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
-  writeFile(dest, (): string => {
-    const allTypes: ExtraTypes = {
-      '@pezkuwi/types-augment': {
-        lookup: {
-          ...lookupDefinitions,
-          ...customLookupDefinitions
-        }
-      },
-      '@pezkuwi/types/interfaces': defaultDefs,
-      ...extraTypes
-    };
-
-    const imports = createImports(allTypes);
-    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-    }, {});
-    const { lookup, pallets } = meta.asLatest;
-    const usedTypes = new Set<string>([]);
-    const modules = pallets
-      .filter(({ storage }) => storage.isSome)
-      .map(({ name, storage }) => {
-        const items = storage.unwrap().items
-          .map((storageEntry) => {
-            const { deprecationInfo, docs, name } = storageEntry;
-            const [isOptional, args, params, _returnType] = entrySignature(lookup, allDefs, registry, name.toString(), storageEntry, imports);
-
-            if (!deprecationInfo.isNotDeprecated) {
-              const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name));
-              const items = docs.length
-                ? ['', deprecationNotice]
-                : [deprecationNotice];
-
-              docs.push(...items.map((text) => registry.createType('Text', text)));
-            }
-
-            // Add the type and args to the list of used types
-            if (!(imports.primitiveTypes[_returnType])) {
-              usedTypes.add(_returnType);
-            }
-
-            if (!(imports.primitiveTypes[args])) {
-              usedTypes.add(args);
-            }
-
-            const returnType = isOptional
-              ? `Option<${_returnType}>`
-              : _returnType;
-
-            return {
-              args,
-              docs,
-              entryType: 'AugmentedQuery',
-              name: stringCamelCase(storageEntry.name),
-              params,
-              returnType
-            };
-          })
-          .sort(compareName);
-
-        return {
-          items,
-          name: stringCamelCase(name)
-        };
-      })
-      .sort(compareName);
-
-    imports.typesTypes['Observable'] = true;
-
-    // filter out the unused lookup types from imports
-    ignoreUnusedLookups([...usedTypes], imports);
-
-    return generateForMetaTemplate({
-      headerType: 'chain',
-      imports,
-      isStrict,
-      modules,
-      types: [
-        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
-          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-          types: Object.keys(imports.localTypes[packagePath])
-        })),
-        {
-          file: '@pezkuwi/api-base/types',
-          types: ['ApiTypes', 'AugmentedQuery', 'QueryableStorageEntry']
-        }
-      ]
-    });
-  });
-}
-
-// Call `generateForMeta()` with current static metadata
-/** @internal */
-export function generateDefaultQuery (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
-  const { metadata, registry } = initMeta(data, extraTypes);
-
-  return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/src/generate/rpc.ts

@@ -1,158 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { TypeRegistry } from '@pezkuwi/types/create';
-import type { Definitions } from '@pezkuwi/types/types';
-import type { ExtraTypes } from './types.js';
-
-import Handlebars from 'handlebars';
-
-import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
-import staticBizinikiwi from '@pezkuwi/types-support/metadata/static-bizinikiwi';
-
-import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
-
-interface ItemDef {
-  args: string;
-  docs: string[];
-  generic: string | undefined;
-  name: string;
-  type: string | undefined;
-}
-
-interface ModuleDef {
-  items: ItemDef[];
-  name: string;
-}
-
-const StorageKeyType = 'StorageKey | string | Uint8Array | any';
-
-const generateRpcTypesTemplate = Handlebars.compile(readTemplate('rpc'));
-
-/** @internal */
-export function generateRpcTypes (registry: TypeRegistry, importDefinitions: Record<string, Definitions>, dest: string, extraTypes: ExtraTypes): void {
-  writeFile(dest, (): string => {
-    const allTypes: ExtraTypes = { '@pezkuwi/types/interfaces': importDefinitions, ...extraTypes };
-    const imports = createImports(allTypes);
-    const definitions = imports.definitions as Record<string, Definitions>;
-    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-    }, {});
-
-    const rpcKeys = Object
-      .keys(definitions)
-      .filter((key) => Object.keys(definitions[key].rpc || {}).length !== 0)
-      .sort();
-
-    const additional: Record<string, ModuleDef> = {};
-    const modules = rpcKeys.map((sectionFullName) => {
-      const rpc = definitions[sectionFullName].rpc || {};
-      const section = sectionFullName.split('/').pop();
-
-      const allMethods = Object.keys(rpc).sort().map((methodName) => {
-        const def = rpc[methodName];
-
-        let args;
-        let type;
-        let generic;
-
-        // These are too hard to type with generics, do manual overrides
-        if (section === 'state') {
-          setImports(allDefs, imports, ['Codec', 'Hash', 'StorageKey', 'Vec']);
-
-          if (methodName === 'getStorage') {
-            generic = 'T = Codec';
-            args = [`key: ${StorageKeyType}, block?: Hash | Uint8Array | string`];
-            type = 'T';
-          } else if (methodName === 'queryStorage') {
-            generic = 'T = Codec[]';
-            args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string`];
-            type = '[Hash, T][]';
-          } else if (methodName === 'queryStorageAt') {
-            generic = 'T = Codec[]';
-            args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], at?: Hash | Uint8Array | string`];
-            type = 'T';
-          } else if (methodName === 'subscribeStorage') {
-            generic = 'T = Codec[]';
-            args = [`keys?: Vec<StorageKey> | (${StorageKeyType})[]`];
-            type = 'T';
-          }
-        }
-
-        if (args === undefined) {
-          setImports(allDefs, imports, [def.type]);
-
-          args = def.params.map((param) => {
-            const similarTypes = getSimilarTypes(registry, definitions, param.type, imports);
-
-            setImports(allDefs, imports, [param.type, ...similarTypes]);
-
-            return `${param.name}${param.isOptional ? '?' : ''}: ${similarTypes.join(' | ')}`;
-          });
-
-          type = formatType(registry, allDefs, def.type, imports);
-          generic = '';
-        }
-
-        const item = {
-          args: args.join(', '),
-          docs: def.deprecated
-            ? [`@deprecated ${def.deprecated}`, def.description]
-            : [def.description],
-          generic,
-          name: methodName,
-          type
-        };
-
-        if (def.aliasSection) {
-          if (!additional[def.aliasSection]) {
-            additional[def.aliasSection] = {
-              items: [],
-              name: def.aliasSection
-            };
-          }
-
-          additional[def.aliasSection].items.push(item);
-
-          return null;
-        }
-
-        return item;
-      }).filter((item): item is ItemDef => !!item);
-
-      return {
-        items: allMethods,
-        name: section || 'unknown'
-      };
-    }).concat(...Object.values(additional)).sort((a, b) => a.name.localeCompare(b.name));
-
-    imports.typesTypes['Observable'] = true;
-
-    return generateRpcTypesTemplate({
-      headerType: 'chain',
-      imports,
-      modules,
-      types: [
-        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
-          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-          types: Object.keys(imports.localTypes[packagePath])
-        })),
-        {
-          file: '@pezkuwi/rpc-core/types',
-          types: ['AugmentedRpc']
-        }
-      ]
-    });
-  });
-}
-
-export function generateDefaultRpc (dest = 'packages/rpc-augment/src/augment/jsonrpc.ts', extraTypes: ExtraTypes = {}): void {
-  const { registry } = initMeta(staticBizinikiwi, extraTypes);
-
-  generateRpcTypes(
-    registry,
-    defaultDefinitions,
-    dest,
-    extraTypes
-  );
-}

package/src/generate/runtime.ts

@@ -1,293 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { RuntimeApiMethodMetadataV16, SiLookupTypeId } from '@pezkuwi/types/interfaces';
-import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
-import type { DefinitionCall, DefinitionCallNamed, Definitions, DefinitionsCall, Registry } from '@pezkuwi/types/types';
-import type { Vec } from '@pezkuwi/types-codec';
-import type { HexString } from '@pezkuwi/util/types';
-
-import Handlebars from 'handlebars';
-
-import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
-import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
-import { objectSpread, stringCamelCase } from '@pezkuwi/util';
-import { blake2AsHex } from '@pezkuwi/util-crypto';
-
-import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
-import { type ExtraTypes, getDeprecationNotice } from './types.js';
-
-type Apis = [HexString, number][];
-
-const generateCallsTypesTemplate = Handlebars.compile(readTemplate('calls'));
-
-// This works similar to the PATHS_ALIAS set from the PortableRegistry
-const aliases: Record<string, string> = {
-  AssetHubZagrosRuntimeRuntimeCall: 'RuntimeCall',
-  AssetHubPezkuwiRuntimeRuntimeCall: 'RuntimeCall',
-  AssetHubDicleRuntimeOriginCaller: 'OriginCaller',
-  AssetHubDicleRuntimeRuntimeCall: 'RuntimeCall',
-  DicleRuntimeConstantsProxyProxyType: 'ProxyType',
-  KitchensinkRuntimeRuntimeCall: 'RuntimeCall',
-  KitchensinkRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
-  OpaqueValue: 'Bytes',
-  PezkuwiTeyrchainPrimitivesPrimitivesId: 'ParaId',
-  PezkuwiTeyrchainPrimitivesPrimitivesValidationCodeHash: 'ValidationCodeHash',
-  PezkuwiPrimitivesV7SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-  PezkuwiPrimitivesV8SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-  PezkuwiRuntimeRuntimeCall: 'RuntimeCall',
-  PrimitiveTypesH160: 'H160',
-  PrimitiveTypesH256: 'H256',
-  PrimitiveTypesU256: 'U256',
-  PezspConsensusBabeOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-  PezspConsensusSlotsSlot: 'Slot',
-  PezspConsensusSlotsSlotDuration: 'SlotDuration',
-  PezspCoreCryptoAccountId32: 'AccountId32',
-  PezspCoreOpaqueMetadata: 'OpaqueMetadata',
-  PezspRuntimeOpaqueValue: 'Bytes',
-  PezspRuntimeUncheckedExtrinsic: 'Extrinsic',
-  StagingDicleRuntimeOriginCaller: 'OriginCaller',
-  StagingDicleRuntimeRuntimeCall: 'RuntimeCall',
-  StagingDicleRuntimeRuntimeParameters: 'RuntimeParameters',
-  StagingDicleRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
-  StagingZagrosRuntimeRuntimeCall: 'RuntimeCall'
-};
-
-const getTypesViaAlias = (registry: Registry, id: SiLookupTypeId) => {
-  const rawTypeName = registry.lookup.getName(id) || registry.lookup.getTypeDef(id).type;
-  const typeName = rebrandTypeName(rawTypeName);
-
-  if (aliases[typeName]) {
-    return aliases[typeName];
-  }
-
-  return typeName;
-};
-
-/** @internal */
-function getMethods (registry: Registry, methods: Vec<RuntimeApiMethodMetadataV16>) {
-  const result: Record<string, DefinitionCall> = {};
-
-  methods.forEach((m) => {
-    const { deprecationInfo, docs, inputs, name, output } = m;
-    let description = docs.map((d) => d.toString()).join();
-
-    if (!deprecationInfo.isNotDeprecated) {
-      const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name));
-      const notice = description.length ? `\n * ${deprecationNotice}` : ` * ${deprecationNotice}`;
-
-      description += notice;
-    }
-
-    result[name.toString()] = {
-      description,
-      params: inputs.map(({ name, type }) => {
-        return { name: name.toString(), type: getTypesViaAlias(registry, type) };
-      }),
-      type: getTypesViaAlias(registry, output)
-    };
-  });
-
-  return result;
-}
-
-/** @internal */
-function getRuntimeDefViaMetadata (registry: Registry) {
-  const result: DefinitionsCall = {};
-  const { apis } = registry.metadata;
-
-  for (let i = 0, count = apis.length; i < count; i++) {
-    const { methods, name } = apis[i];
-
-    result[name.toString()] = [{
-      methods: getMethods(registry, methods),
-      // We set the version to 0 here since it will not be relevant when we are grabbing the runtime apis
-      // from the Metadata.
-      version: 0
-    }];
-  }
-
-  return Object.entries(result);
-}
-
-/** @internal */
-function getDefs (apis: Apis | null, defs: Record<string, Definitions>, registry: Registry): Record<string, Record<string, DefinitionCallNamed>> {
-  const named: Record<string, Record<string, DefinitionCallNamed>> = {};
-  const all = Object.values(defs);
-  const isApiInMetadata = registry.metadata.apis.length > 0;
-
-  if (isApiInMetadata) {
-    const sections = getRuntimeDefViaMetadata(registry);
-
-    for (let j = 0, jcount = sections.length; j < jcount; j++) {
-      const [_section, secs] = sections[j];
-      const sec = secs[0];
-      const sectionHash = blake2AsHex(_section, 64);
-
-      const section = stringCamelCase(_section);
-      const methods = Object.entries(sec.methods);
-
-      if (!named[section]) {
-        named[section] = {};
-      }
-
-      for (let m = 0, mcount = methods.length; m < mcount; m++) {
-        const [_method, def] = methods[m];
-        const method = stringCamelCase(_method);
-
-        named[section][method] = objectSpread({ method, name: `${_section}_${_method}`, section, sectionHash }, def);
-      }
-    }
-  } else {
-    for (let j = 0, jcount = all.length; j < jcount; j++) {
-      const set = all[j].runtime;
-
-      if (set) {
-        const sections = Object.entries(set);
-
-        for (let i = 0, scount = sections.length; i < scount; i++) {
-          const [_section, sec] = sections[i];
-          const sectionHash = blake2AsHex(_section, 64);
-          const api = apis?.find(([h]) => h === sectionHash);
-
-          if (api) {
-            const ver = sec.find(({ version }) => version === api[1]);
-
-            if (ver) {
-              const methods = Object.entries(ver.methods);
-              const mcount = methods.length;
-
-              if (mcount) {
-                const section = stringCamelCase(_section);
-
-                if (!named[section]) {
-                  named[section] = {};
-                }
-
-                for (let m = 0; m < mcount; m++) {
-                  const [_method, def] = methods[m];
-                  const method = stringCamelCase(_method);
-
-                  named[section][method] = objectSpread({ method, name: `${_section}_${method}`, section, sectionHash, version: ver.version }, def);
-                }
-              }
-            } else {
-              console.warn(`Unable to find matching version for runtime ${_section}, expected ${api[1]}`);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return named;
-}
-
-/** @internal */
-export function generateCallTypes (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
-  writeFile(dest, (): string => {
-    const allTypes: ExtraTypes = {
-      '@pezkuwi/types-augment': {
-        lookup: {
-          ...lookupDefinitions,
-          ...customLookupDefinitions
-        }
-      },
-      '@pezkuwi/types/interfaces': defaultDefs,
-      ...extraTypes
-    };
-    const imports = createImports(allTypes);
-
-    // find the system.Version in metadata
-    let apis: Apis | null = null;
-    const sysp = meta.asLatest.pallets.find(({ name }) => name.eq('System'));
-
-    if (sysp) {
-      const verc = sysp.constants.find(({ name }) => name.eq('Version'));
-
-      if (verc) {
-        apis = registry.createType('RuntimeVersion', verc.value).apis.map(([k, v]): [HexString, number] => [k.toHex(), v.toNumber()]);
-      } else {
-        console.error('Unable to find System.Version pallet, skipping API extraction');
-      }
-    } else {
-      console.error('Unable to find System pallet, skipping API extraction');
-    }
-
-    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-    }, {});
-    const definitions = getDefs(apis, imports.definitions as Record<string, Definitions>, registry);
-    const callKeys = Object.keys(definitions);
-
-    const modules = callKeys.map((section) => {
-      const calls = definitions[section];
-
-      const allMethods = Object.keys(calls).sort().map((methodName) => {
-        const def = calls[methodName];
-
-        setImports(allDefs, imports, [def.type]);
-
-        const args = def.params.map((param) => {
-          const similarTypes = getSimilarTypes(registry, imports.definitions, param.type, imports);
-
-          setImports(allDefs, imports, [param.type, ...similarTypes]);
-
-          return `${param.name}: ${similarTypes.join(' | ')}`;
-        });
-
-        return {
-          args: args.join(', '),
-          docs: [def.description],
-          name: methodName,
-          sectionHash: def.sectionHash,
-          sectionName: def.section,
-          sectionVersion: def.version,
-          type: formatType(registry, allDefs, def.type, imports)
-        };
-      }).sort((a, b) => a.name.localeCompare(b.name));
-
-      return {
-        items: allMethods,
-        name: section || 'unknown',
-        sectionHash: allMethods.length && allMethods[0].sectionHash,
-        sectionName: allMethods.length && allMethods[0].sectionName,
-        sectionVersion: allMethods.length && allMethods[0].sectionVersion
-      };
-    }).filter(({ items }) => items.length).sort((a, b) => a.name.localeCompare(b.name));
-
-    if (modules.length) {
-      imports.typesTypes['Observable'] = true;
-    }
-
-    return generateCallsTypesTemplate({
-      headerType: 'chain',
-      imports,
-      isStrict,
-      modules,
-      types: [
-        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
-          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-          types: Object.keys(imports.localTypes[packagePath])
-        })),
-        {
-          file: '@pezkuwi/api-base/types',
-          types: ['ApiTypes', 'AugmentedCall', 'DecoratedCallBase']
-        }
-      ]
-    });
-  });
-}
-
-export function generateDefaultRuntime (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
-  const { metadata, registry } = initMeta(data, extraTypes);
-
-  generateCallTypes(
-    registry,
-    metadata,
-    dest,
-    extraTypes,
-    isStrict,
-    customLookupDefinitions
-  );
-}