Preferred way of dealing with both architectures

[mateioprea]

Hi,
I have this problem that I'm confronting with. I'm building a RN module and I want to support both architectures. I want to ask what is the recommended way of dealing with this kind of situation.

Methods written in RCT_EXPORT_METHOD macro are async, so that means that we need to either use a Promise or a callback to get the result back.
With TurboModules, we can return the result directly since everything is synchronous.

There's also a warning in the RN docs:
[...] Ultimately, React Native will remove RCT_EXPORT_MACRO [...]

Let's assume I have the following spec interface:

export interface Spec extends TurboModule {
  getConstants: () => {};
  add(a: number, b: number): Promise<number>;
  getSDKVersion(): string;
}

Since, getSDKVersion returns a string, how should that be handled for old architecture?

Should we use RCT_REMAP_METHOD for old arch and then type the methods on JS land? Example:

(...)

// new arch
- (NSString *)getSDKVersion {
    return @"test";
}

// old arch
RCT_REMAP_METHOD(getSDKVersion, getSDKVersionAsync:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
    resolve(@("test"));
}

type TurboModule = {
  add: (a: number, b: number) => Promise<number>;
  getSDKVersion: () => string;
};

type NativeModule = {
  add: (a: number, b: number) => Promise<number>;
  getSDKVersion: () => Promise<string>;
};

Thanks and have a great day!

[cipolleschi]

Hi @mateioprea, thanks for your question.

We created some examples to help handling both architectures at the same time: this repo contains a branch with TurboModules and Fabric Components that can work on both architectures.

At the moment, we still have to use the RCT_EXPORT_METHOD macros to export a function from a TurboModule. The RCT_REMAP_METHOD is just the same as the RCT_EXPORT_METHOD: additionally, it allows you to rename the method.

For your specific question, I see two alternatives:

1. If you want to keep the same API, you have to stay asynchronous, also with the TurboModule. It is still a smaller overhead than w.r.t the Old Architecture, because TurboModules use JSI and they don't serialize/deserialize messages.
2. Create an overload for your methods, something like getSDKVersion and getSDKVersionAsync and add a note that the Async version is deprecated and will be removed as soon as you stop supporting the Old Architecture.

What do you think?