@gnolang/gnonative 0.1.2

package/ios/GnoError.swift

@@ -0,0 +1,31 @@
+import ExpoModulesCore
+
+// Redefine GnoError with more context.
+open class GnoError: Exception {
+    public enum ErrorCase {
+        case alreadyStarted
+        case createConfig
+        case notStarted
+        case coreError(NSError)
+    }
+
+    private var errorDescription: String
+
+    public init(_ error: ErrorCase, file: String = #fileID, line: UInt = #line, function: String = #function) {
+        switch error {
+        case .alreadyStarted:
+            self.errorDescription = "Service is already started"
+        case .createConfig:
+            self.errorDescription = "unable to create config"
+        case .notStarted:
+            self.errorDescription = "Service hasn't started yet"
+        case .coreError(let error):
+            self.errorDescription = error.localizedDescription
+        }
+        super.init(file: file, line: line, function: function)
+    }
+
+    open override var reason: String {
+        return self.errorDescription
+    }
+}

package/ios/Gnonative.podspec

@@ -0,0 +1,28 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'Gnonative'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = { :ios => '13.4', :tvos => '13.4' }
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/gnolang/gnonative' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  s.libraries = 'resolv'
+  s.vendored_frameworks = "Frameworks/GnoCore.xcframework"
+  s.source_files = "**/*.{h,m,mm,swift}"
+  s.private_header_files = "Frameworks/GnoCore.xcframework/**/*.h"
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+end

package/ios/GnonativeModule.swift

@@ -0,0 +1,186 @@
+import ExpoModulesCore
+import GnoCore
+
+public class GnonativeModule: Module {
+  // Each module class must implement the definition function. The definition consists of components
+  // that describes the module's functionality and behavior.
+  // See https://docs.expo.dev/modules/module-api for more details about available components.
+  var logger: Logger = Logger(
+    category: String(describing: "GnoNative")
+  )
+  var appRootDir: String?
+  var tmpDir: String?
+  var bridge: GnoGnonativeBridge?
+  var socketPort: Int = 0
+  
+  public func definition() -> ModuleDefinition {
+    // Sets the name of the module that JavaScript code will use to refer to the module. Takes a string as an argument.
+    // Can be inferred from module's class name, but it's recommended to set it explicitly for clarity.
+    // The module will be accessible from `requireNativeModule('Gnonative')` in JavaScript.
+    Name("Gnonative")
+    
+    // Sets constant properties on the module. Can take a dictionary or a closure that returns a dictionary.
+    Constants([
+      "PI": Double.pi
+    ])
+    
+    OnCreate {
+      do {
+        self.appRootDir = try FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: true).path
+      } catch let error as NSError {
+        self.logger.error("\(String(describing: error.code))")
+      }
+      self.tmpDir = FileManager.default.compatTemporaryDirectory.path
+    }
+    
+    OnDestroy {
+      do {
+        if self.bridge != nil {
+          try self.bridge?.close()
+          self.bridge = nil
+        }
+      } catch let error as NSError {
+        self.logger.error("\(String(describing: error.code))")
+      }
+    }
+    
+    // Defines event names that the module can send to JavaScript.
+    Events("onChange")
+    
+    AsyncFunction("initBridge") { (promise: Promise) in
+      var err: NSError?
+      
+      do {
+        if self.bridge != nil {
+          throw GnoError(.alreadyStarted)
+        }
+        
+        // init the bridge service
+        
+        guard let config = GnoGnonativeBridgeConfig() else {
+          throw GnoError(.createConfig)
+        }
+        config.rootDir = self.appRootDir!
+        config.tmpDir = self.tmpDir!
+        
+        // On simulator we can't create an UDS, see comment below
+#if targetEnvironment(simulator)
+        config.useTcpListener = true
+        config.disableUdsListener = true
+#endif
+        
+        let bridge = GnoGnonativeNewBridge(config, &err);
+        if err != nil {
+          throw err!
+        }
+        self.bridge = bridge
+        
+        promise.resolve(true)
+      } catch let error {
+        promise.reject(error)
+      }
+    }
+    
+    AsyncFunction("getTcpPort") { (promise: Promise) in
+      do {
+        guard let service = self.bridge else {
+          throw GnoError(.notStarted)
+        }
+        self.socketPort = service.getTcpPort()
+        self.logger.info("gRPC server port: \(self.socketPort)")
+        promise.resolve(self.socketPort)
+      } catch let error {
+        promise.reject(error)
+      }
+    }
+    
+    AsyncFunction("closeBridge") { (promise: Promise) in
+      do {
+        guard let service = self.bridge else {
+          throw GnoError(.notStarted)
+        }
+        
+        try service.close()
+        self.bridge = nil
+      } catch let error {
+        promise.reject(error)
+      }
+    }
+    
+    AsyncFunction("invokeGrpcMethod") { (method: String, jsonMessage: String, promise: Promise) in
+      do {
+        guard let service = self.bridge else {
+          throw GnoError(.notStarted)
+        }
+        
+        let block = PromiseBlock(promise: promise)
+        service.invokeGrpcMethod(with: block, method: method as String, jsonMessage: jsonMessage as String)
+      } catch let err {
+        promise.reject(err)
+      }
+    }
+    
+    AsyncFunction("createStreamClient") { (method: String, jsonMessage: String, promise: Promise) in
+      do {
+        guard let service = self.bridge else {
+          throw GnoError(.notStarted)
+        }
+        
+        let block = PromiseBlock(promise: promise)
+        service.createStreamClient(with: block, method: method as String, jsonMessage: jsonMessage as String)
+      } catch let err {
+        promise.reject(err)
+      }
+    }
+    
+    AsyncFunction("streamClientReceive") { (id: String, promise: Promise) in
+      do {
+        guard let service = self.bridge else {
+          throw GnoError(.notStarted)
+        }
+        
+        let block = PromiseBlock(promise: promise)
+        service.streamClientReceive(with: block, id_: id as String)
+      } catch let err {
+        promise.reject(err)
+      }
+    }
+    
+    AsyncFunction("closeStreamClient") { (id: String, promise: Promise) in
+      do {
+        guard let service = self.bridge else {
+          throw GnoError(.notStarted)
+        }
+        
+        let block = PromiseBlock(promise: promise)
+        service.closeStreamClient(with: block, id_: id as String)
+      } catch let err {
+        promise.reject(err)
+      }
+    }
+
+    // Enables the module to be used as a native view. Definition components that are accepted as part of the
+    // view definition: Prop, Events.
+    View(GnonativeView.self) {
+      // Defines a setter for the `name` prop.
+      Prop("name") { (view: GnonativeView, prop: String) in
+        print(prop)
+      }
+    }
+  }
+}
+
+extension FileManager {
+  public var compatTemporaryDirectory: URL {
+    if #available(iOS 10.0, *) {
+      return temporaryDirectory
+    } else {
+      return (try? url(
+        for: .itemReplacementDirectory,
+        in: .userDomainMask,
+        appropriateFor: nil,
+        create: true)
+      ) ?? URL(fileURLWithPath: NSTemporaryDirectory())
+    }
+  }
+}

package/ios/GnonativeView.swift

@@ -0,0 +1,7 @@
+import ExpoModulesCore
+
+// This view will be used as a native component. Make sure to inherit from `ExpoView`
+// to apply the proper styling (e.g. border radius and shadows).
+class GnonativeView: ExpoView {
+  
+}

package/ios/PromiseBlock.swift

@@ -0,0 +1,45 @@
+//
+//  PromiseBlock.swift
+//  GnoExpo
+//
+//  Created by Guilhem Fanton on 10/07/2023.
+//
+
+import ExpoModulesCore
+import GnoCore
+
+var promises = Set<PromiseBlock>()
+
+// PromiseBlock aim to keep reference over promise object so go can play with
+// until the promise is resolved
+class PromiseBlock: NSObject, GnoGnonativePromiseBlockProtocol {
+    static func == (lhs: PromiseBlock, rhs: PromiseBlock) -> Bool {
+        return lhs === rhs
+    }
+    
+    var promise: Promise
+    
+    init(promise: Promise) {
+        self.promise = promise
+        super.init()
+        self.store()
+    }
+    
+    func callResolve(_ reply: String?) {
+        self.promise.resolve(reply ?? "")
+        self.remove() // cleanup the promise
+    }
+    
+    func callReject(_ error: Error?) {
+        self.promise.reject(error ?? Exception(name: "Unknown Error", description: "unknown reject error"))
+        self.remove() // cleanup the promise
+    }
+    
+    func store() {
+        promises.insert(self)
+    }
+    
+    func remove() {
+        promises.remove(self)
+    }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gnolang/gnonative",
+  "version": "0.1.2",
+  "description": "Develop for Gno using your app's native language ",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "open -a \"Xcode\" example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "gnonative",
+    "Gnonative"
+  ],
+  "repository": "https://github.com/gnolang/gnonative",
+  "bugs": {
+    "url": "https://github.com/gnolang/gnonative/issues"
+  },
+  "author": "D4ryl00 <d4ryl00@gmail.com> (https://github.com/D4ryl00)",
+  "license": "MIT",
+  "homepage": "https://github.com/gnolang/gnonative#readme",
+  "dependencies": {
+    "@buf/gnolang_gnonative.bufbuild_es": "^1.8.0-20240327143536-1ec48ff39f30.2",
+    "@buf/gnolang_gnonative.connectrpc_es": "^1.4.0-20240327143536-1ec48ff39f30.2",
+    "@bufbuild/protobuf": "^1.8.0",
+    "@connectrpc/connect": "^1.4.0",
+    "@connectrpc/connect-web": "^1.4.0",
+    "fast-text-encoding": "^1.0.6",
+    "js-base64": "^3.7.7"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.25",
+    "expo-module-scripts": "^3.4.1",
+    "expo-modules-core": "~1.11.12"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/Gnonative.types.ts

@@ -0,0 +1,7 @@
+export type ChangeEventPayload = {
+  value: string;
+};
+
+export type GnonativeViewProps = {
+  name: string;
+};

package/src/GnonativeModule.ts

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('Gnonative');

package/src/GnonativeModule.web.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'expo-modules-core';
+
+const emitter = new EventEmitter({} as any);
+
+export default {
+  PI: Math.PI,
+  async setValueAsync(value: string): Promise<void> {
+    emitter.emit('onChange', { value });
+  },
+  hello() {
+    return 'Hello world! 👋';
+  },
+};

package/src/GnonativeView.tsx

@@ -0,0 +1,11 @@
+import { requireNativeViewManager } from 'expo-modules-core';
+import * as React from 'react';
+
+import { GnonativeViewProps } from './Gnonative.types';
+
+const NativeView: React.ComponentType<GnonativeViewProps> =
+  requireNativeViewManager('Gnonative');
+
+export default function GnonativeView(props: GnonativeViewProps) {
+  return <NativeView {...props} />;
+}

package/src/GnonativeView.web.tsx

@@ -0,0 +1,11 @@
+import * as React from 'react';
+
+import { GnonativeViewProps } from './Gnonative.types';
+
+export default function GnonativeView(props: GnonativeViewProps) {
+  return (
+    <div>
+      <span>{props.name}</span>
+    </div>
+  );
+}

package/src/GoBridge.ts

@@ -0,0 +1,44 @@
+import GnonativeModule from './GnonativeModule';
+
+export interface GoBridgeInterface {
+  initBridge(): Promise<void>;
+  closeBridge(): Promise<void>;
+  getTcpPort(): Promise<number>;
+  invokeGrpcMethod(method: string, jsonMessage: string): Promise<string>;
+  createStreamClient(method: string, jsonMessage: string): Promise<string>;
+  streamClientReceive(id: string): Promise<string>;
+  closeStreamClient(id: string): Promise<void>;
+}
+
+class GoBridge implements GoBridgeInterface {
+  initBridge(): Promise<void> {
+    return GnonativeModule.initBridge();
+  }
+
+  closeBridge(): Promise<void> {
+    return GnonativeModule.closeBridge();
+  }
+
+  getTcpPort(): Promise<number> {
+    return GnonativeModule.getTcpPort();
+  }
+
+  invokeGrpcMethod(method: string, jsonMessage: string): Promise<string> {
+    return GnonativeModule.invokeGrpcMethod(method, jsonMessage);
+  }
+
+  createStreamClient(method: string, jsonMessage: string): Promise<string> {
+    return GnonativeModule.createStreamClient(method, jsonMessage);
+  }
+
+  streamClientReceive(id: string): Promise<string> {
+    return GnonativeModule.streamClientReceive(id);
+  }
+
+  closeStreamClient(id: string): Promise<void> {
+    return GnonativeModule.closeStreamClient(id);
+  }
+}
+
+const goBridge: GoBridgeInterface = new GoBridge();
+export { goBridge as GoBridge };

package/src/grpc/client.ts

@@ -0,0 +1,14 @@
+import { GnoNativeService } from '@buf/gnolang_gnonative.connectrpc_es/rpc_connect';
+import { createPromiseClient, PromiseClient } from '@connectrpc/connect';
+
+import { createNativeGrpcTransport } from './transport_native';
+
+// Create a GnoNativeService client
+export function createClient(_port: number): PromiseClient<typeof GnoNativeService> {
+  const transport = createNativeGrpcTransport({
+    baseUrl: '',
+    useBinaryFormat: false,
+  });
+
+  return createPromiseClient(GnoNativeService, transport);
+}

package/src/grpc/error.ts

@@ -0,0 +1,89 @@
+import { ErrCode } from '@buf/gnolang_gnonative.bufbuild_es/rpc_pb';
+import { Code, ConnectError } from '@connectrpc/connect';
+
+class GRPCError extends Error {
+  public GrpcCode: Code;
+
+  public error: ConnectError;
+
+  constructor(e: ConnectError | null | undefined) {
+    if (!e) {
+      // this should not happen, but should not break the app either.
+      // instead simply create a empty error and warn about this
+      console.warn(`GRPCError: (${e}) grpc error provided, empty error returned`);
+      e = new ConnectError('');
+    }
+
+    super(e.rawMessage);
+
+    this.error = e;
+    this.GrpcCode = e.code;
+  }
+
+  private extractErrCode(match: RegExpMatchArray | null) {
+    if (match === null || match.length < 2) {
+      return ErrCode.Undefined;
+    }
+
+    const code = parseInt(match[1]);
+    if (typeof code !== 'number') {
+      return ErrCode.Undefined;
+    }
+
+    return code;
+  }
+
+  // errCodes parses the error message formatted like `ErrType(#ErrNumber): WrappedErrType(#WrappedErrNumber)`
+  // and returns the corresponding ErrCodes or [ErrCode.Undefined] if some errors occur.
+  private errCodes(): ErrCode[] {
+    const errCodes: ErrCode[] = [];
+
+    if (this.message === '') {
+      return [ErrCode.Undefined];
+    }
+
+    const matches = this.message.matchAll(/\w+\(#(\d+)\)/g);
+
+    for (const match of matches) {
+      const code = this.extractErrCode(match);
+      errCodes.push(code);
+    }
+
+    return errCodes;
+  }
+
+  // errCode parses the error message formatted like `ErrType(#ErrNumber): WrappedErrType(#WrappedErrNumber)`
+  // and returns the corresponding parent ErrCode or ErrCode.Undefined if some errors occur.
+  public errCode(): ErrCode {
+    if (this.message === '') {
+      return ErrCode.Undefined;
+    }
+
+    const match = this.message.match(/\w+\(#(\d+)\)/);
+
+    return this.extractErrCode(match);
+  }
+
+  public grpcErrorCode(): Code {
+    return this.GrpcCode;
+  }
+
+  public toJSON(): any {
+    return {
+      message: this.message,
+      grpcErrorCode: Code[this.GrpcCode],
+      errorCode: ErrCode[this.errCode()],
+    };
+  }
+
+  public hasErrCode(error: ErrCode): boolean {
+    for (const err of this.errCodes()) {
+      if (err === error) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+export { GRPCError };