support Rust

Author: b00f

src/components/client.ts

@@ -7,7 +7,7 @@ import { promisify } from 'util';
 const writeFile = promisify(fs.writeFile);
 import TOML from '@iarna/toml';
 import { template } from 'lodash';
-import { normalizeMethodName } from './helper';
+import { normalizeMethodNameJavascript, normalizeMethodNameRust, extractParameterNames } from './helper';
 
 const tsTemplate = template(
   `
@@ -213,10 +213,10 @@ export class <%= className %> {
 
   <% openrpcDocument.methods.forEach((method) => { %>
   /**
-   * <%= method.summary %>
+   * <%= method.description %>
    */
   // tslint:disable-next-line:max-line-length
-  public <%= normalizeMethodName(method.name) %>: <%= methodTypings.getTypingNames("typescript", method).method %> = (...params) => {
+  public <%= normalizeMethodNameJavascript(method.name) %>: <%= methodTypings.getTypingNames("typescript", method).method %> = (...params) => {
     return this.request("<%= method.name %>", params);
   }
   <% }); %>
@@ -225,21 +225,54 @@ export default <%= className %>;
 `,
   {
     imports: {
-      normalizeMethodName,
+      normalizeMethodNameJavascript,
     },
   }
 );
 
-const rsTemplate = template(`
-#[macro_use]
-extern crate jsonrpc_client_core;
+const rsTemplate = template(
+  `// @generated
+// Code generated by @open-rpc/generator DO NOT EDIT.
+
+use jsonrpc_client_core::{
+    Transport, RpcRequest, call_method
+};
 
 <%= methodTypings.toString("rust", { includeSchemaTypings: true, includeMethodAliasTypings: false }) %>
 
-jsonrpc_client!(pub struct <%= className %> {
-<%= methodTypings.toString("rust", { includeSchemaTypings: false, includeMethodAliasTypings: true }) %>
-});
-`);
+pub struct <%= className %><T: Transport> {
+  transport: T,
+}
+
+impl <T: Transport> <%= className %><T> {
+
+  pub fn new(transport: T) -> Self {
+    Self { transport }
+  }
+
+<% openrpcDocument.methods.forEach((method) => { %>
+  /**
+   * <%= method.description %>
+   */
+  pub fn <%= normalizeMethodNameRust(method.name) %>(&mut self, <%= methodTypings.getParamsTyping("rust", method) %>) -> RpcRequest<<%= methodTypings.getTypingNames("rust", method).result %>, T::Future> {
+    let method = String::from(stringify!(<%= method.name %>));
+    let params: HashMap<&str, serde_json::Value> = HashMap::from([
+      <% extractParameterNames(methodTypings.getParamsTyping("rust", method)).forEach((paramName, index) => { %>
+      ("<%= paramName %>", serde_json::to_value(<%= paramName %>).unwrap()),
+      <% }); %>
+    ]);
+    call_method(&mut self.transport, method, params)
+  }
+  <% }); %>
+}
+`,
+  {
+    imports: {
+      normalizeMethodNameRust,
+      extractParameterNames,
+    },
+  }
+);
 
 const hooks: IHooks = {
   afterCopyStatic: [

src/components/docs.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
 import { copy, ensureDir, remove } from 'fs-extra';
 import { IHooks, IComponent } from './types';
-import { IDocsConfig, IDocsExtraConfig } from 'src/config';
+import { IDocsExtraConfig } from 'src/config';
 import * as fs from 'fs';
 import { promisify } from 'util';
 import { template, startCase } from 'lodash';
@@ -198,7 +198,7 @@ const hooks: IHooks = {
     ],
   },
   afterCompileTemplate: [
-    async (dest, frm, component, openrpcDocument): Promise<void> => {
+    async (dest, frm, component, _): Promise<void> => {
       const docsComponent = component as IComponent<IDocsExtraConfig>;
       if (!docsComponent.extraConfig) {
         return;

src/components/helper.test.ts

@@ -1,28 +1,104 @@
 import { describe, it, expect } from '@jest/globals';
-import { normalizeMethodName } from './helper';
+import {
+  normalizeMethodNameJavascript,
+  normalizeMethodNameRust,
+  extractParameterNames,
+} from './helper';
 
-describe('normalizeMethodName', () => {
+describe('Test normalizeMethodNameJavascript', () => {
   it('returns the original name if it does not contain a dot', () => {
-    expect(normalizeMethodName('hello')).toBe('hello');
-    expect(normalizeMethodName('foo_bar')).toBe('foo_bar');
+    expect(normalizeMethodNameJavascript('hello')).toBe('hello');
+    expect(normalizeMethodNameJavascript('foo_bar')).toBe('foo_bar');
   });
 
   it('splits and capitalizes correctly with dot', () => {
-    expect(normalizeMethodName('foo.bar')).toBe('fooBar');
-    expect(normalizeMethodName('foo.bar.baz')).toBe('fooBarBaz');
+    expect(normalizeMethodNameJavascript('foo.bar')).toBe('fooBar');
+    expect(normalizeMethodNameJavascript('foo.bar.baz')).toBe('fooBarBaz');
   });
 
   it('capitalizes only subsequent parts', () => {
-    expect(normalizeMethodName('one.two.three')).toBe('oneTwoThree');
+    expect(normalizeMethodNameJavascript('one.two.three')).toBe('oneTwoThree');
   });
 
   it('handles leading/trailing separators gracefully', () => {
-    expect(normalizeMethodName('.foo.bar')).toBe('FooBar');
-    expect(normalizeMethodName('foo.bar.')).toBe('fooBar');
-    expect(normalizeMethodName('..foo..bar..')).toBe('FooBar');
+    expect(normalizeMethodNameJavascript('.foo.bar')).toBe('FooBar');
+    expect(normalizeMethodNameJavascript('foo.bar.')).toBe('fooBar');
+    expect(normalizeMethodNameJavascript('..foo..bar..')).toBe('FooBar');
   });
 
   it('handles empty string', () => {
-    expect(normalizeMethodName('')).toBe('');
+    expect(normalizeMethodNameJavascript('')).toBe('');
+  });
+});
+
+describe('Test normalizeMethodNameRust', () => {
+  it('returns the original name if it does not contain a dot', () => {
+    expect(normalizeMethodNameRust('hello')).toBe('hello');
+    expect(normalizeMethodNameRust('foo_bar')).toBe('foo_bar');
+  });
+
+  it('splits and capitalizes correctly with dot', () => {
+    expect(normalizeMethodNameRust('foo.bar')).toBe('foo_bar');
+    expect(normalizeMethodNameRust('foo.bar.baz')).toBe('foo_bar_baz');
+  });
+
+  it('capitalizes only subsequent parts', () => {
+    expect(normalizeMethodNameRust('one.two.three')).toBe('one_two_three');
+  });
+
+  it('handles leading/trailing separators gracefully', () => {
+    expect(normalizeMethodNameRust('.foo.bar')).toBe('foo_bar');
+    expect(normalizeMethodNameRust('foo.bar.')).toBe('foo_bar');
+    expect(normalizeMethodNameRust('..foo..bar..')).toBe('foo_bar');
+  });
+
+  it('handles empty string', () => {
+    expect(normalizeMethodNameRust('')).toBe('');
+  });
+});
+
+describe('Test extractParameterNames', () => {
+  it('extracts parameter names from a string with types', () => {
+    expect(extractParameterNames('number:int, address: string')).toEqual(['number', 'address']);
+    expect(extractParameterNames('id:number, name:string, active:boolean')).toEqual([
+      'id',
+      'name',
+      'active',
+    ]);
+  });
+
+  it('handles single parameter', () => {
+    expect(extractParameterNames('value:string')).toEqual(['value']);
+  });
+
+  it('handles parameters without types', () => {
+    expect(extractParameterNames('param1, param2, param3')).toEqual(['param1', 'param2', 'param3']);
+  });
+
+  it('handles mixed parameters with and without types', () => {
+    expect(extractParameterNames('id:number, name, active:boolean')).toEqual([
+      'id',
+      'name',
+      'active',
+    ]);
+  });
+
+  it('handles empty string', () => {
+    expect(extractParameterNames('')).toEqual([]);
+  });
+
+  it('handles string with only whitespace', () => {
+    expect(extractParameterNames('   ')).toEqual([]);
+  });
+
+  it('handles parameters with extra whitespace', () => {
+    expect(extractParameterNames('  number : int  ,  address : string  ')).toEqual([
+      'number',
+      'address',
+    ]);
+  });
+
+  it('filters out empty parameter names', () => {
+    expect(extractParameterNames('valid:type, , another:type')).toEqual(['valid', 'another']);
   });
 });

src/components/helper.ts

@@ -1,4 +1,6 @@
-export function normalizeMethodName(name: string): string {
+// This function is used in the template files to normalize method names for JavaScript/TypeScript.
+// It removes dots and applies camelCase formatting.
+export function normalizeMethodNameJavascript(name: string): string {
   // backward compatibility only change on dot inside in name.
   if (!name.includes('.')) return name;
 
@@ -7,3 +9,35 @@ export function normalizeMethodName(name: string): string {
     .map((part, index) => (index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
     .join('');
 }
+
+// This function is used in the template files to normalize method names for Rust.
+// It replace dots with underscores and applies snake_case formatting.
+export function normalizeMethodNameRust(name: string): string {
+  // backward compatibility only change on dot inside in name.
+  if (!name.includes('.')) return name;
+
+  name = name.replace(/\./g, '_');
+  name = name.toLowerCase();
+  name = name.replace(/__+/g, '_'); // replace multiple underscores with a single underscore
+  while (name.startsWith('_')) {
+    name = name.slice(1); // remove leading underscore
+  }
+  while (name.endsWith('_')) {
+    name = name.slice(0, -1); // remove trailing underscore
+  }
+
+  return name;
+}
+
+// Extract parameter names from a parameter string into an array
+export function extractParameterNames(paramStr: string): string[] {
+  if (!paramStr || paramStr.trim() === '') {
+    return [];
+  }
+
+  return paramStr
+    .split(',')
+    .map((param) => param.trim())
+    .map((param) => param.split(':')[0].trim())
+    .filter((name) => name.length > 0);
+}

src/index.test.ts

@@ -7,7 +7,6 @@ import { forEach } from 'lodash';
 import { OpenRPCDocumentDereferencingError } from '@open-rpc/schema-utils-js';
 import { OpenrpcDocument as OpenRPC } from '@open-rpc/meta-schema';
 import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { isMapIterator } from 'util/types';
 
 const stat = promisify(fs.stat);
 const rmdir = promisify(fs.rmdir);

src/index.ts

@@ -5,17 +5,15 @@ import { promisify } from 'util';
 import { startCase } from 'lodash';
 import { OpenrpcDocument as OpenRPC } from '@open-rpc/meta-schema';
 import { parseOpenRPCDocument } from '@open-rpc/schema-utils-js';
-import { IDocsConfig, TComponentConfig } from './config';
+import { TComponentConfig } from './config';
 import Typings from '@open-rpc/typings';
 
 import {
   defaultClientComponent,
   defaultDocComponent,
   defaultServerComponent,
   IComponentModule,
-  IHooks,
   FHook,
-  getDefaultComponentTemplatePath,
   IComponent,
 } from './components';
 export * as components from './components';