brick-module 0.3.1 → 0.4.0

package/BrickModule.podspec

@@ -17,7 +17,7 @@ Pod::Spec.new do |s|
   s.public_header_files = "ios/BrickModule/Public/*.h"
   s.private_header_files = "ios/BrickModule/Internal/*.h"
   
-  # Swift 설정
+  # Swift settings
   s.swift_version = "5.0"
   s.requires_arc = true
 

package/android/brick_modules.gradle

@@ -68,6 +68,29 @@ ext.getBrickAndroidPath = { projectRoot ->
     return new File(projectRoot, 'android/.brick').canonicalPath
 }
 
+ext.getBrickAndroidAppPath = { projectRoot ->
+    // Read brick.json from explicit project root
+    try {
+        def brickConfigFile = new File(projectRoot, 'brick.json')
+        if (brickConfigFile.exists()) {
+            def config = new JsonSlurper().parse(brickConfigFile)
+            def androidAppPath = config?.output?.androidAppPath
+            if (androidAppPath && !androidAppPath.isEmpty()) {
+                if (new File(androidAppPath).isAbsolute()) {
+                    println("[Brick] Warning: Using absolute path for Android app path is not recommended: ${androidAppPath}")
+                    return androidAppPath
+                }
+                return new File(projectRoot, androidAppPath).canonicalPath
+            }
+        }
+    } catch (Exception e) {
+        println("[Brick] Warning: Failed to read brick.json from ${projectRoot}: ${e.message}")
+    }
+
+    // Default: android/app in project root
+    return new File(projectRoot, 'android/app').canonicalPath
+}
+
 ext.getAllDependencies = { packageJson ->
     def deps = []
     deps.addAll(packageJson.dependencies?.keySet() ?: [])
@@ -402,7 +425,12 @@ ${moduleNames}
         // which contains package-aware-r.txt needed by dependent modules
         def brickOutputDir = getBrickAndroidPath(workingDir)
         def generatedMarker = new File(brickOutputDir, "src/main/kotlin/BrickModule.kt")
-        if (generatedMarker.exists()) {
+        def androidAppPath = getBrickAndroidAppPath(workingDir)
+        def jniDir = new File(androidAppPath, "build/generated/autolinking/src/main/jni")
+        def hasJniOutputs = new File(jniDir, "BrickModuleSpec-generated.cpp").exists() &&
+            new File(jniDir, "BrickModuleSpec.h").exists() &&
+            new File(jniDir, "CMakeLists.txt").exists()
+        if (generatedMarker.exists() && hasJniOutputs) {
             // Already generated, skip to preserve build outputs
             return
         }
@@ -419,7 +447,11 @@ ${moduleNames}
                     def codegenPath = new File(brickModuleDir, "bin/brick-codegen.js")
                     
                     if (codegenPath.exists()) {
-                        def codegenProc = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', workingDir.absolutePath].execute(null, workingDir)
+                        def codegenArgs = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', workingDir.absolutePath]
+                        if (generatedMarker.exists()) {
+                            codegenArgs.add('--no-clean')
+                        }
+                        def codegenProc = codegenArgs.execute(null, workingDir)
                         codegenProc.waitFor()
                     }
                 }

package/android/src/main/java/com/brickmodule/BrickModuleBase.kt

@@ -58,8 +58,45 @@ abstract class BrickModuleSpec(private val reactContext: ReactContext) : BrickMo
     }
 }
 
-/** Error types for Brick modules */
-open class BrickModuleError(message: String, val errorCode: String) : Exception(message) {
+// MARK: - BrickError Interface
+
+/**
+ * Error interface for Brick modules.
+ * Implement this interface to propagate all error properties to JavaScript.
+ * Follows the same pattern as iOS BrickError protocol.
+ *
+ * Note: message is inherited from Throwable, so it's not defined in this interface.
+ * Classes implementing BrickError must extend Exception/Throwable.
+ */
+interface BrickError {
+    /** Error code (accessed as error.name in JS) */
+    val code: String
+
+    /** Additional properties (accessed as error.userInfo.xxx in JS) */
+    val userInfo: Map<String, Any>?
+        get() = null
+}
+
+/**
+ * Default implementation of BrickError.
+ * Extend this class to create custom errors.
+ */
+open class BrickException(
+    override val code: String,
+    message: String,
+    override val userInfo: Map<String, Any>? = null,
+    cause: Throwable? = null
+) : Exception(message, cause), BrickError
+
+/** Error types for Brick modules - implements BrickError interface */
+open class BrickModuleError(
+    message: String,
+    override val code: String
+) : Exception(message), BrickError {
+
+    override val userInfo: Map<String, Any>?
+        get() = null
+
     class TypeMismatch(message: String) : BrickModuleError("Type mismatch: $message", "TYPE_ERROR")
     class ExecutionError(message: String) :
             BrickModuleError("Execution error: $message", "EXECUTION_ERROR")

package/dist/BrickError.d.ts

@@ -0,0 +1,29 @@
+//#region src/BrickError.d.ts
+/**
+ * BrickError - Type-safe class for custom errors from native modules.
+ * Matches the structure of iOS/Android BrickError.
+ */
+declare class BrickError extends Error {
+  /** Error code (same as error.name) */
+  readonly code: string;
+  /** Additional properties (e.g., amount, currency) */
+  readonly userInfo: Record<string, unknown>;
+  /** Name of the module where the error occurred */
+  readonly moduleName?: string;
+  constructor(message: string, code: string, userInfo?: Record<string, unknown>, moduleName?: string);
+  /**
+   * Type guard to check if an error object is a BrickError.
+   * @param error - The error object to check
+   * @returns true if the error is a BrickError
+   */
+  static isBrickError(error: unknown): error is BrickError;
+  /**
+   * Converts a general error object to a BrickError.
+   * @param error - The error object to convert
+   * @param moduleName - Name of the module where the error occurred
+   * @returns A BrickError instance
+   */
+  static from(error: unknown, moduleName?: string): BrickError;
+}
+//#endregion
+export { BrickError };

package/dist/BrickError.js

@@ -0,0 +1,49 @@
+//#region src/BrickError.ts
+/**
+* BrickError - Type-safe class for custom errors from native modules.
+* Matches the structure of iOS/Android BrickError.
+*/
+var BrickError = class BrickError extends Error {
+	/** Error code (same as error.name) */
+	code;
+	/** Additional properties (e.g., amount, currency) */
+	userInfo;
+	/** Name of the module where the error occurred */
+	moduleName;
+	constructor(message, code, userInfo = {}, moduleName) {
+		super(message);
+		this.name = code;
+		this.code = code;
+		this.userInfo = userInfo;
+		this.moduleName = moduleName;
+	}
+	/**
+	* Type guard to check if an error object is a BrickError.
+	* @param error - The error object to check
+	* @returns true if the error is a BrickError
+	*/
+	static isBrickError(error) {
+		return error instanceof Error && typeof error.code === "string" && typeof error.userInfo === "object" && error.userInfo !== null;
+	}
+	/**
+	* Converts a general error object to a BrickError.
+	* @param error - The error object to convert
+	* @param moduleName - Name of the module where the error occurred
+	* @returns A BrickError instance
+	*/
+	static from(error, moduleName) {
+		if (error instanceof BrickError) {
+			if (moduleName && !error.moduleName) return new BrickError(error.message, error.code, error.userInfo, moduleName);
+			return error;
+		}
+		if (BrickError.isBrickError(error)) return new BrickError(error.message, error.code, error.userInfo, moduleName || error.moduleName);
+		if (error instanceof Error) {
+			const anyError = error;
+			return new BrickError(error.message, anyError.code || anyError.name || "UNKNOWN_ERROR", anyError.userInfo || {}, moduleName || anyError.moduleName);
+		}
+		return new BrickError(String(error), "UNKNOWN_ERROR", {}, moduleName);
+	}
+};
+
+//#endregion
+export { BrickError };

package/dist/BrickModule.js

@@ -1,3 +1,4 @@
+import { BrickError } from "./BrickError.js";
 import { TurboModuleRegistry } from "react-native";
 
 //#region src/BrickModule.ts
@@ -49,11 +50,15 @@ function get(moduleName) {
 					if (result && typeof result === "object" && result["~sync"] === true) if (result.success === true) return result.value;
 					else {
 						const errorInfo = result.error || {};
-						const error = new Error(errorInfo.message || "Unknown error");
-						error.name = errorInfo.code || "BRICK_ERROR";
-						if (errorInfo.details) error.details = errorInfo.details;
-						throw error;
+						const message = errorInfo.message || errorInfo.errorMessage || "Unknown error";
+						const code = errorInfo.code || errorInfo.errorCode || "BRICK_ERROR";
+						const userInfo = { code };
+						for (const key of Object.keys(errorInfo)) if (key !== "code" && key !== "message" && key !== "errorCode" && key !== "errorMessage") userInfo[key] = errorInfo[key];
+						throw new BrickError(message, code, userInfo, moduleName);
 					}
+					if (result && typeof result.then === "function") return result.catch((error) => {
+						throw BrickError.from(error, moduleName);
+					});
 					return result;
 				}
 				throw new Error(`Method ${methodKey} not found`);

package/dist/index.d.ts

@@ -1,17 +1,9 @@
 import { BrickModule, BrickModuleInterface, BrickModuleSpec } from "./BrickModule.js";
+import { BrickError } from "./BrickError.js";
 import { Any, AnyObject } from "./types.js";
 
 //#region src/index.d.ts
 
-/**
- * Error types for Brick modules
- */
-declare class BrickModuleError extends Error {
-  code: string;
-  moduleName?: string | undefined;
-  methodName?: string | undefined;
-  constructor(message: string, code?: string, moduleName?: string | undefined, methodName?: string | undefined);
-}
 /**
  * Configuration interface for brick-codegen
  */
@@ -29,4 +21,4 @@ interface BrickCodegenConfig {
   dev?: boolean;
 }
 //#endregion
-export { Any, AnyObject, BrickCodegenConfig, BrickModule, BrickModuleError, type BrickModuleInterface, type BrickModuleSpec };
+export { Any, AnyObject, BrickCodegenConfig, BrickError, BrickModule, type BrickModuleInterface, type BrickModuleSpec };

package/dist/index.js

@@ -1,18 +1,4 @@
+import { BrickError } from "./BrickError.js";
 import BrickModule_default from "./BrickModule.js";
 
-//#region src/index.ts
-/**
-* Error types for Brick modules
-*/
-var BrickModuleError = class extends Error {
-	constructor(message, code = "BRICK_ERROR", moduleName, methodName) {
-		super(message);
-		this.code = code;
-		this.moduleName = moduleName;
-		this.methodName = methodName;
-		this.name = "BrickModuleError";
-	}
-};
-
-//#endregion
-export { BrickModule_default as BrickModule, BrickModuleError };
+export { BrickError, BrickModule_default as BrickModule };

package/ios/BrickModule/BrickCoreModule.swift

@@ -1,6 +1,48 @@
 import Foundation
 import React
 
+// MARK: - BrickError Protocol
+
+/// Error protocol for Brick modules.
+/// Conforming to this protocol propagates all error properties to JavaScript.
+public protocol BrickError: Error {
+    /// Error message (accessed as error.message in JS)
+    var message: String { get }
+
+    /// Error code (accessed as error.code in JS, optional)
+    var code: String? { get }
+
+    /// Additional properties (accessed as error.userInfo.xxx in JS)
+    var userInfo: [String: Any]? { get }
+
+    /// Convert to NSError (for React Native reject)
+    func asNSError() -> NSError
+}
+
+public extension BrickError {
+    /// Default code implementation
+    var code: String? { nil }
+
+    /// Default userInfo implementation
+    var userInfo: [String: Any]? { nil }
+
+    /// Default NSError conversion implementation
+    func asNSError() -> NSError {
+        var info: [String: Any] = userInfo ?? [:]
+        info["code"] = code ?? "EXECUTION_ERROR"
+        info["message"] = message
+        info[NSLocalizedDescriptionKey] = message
+        return NSError(domain: "BrickModule", code: 0, userInfo: info)
+    }
+
+    /// Error code to use when calling reject
+    var rejectCode: String {
+        code ?? "EXECUTION_ERROR"
+    }
+}
+
+// MARK: - BrickModuleBase
+
 /**
  * Base class for all Brick modules
  * Provides common functionality including event emission
@@ -30,43 +72,35 @@ open class BrickModuleBase: NSObject {
     }
 }
 
+// MARK: - BrickModuleError
+
 /**
  * Error types for Brick modules
  */
-public enum BrickModuleError: Error, LocalizedError {
+public enum BrickModuleError: BrickError {
     case typeMismatch(String)
     case executionError(String)
     case invalidDefinition(String)
     case methodNotFound(String)
     case moduleNotFound(String)
-    
-    public var errorDescription: String? {
+
+    public var code: String? {
         switch self {
-        case .typeMismatch(let message):
-            return "Type mismatch: \(message)"
-        case .executionError(let message):
-            return "Execution error: \(message)"
-        case .invalidDefinition(let message):
-            return "Invalid definition: \(message)"
-        case .methodNotFound(let message):
-            return "Method not found: \(message)"
-        case .moduleNotFound(let message):
-            return "Module not found: \(message)"
+        case .typeMismatch: return "TYPE_ERROR"
+        case .executionError: return "EXECUTION_ERROR"
+        case .invalidDefinition: return "DEFINITION_ERROR"
+        case .methodNotFound: return "METHOD_NOT_FOUND"
+        case .moduleNotFound: return "MODULE_NOT_FOUND"
         }
     }
-    
-    public var errorCode: String {
+
+    public var message: String {
         switch self {
-        case .typeMismatch:
-            return "TYPE_ERROR"
-        case .executionError:
-            return "EXECUTION_ERROR"
-        case .invalidDefinition:
-            return "DEFINITION_ERROR"
-        case .methodNotFound:
-            return "METHOD_NOT_FOUND"
-        case .moduleNotFound:
-            return "MODULE_NOT_FOUND"
+        case .typeMismatch(let msg): return "Type mismatch: \(msg)"
+        case .executionError(let msg): return "Execution error: \(msg)"
+        case .invalidDefinition(let msg): return "Invalid definition: \(msg)"
+        case .methodNotFound(let msg): return "Method not found: \(msg)"
+        case .moduleNotFound(let msg): return "Module not found: \(msg)"
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-module",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Better React Native native module development",
   "type": "module",
   "main": "dist/index.js",
@@ -58,7 +58,7 @@
     "brick-codegen": "./bin/brick-codegen.js"
   },
   "dependencies": {
-    "brick-codegen": "0.3.1"
+    "brick-codegen": "0.4.0"
   },
   "peerDependencies": {
     "react": ">=18.2.0",

package/podfile_helper.rb

@@ -27,7 +27,14 @@ def use_brick_modules!(app_path: nil)
     else
       File.expand_path(File.join(brick_root, ios_brick_path))
     end
-    brick_codegen_podspec_path = File.join(brick_codegen_pod_path, 'BrickCodegen.podspec')
+    brick_codegen_podspec_path = File.join(
+      brick_codegen_pod_path,
+      'BrickCodegen.podspec'
+    )
+    brick_codegen_pod_relative_path = relative_pod_path(
+      brick_codegen_pod_path,
+      podfile_dir
+    )
 
     # Run brick-codegen with real-time output and colors (iOS only)
     exit_status = system("cd #{brick_root} && FORCE_COLOR=1 npx brick-codegen --platform ios --projectRoot \"#{brick_root}\"")
@@ -42,8 +49,8 @@ def use_brick_modules!(app_path: nil)
     end
 
     # Link generated BrickCodegen pod
-    pod 'BrickCodegen', :path => brick_codegen_pod_path
-    Pod::UI.puts "[Brick] Linked BrickCodegen from #{brick_codegen_pod_path}"
+    pod 'BrickCodegen', :path => brick_codegen_pod_relative_path
+    Pod::UI.puts "[Brick] Linked BrickCodegen from #{brick_codegen_pod_relative_path}"
   rescue => e
     # Re-raise so CocoaPods fails the install
     raise e
@@ -74,3 +81,19 @@ def get_brick_ios_path(project_root)
   
   return File.expand_path(File.join(project_root, 'ios/.brick'))
 end
+
+def podfile_dir
+  podfile_path = Pod::Config.instance.podfile_path
+  return Pathname.new(Dir.pwd).expand_path if podfile_path.nil?
+
+  podfile_path.dirname.expand_path
+end
+
+def relative_pod_path(target_path, base_dir)
+  Pathname.new(target_path)
+    .expand_path
+    .relative_path_from(base_dir)
+    .to_s
+rescue ArgumentError
+  target_path
+end

package/src/BrickError.ts

@@ -0,0 +1,78 @@
+/**
+ * BrickError - Type-safe class for custom errors from native modules.
+ * Matches the structure of iOS/Android BrickError.
+ */
+export class BrickError extends Error {
+  /** Error code (same as error.name) */
+  readonly code: string;
+
+  /** Additional properties (e.g., amount, currency) */
+  readonly userInfo: Record<string, unknown>;
+
+  /** Name of the module where the error occurred */
+  readonly moduleName?: string;
+
+  constructor(
+    message: string,
+    code: string,
+    userInfo: Record<string, unknown> = {},
+    moduleName?: string
+  ) {
+    super(message);
+    this.name = code;
+    this.code = code;
+    this.userInfo = userInfo;
+    this.moduleName = moduleName;
+  }
+
+  /**
+   * Type guard to check if an error object is a BrickError.
+   * @param error - The error object to check
+   * @returns true if the error is a BrickError
+   */
+  static isBrickError(error: unknown): error is BrickError {
+    return (
+      error instanceof Error &&
+      typeof (error as any).code === "string" &&
+      typeof (error as any).userInfo === "object" &&
+      (error as any).userInfo !== null
+    );
+  }
+
+  /**
+   * Converts a general error object to a BrickError.
+   * @param error - The error object to convert
+   * @param moduleName - Name of the module where the error occurred
+   * @returns A BrickError instance
+   */
+  static from(error: unknown, moduleName?: string): BrickError {
+    if (error instanceof BrickError) {
+      // Update moduleName if provided
+      if (moduleName && !error.moduleName) {
+        return new BrickError(error.message, error.code, error.userInfo, moduleName);
+      }
+      return error;
+    }
+
+    if (BrickError.isBrickError(error)) {
+      return new BrickError(
+        error.message,
+        error.code,
+        error.userInfo,
+        moduleName || (error as any).moduleName
+      );
+    }
+
+    if (error instanceof Error) {
+      const anyError = error as any;
+      return new BrickError(
+        error.message,
+        anyError.code || anyError.name || "UNKNOWN_ERROR",
+        anyError.userInfo || {},
+        moduleName || anyError.moduleName
+      );
+    }
+
+    return new BrickError(String(error), "UNKNOWN_ERROR", {}, moduleName);
+  }
+}

package/src/BrickModule.ts

@@ -5,6 +5,7 @@
 
 import type { TurboModule } from "react-native";
 import { TurboModuleRegistry } from "react-native";
+import { BrickError } from "./BrickError";
 
 /**
  * Base interface that all Brick module specs must extend
@@ -133,18 +134,32 @@ function get<T extends BrickModuleInterface>(
               // Success: return the unwrapped value
               return result.value;
             } else {
-              // Failure: throw an Error with details from error object
+              // Failure: throw a BrickError with all properties from error object
               const errorInfo = result.error || {};
-              const error = new Error(errorInfo.message || "Unknown error");
-              error.name = errorInfo.code || "BRICK_ERROR";
-              if (errorInfo.details) {
-                (error as any).details = errorInfo.details;
+              const message = errorInfo.message || errorInfo.errorMessage || "Unknown error";
+              const code = errorInfo.code || errorInfo.errorCode || "BRICK_ERROR";
+
+              // Build userInfo from additional properties
+              const userInfo: Record<string, unknown> = { code };
+              for (const key of Object.keys(errorInfo)) {
+                if (key !== "code" && key !== "message" && key !== "errorCode" && key !== "errorMessage") {
+                  userInfo[key] = errorInfo[key];
+                }
               }
-              throw error;
+
+              throw new BrickError(message, code, userInfo, moduleName);
             }
           }
 
-          // Not wrapped (async method or other): return as-is
+          // Async method: wrap Promise and convert to BrickError
+          if (result && typeof result.then === "function") {
+            return result.catch((error: unknown) => {
+              // Convert to BrickError with moduleName for type-safe error handling
+              throw BrickError.from(error, moduleName);
+            });
+          }
+
+          // Not wrapped: return as-is
           return result;
         }
 

package/src/index.ts

@@ -4,20 +4,7 @@
 export type { BrickModuleInterface, BrickModuleSpec } from "./BrickModule";
 // Main API exports
 export { default as BrickModule } from "./BrickModule";
-/**
- * Error types for Brick modules
- */
-export class BrickModuleError extends Error {
-  constructor(
-    message: string,
-    public code: string = "BRICK_ERROR",
-    public moduleName?: string,
-    public methodName?: string
-  ) {
-    super(message);
-    this.name = "BrickModuleError";
-  }
-}
+export { BrickError } from "./BrickError";
 
 /**
  * Configuration interface for brick-codegen