Infer concrete types from constructor TypeClass forms

Author: minggangw

demo/typescript/topics/src/publisher.ts

@@ -3,6 +3,15 @@
  *
  * This demo shows how to create a ROS2 publisher using TypeScript
  * with rclnodejs. It publishes string messages to the "ts_demo" topic.
+ *
+ * It also demonstrates the two equivalent, fully type-safe ways to
+ * identify a message type:
+ *   - String name:   node.createPublisher('std_msgs/msg/String', ...)
+ *   - Message class: node.createPublisher(StringMsg, ...)
+ *
+ * With the class form (obtained from `rclnodejs.require(...)`), TypeScript
+ * infers the publisher's message type directly from the constructor, so
+ * `new StringMsg()` is typed without any explicit annotation.
  */
 
 import * as rclnodejs from 'rclnodejs';
@@ -25,22 +34,35 @@ async function main(): Promise<void> {
     const node = new rclnodejs.Node('ts_publisher_demo');
     console.log(`✓ Created node: ${node.getFullyQualifiedName()}`);
 
-    // Create a publisher for std_msgs/msg/String messages
+    // Style A — string name. Create a publisher for std_msgs/msg/String
+    // messages, building each message with `createMessageObject`:
     const publisher = node.createPublisher('std_msgs/msg/String', TOPIC_NAME);
     console.log(`✓ Created publisher on topic: ${TOPIC_NAME}`);
 
+    // Style B — message class. Obtain the constructor with
+    // `rclnodejs.require(...)` and pass it directly. The publisher's message
+    // type is inferred from the constructor, and `new StringMsg()` is typed
+    // without any annotation. Both styles are equally type-safe.
+    const StringMsg = rclnodejs.require('std_msgs/msg/String');
+    const typedPublisher = node.createPublisher(StringMsg, TOPIC_NAME);
+
     // Message counter
     let messageCount = 0;
 
     // Create a timer to publish messages at regular intervals
     const timer = node.createTimer(PUBLISH_INTERVAL, () => {
-      // Create a string message
+      // Style A — build the message with createMessageObject:
       const message = rclnodejs.createMessageObject('std_msgs/msg/String');
       message.data = `Hello from TypeScript publisher! Message #${++messageCount} at ${new Date().toISOString()}`;
-
-      // Publish the message
       publisher.publish(message);
-      console.log(`📤 Published: "${message.data}"`);
+      console.log(`📤 [A/string] Published: "${message.data}"`);
+
+      // Style B — build the message by instantiating the class. The
+      // `data` field is typed from the inferred message type.
+      const typedMessage = new StringMsg();
+      typedMessage.data = `Hello from typed publisher! Message #${messageCount}`;
+      typedPublisher.publish(typedMessage);
+      console.log(`📤 [B/class] Published: "${typedMessage.data}"`);
     });
 
     console.log(`✓ Created timer with ${PUBLISH_INTERVAL}ms interval`);

demo/typescript/topics/src/subscriber.ts

@@ -3,6 +3,15 @@
  *
  * This demo shows how to create a ROS2 subscriber using TypeScript
  * with rclnodejs. It subscribes to string messages from the "ts_demo" topic.
+ *
+ * It also demonstrates the two equivalent, fully type-safe ways to
+ * identify a message type:
+ *   - String name:   node.createSubscription('std_msgs/msg/String', ...)
+ *   - Message class: node.createSubscription(StringMsg, ...)
+ *
+ * With the class form (obtained from `rclnodejs.require(...)`), TypeScript
+ * infers the callback's message type directly from the constructor, so no
+ * explicit `message` annotation is needed.
  */
 
 import * as rclnodejs from 'rclnodejs';
@@ -27,17 +36,30 @@ async function main(): Promise<void> {
     // Message counter
     let receivedCount = 0;
 
-    // Create a subscription for std_msgs/msg/String messages
+    // Create a subscription for std_msgs/msg/String messages.
+    //
+    // Style A — string name. The callback message type is annotated
+    // explicitly as rclnodejs.std_msgs.msg.String:
     const subscription = node.createSubscription(
       'std_msgs/msg/String',
       TOPIC_NAME,
       (message: rclnodejs.std_msgs.msg.String) => {
         receivedCount++;
-        console.log(`📥 [${receivedCount}] Received: "${message.data}"`);
-        console.log(`    Timestamp: ${new Date().toISOString()}`);
+        console.log(
+          `📥 [A/string] [${receivedCount}] Received: "${message.data}"`
+        );
       }
     );
 
+    // Style B — message class. Obtain the constructor with
+    // `rclnodejs.require(...)` and pass it directly. The `message`
+    // parameter type is inferred as rclnodejs.std_msgs.msg.String, so no
+    // explicit annotation is required. Both styles are equally type-safe.
+    const StringMsg = rclnodejs.require('std_msgs/msg/String');
+    node.createSubscription(StringMsg, TOPIC_NAME, (message) => {
+      console.log(`📥 [B/class] Received: "${message.data}"`);
+    });
+
     console.log(`✓ Created subscription on topic: ${TOPIC_NAME}`);
     console.log('👂 Subscriber is listening. Press Ctrl+C to stop...\n');
 

rostsd_gen/index.js

@@ -164,7 +164,7 @@ function savePkgInfoAsTSD(pkgInfos, fd) {
   fs.writeSync(fd, '  type Message = MessagesMap[MessageTypeClassName];\n');
   fs.writeSync(
     fd,
-    '  type MessageType<T> = T extends MessageTypeClassName ? MessagesMap[T] : object;\n\n'
+    '  type MessageType<T> = T extends MessageTypeClassName ? MessagesMap[T] : T extends new (...args: any[]) => infer R ? R : object;\n\n'
   );
 
   // write message contructor mappings
@@ -193,7 +193,7 @@ function savePkgInfoAsTSD(pkgInfos, fd) {
   fs.writeSync(fd, '  type Service = ServicesMap[ServiceTypeClassName];\n');
   fs.writeSync(
     fd,
-    '  type ServiceType<T> = T extends ServiceTypeClassName ? ServicesMap[T] : object;\n\n'
+    '  type ServiceType<T> = T extends ServiceTypeClassName ? ServicesMap[T] : T extends { Request: any; Response: any } ? T : object;\n\n'
   );
 
   // write actions type mappings
@@ -206,7 +206,7 @@ function savePkgInfoAsTSD(pkgInfos, fd) {
   fs.writeSync(fd, '  type Action = ActionsMap[ActionTypeClassName];\n');
   fs.writeSync(
     fd,
-    '  type ActionType<T> = T extends ActionTypeClassName ? ActionsMap[T] : object;\n\n'
+    '  type ActionType<T> = T extends ActionTypeClassName ? ActionsMap[T] : T extends { Goal: any; Feedback: any; Result: any } ? T : object;\n\n'
   );
 
   fs.writeSync(

test/types/index.test-d.ts

@@ -211,6 +211,24 @@ node.createPublisher(TYPE_CLASS, TOPIC, publisher.options, (event: object) => {
 expectType<void>(publisher.assertLiveliness());
 expectType<string>(publisher.loggerName);
 
+// ---- TypeClass forms ----
+// Case 1: a message/service class constructor (e.g. the value returned by rclnodejs.require)
+const StringClass = rclnodejs.require('std_msgs/msg/String');
+expectAssignable<rclnodejs.TypeClass>(StringClass);
+const publisherFromCtor = node.createPublisher(StringClass, TOPIC);
+expectType<rclnodejs.Publisher<typeof StringClass>>(publisherFromCtor);
+
+// Case 2: a string representing the message class name
+expectAssignable<rclnodejs.TypeClass>(TYPE_CLASS);
+const publisherFromString = node.createPublisher(TYPE_CLASS, TOPIC);
+expectType<rclnodejs.Publisher<'std_msgs/msg/String'>>(publisherFromString);
+
+// Case 3: an object descriptor of the message class
+const typeDescriptor = { package: 'std_msgs', type: 'msg', name: 'String' };
+expectAssignable<rclnodejs.TypeClass>(typeDescriptor);
+const publisherFromDescriptor = node.createPublisher(typeDescriptor, TOPIC);
+expectType<rclnodejs.Publisher<typeof typeDescriptor>>(publisherFromDescriptor);
+
 // ---- LifecyclePublisher ----
 const lifecyclePublisher = lifecycleNode.createLifecyclePublisher(
   TYPE_CLASS,
@@ -343,6 +361,30 @@ expectType<void>(
 expectType<boolean>(client.isDestroyed());
 expectType<string>(client.loggerName);
 
+// ---- Service/Client constructor-form typing ----
+// Passing a service constructor (the value returned by rclnodejs.require) should
+// infer the concrete request/response message types, not fall back to `object`.
+const AddTwoInts = rclnodejs.require('example_interfaces/srv/AddTwoInts');
+const serviceFromCtor = node.createService(
+  AddTwoInts,
+  'add_two_ints_ctor',
+  (request) => {
+    expectType<rclnodejs.example_interfaces.srv.AddTwoInts_Request>(request);
+  }
+);
+expectType<rclnodejs.example_interfaces.srv.AddTwoIntsConstructor>(
+  serviceFromCtor
+);
+
+const clientFromCtor = node.createClient(AddTwoInts, 'add_two_ints_ctor');
+expectType<rclnodejs.Client<typeof AddTwoInts>>(clientFromCtor);
+clientFromCtor.sendRequest(new AddTwoInts.Request(), (response) => {
+  expectType<rclnodejs.example_interfaces.srv.AddTwoInts_Response>(response);
+});
+expectType<Promise<rclnodejs.example_interfaces.srv.AddTwoInts_Response>>(
+  clientFromCtor.sendRequestAsync(new AddTwoInts.Request())
+);
+
 // ---- Timer ----
 const timerCallback: rclnodejs.TimerRequestCallback = (timerInfo) => {
   if (timerInfo) {
@@ -602,6 +644,25 @@ expectType<void>(
   )
 );
 
+// ---- Action constructor-form typing ----
+// Passing an action constructor (the value returned by rclnodejs.require) should
+// infer the concrete goal/feedback/result message types, not fall back to `object`.
+const actionClientFromCtor = new rclnodejs.ActionClient(
+  node,
+  Fibonacci,
+  'fibonacci_ctor'
+);
+expectType<rclnodejs.ActionClient<typeof Fibonacci>>(actionClientFromCtor);
+expectType<rclnodejs.example_interfaces.action.Fibonacci_Goal>(
+  {} as rclnodejs.ActionGoal<typeof Fibonacci>
+);
+expectType<rclnodejs.example_interfaces.action.Fibonacci_Feedback>(
+  {} as rclnodejs.ActionFeedback<typeof Fibonacci>
+);
+expectType<rclnodejs.example_interfaces.action.Fibonacci_Result>(
+  {} as rclnodejs.ActionResult<typeof Fibonacci>
+);
+
 // ---- ActionUuid -----
 const actionUuid = new rclnodejs.ActionUuid();
 expectType<rclnodejs.ActionUuid>(actionUuid);

types/action_client.d.ts

@@ -1,13 +1,19 @@
 declare module 'rclnodejs' {
   type ActionGoal<T> = T extends ActionTypeClassName
     ? InstanceType<ActionsMap[T]['Goal']>
-    : object;
+    : T extends { Goal: new (...args: any[]) => infer R }
+      ? R
+      : object;
   type ActionFeedback<T> = T extends ActionTypeClassName
     ? InstanceType<ActionsMap[T]['Feedback']>
-    : object;
+    : T extends { Feedback: new (...args: any[]) => infer R }
+      ? R
+      : object;
   type ActionResult<T> = T extends ActionTypeClassName
     ? InstanceType<ActionsMap[T]['Result']>
-    : object;
+    : T extends { Result: new (...args: any[]) => infer R }
+      ? R
+      : object;
 
   /**
    * Goal handle for working with Action Clients.

types/node.d.ts

@@ -3,10 +3,24 @@ declare module 'rclnodejs' {
    * Identifies type of ROS message such as msg or srv.
    */
   type TypeClass<T = TypeClassName> =
-    | (() => any)
-    | T // a string representing the message class, e.g. 'std_msgs/msg/String',
+    | (new (...args: any[]) => any) // a message class constructor, e.g. the value returned by rclnodejs.require('std_msgs/msg/String')
     | {
-        // object representing a message class, e.g. {package: 'std_msgs', type: 'msg', name: 'String'}
+        // a service class constructor, e.g. the value returned by rclnodejs.require('example_interfaces/srv/AddTwoInts')
+        readonly Request: new (...args: any[]) => any;
+        readonly Response: new (...args: any[]) => any;
+      }
+    | {
+        // an action class constructor, e.g. the value returned by rclnodejs.require('example_interfaces/action/Fibonacci')
+        readonly Goal: new (...args: any[]) => any;
+        readonly Feedback: new (...args: any[]) => any;
+        readonly Result: new (...args: any[]) => any;
+      }
+    | T // a string representing the message/service/action class, e.g. 'std_msgs/msg/String',
+    | {
+        // object representing a message class, e.g. {package: 'std_msgs', type: 'msg', name: 'String'}.
+        // NOTE: this form is supported at runtime but provides no message type inference in
+        // TypeScript (messages resolve to `object`). Prefer the string or constructor form for
+        // full type safety.
         package: string;
         type: string;
         name: string;

types/service.d.ts

@@ -1,11 +1,15 @@
 declare module 'rclnodejs' {
   type ServiceRequestMessage<T> = T extends ServiceTypeClassName
     ? InstanceType<ServicesMap[T]['Request']>
-    : object;
+    : T extends { Request: new (...args: any[]) => infer R }
+      ? R
+      : object;
 
   type ServiceResponseMessage<T> = T extends ServiceTypeClassName
     ? InstanceType<ServicesMap[T]['Response']>
-    : object;
+    : T extends { Response: new (...args: any[]) => infer R }
+      ? R
+      : object;
 
   /**
    * Callback for receiving service requests from a client.