brick-module 0.3.1 → 0.4.1

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() ?: [])
@@ -79,7 +102,7 @@ ext.isBrickModule = { packageJson ->
     return packageJson?.brickModule != null
 }
 
-ext.runBrickCodegen = { workingDir ->
+ext.runBrickCodegen = { workingDir, options = [:] ->
     def brickModuleDir = resolveModule(workingDir, "brick-module")
     if (brickModuleDir == null) {
         brickLog("brick-module not found, skipping code generation")
@@ -94,7 +117,18 @@ ext.runBrickCodegen = { workingDir ->
     
     try {
         def wdPath = (workingDir instanceof File) ? workingDir.absolutePath : workingDir
-        def proc = ['node', codegenPath.absolutePath, '--platform', 'android', '--projectRoot', wdPath].execute(null, workingDir)
+        def codegenArgs = [
+            'node',
+            codegenPath.absolutePath,
+            '--platform',
+            'android',
+            '--projectRoot',
+            wdPath
+        ]
+        if (options.noClean == true) {
+            codegenArgs.add('--no-clean')
+        }
+        def proc = codegenArgs.execute(null, workingDir)
         proc.waitFor()
         return proc.exitValue() == 0
     } catch (Exception e) {
@@ -194,10 +228,12 @@ ext.applyBrickModules = { settings, args ->
     def androidBrickPath = getBrickAndroidPath(projectRoot)
     def brickDir = new File(androidBrickPath)
     def needsCodegen = !brickDir.exists() || !new File(brickDir, "src/main/kotlin/BrickModule.kt").exists()
-    
+    def codegenAttempted = false
     if (needsCodegen) {
-        runBrickCodegen(projectRoot)
+        codegenAttempted = true
+        runBrickCodegen(projectRoot, [noClean: true])
     }
+    settings.ext.brickCodegenRan = codegenAttempted
     
     // Include generated module (use configured path)
     if (brickDir.exists()) {
@@ -216,6 +252,8 @@ ext.applyBrickModules = { settings, args ->
         gradle.rootProject.ext.brickModulesList = foundModules
         gradle.rootProject.ext.brickProjectRoot = projectRoot
         gradle.rootProject.ext.brickAppProjectName = appProjectName
+        gradle.rootProject.ext.brickCodegenRanInBuild =
+            settings.ext.has("brickCodegenRan") ? settings.ext.brickCodegenRan : false
         configureAppProject(gradle)
         // Inline: ensure RN autolinking doesn't fail due to missing codegen/jni for brick-module
         gradle.rootProject.subprojects { subproj ->
@@ -395,19 +433,16 @@ ${moduleNames}
     project.preBuild.dependsOn('generateBrickModulesList')
     project.preBuild.doFirst {
         def workingDir = projectRoot
-        
-        // Skip codegen if already generated to prevent deleting Gradle build outputs
-        // The codegen is already run during settings.gradle phase (applyBrickModules -> runBrickCodegen)
-        // Re-running here with --clean would delete .brick_android/build/ directory
-        // 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()) {
-            // Already generated, skip to preserve build outputs
+
+        def alreadyRan = rootProject.ext.has("brickCodegenRanInBuild") ?
+            rootProject.ext.brickCodegenRanInBuild : false
+        if (alreadyRan) {
+            // Avoid double-running if settings already executed codegen.
             return
         }
+        rootProject.ext.brickCodegenRanInBuild = true
 
-        // Run codegen only if not yet generated
+        // Run codegen once per build without cleaning outputs.
         try {
             def proc = ['node', '-p', "require.resolve('brick-module/package.json')"].execute(null, workingDir)
             proc.waitFor()
@@ -419,7 +454,16 @@ ${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,
+                            '--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/android/src/main/java/com/brickmodule/EventDataConverter.kt

@@ -3,33 +3,45 @@ package com.brickmodule
 import com.facebook.react.bridge.*
 
 /**
- * Helper class for converting data to React Native compatible formats
- * Ensures type safety when sending events to JavaScript
+ * Helper class for converting data to React Native compatible formats Ensures type safety when
+ * sending events to JavaScript
  */
 object EventDataConverter {
-    
+
+    private fun isNullSentinel(value: Any?): Boolean {
+        return value is Null ||
+                (value != null && value.javaClass.name == "com.brickmodule.Null") ||
+                (value is String && value.startsWith("com.brickmodule.Null@"))
+    }
+
     /**
      * Convert any data to React Native compatible format
-     * 
+     *
      * @param data The data to convert
      * @return React Native compatible data or null if conversion fails
      */
     fun convert(data: Any?): Any? {
         return try {
-            when (data) {
-                null -> null
-                is String -> data
-                is Boolean -> data
-                is Int -> data
-                is Double -> data
-                is Float -> data.toDouble()
-                is Long -> data.toDouble()
-                is Map<*, *> -> convertMap(data)
-                is List<*> -> convertList(data)
-                is Array<*> -> convertList(data.toList())
-                else -> {
-                    println("⚠️ EventDataConverter: Unsupported data type ${data.javaClass.simpleName}, converting to string")
-                    data.toString()
+            if (isNullSentinel(data)) {
+                null
+            } else {
+                when (data) {
+                    null -> null
+                    is String -> data
+                    is Boolean -> data
+                    is Int -> data
+                    is Double -> data
+                    is Float -> data.toDouble()
+                    is Long -> data.toDouble()
+                    is Map<*, *> -> convertMap(data)
+                    is List<*> -> convertList(data)
+                    is Array<*> -> convertList(data.toList())
+                    else -> {
+                        println(
+                                "⚠️ EventDataConverter: Unsupported data type ${data.javaClass.simpleName}, converting to string"
+                        )
+                        data.toString()
+                    }
                 }
             }
         } catch (e: Exception) {
@@ -37,17 +49,17 @@ object EventDataConverter {
             null
         }
     }
-    
+
     /**
      * Convert a map to WritableMap for React Native
-     * 
+     *
      * @param map The map to convert
      * @return WritableMap or null if conversion fails
      */
     private fun convertMap(map: Map<*, *>): WritableMap? {
         return try {
             val writableMap = Arguments.createMap()
-            
+
             map.forEach { (key, value) ->
                 val keyString = key?.toString()
                 if (keyString != null) {
@@ -63,24 +75,24 @@ object EventDataConverter {
                     }
                 }
             }
-            
+
             writableMap
         } catch (e: Exception) {
             println("❌ EventDataConverter: Failed to convert map: ${e.message}")
             null
         }
     }
-    
+
     /**
      * Convert a list to WritableArray for React Native
-     * 
+     *
      * @param list The list to convert
      * @return WritableArray or null if conversion fails
      */
     private fun convertList(list: List<*>): WritableArray? {
         return try {
             val writableArray = Arguments.createArray()
-            
+
             list.forEach { item ->
                 when (val convertedValue = convert(item)) {
                     null -> writableArray.pushNull()
@@ -93,30 +105,31 @@ object EventDataConverter {
                     else -> writableArray.pushString(convertedValue.toString())
                 }
             }
-            
+
             writableArray
         } catch (e: Exception) {
             println("❌ EventDataConverter: Failed to convert list: ${e.message}")
             null
         }
     }
-    
+
     /**
      * Validate if data can be safely converted to React Native format
-     * 
+     *
      * @param data The data to validate
      * @return true if data can be safely converted, false otherwise
      */
     fun isConvertible(data: Any?): Boolean {
+        if (isNullSentinel(data)) {
+            return true
+        }
         return when (data) {
             null -> true
             is String, is Boolean, is Number -> true
-            is Map<*, *> -> data.all { (key, value) -> 
-                key is String && isConvertible(value) 
-            }
+            is Map<*, *> -> data.all { (key, value) -> key is String && isConvertible(value) }
             is List<*> -> data.all { isConvertible(it) }
             is Array<*> -> data.all { isConvertible(it) }
             else -> false
         }
     }
-}
+}

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

@@ -0,0 +1,7 @@
+
+package com.brickmodule
+
+/**
+ * Sentinel value used to represent null for Any conversions.
+ */
+object Null

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,10 +1,12 @@
 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
+ * @deprecated Use BrickError instead
  */
 declare class BrickModuleError extends Error {
   code: string;
@@ -29,4 +31,4 @@ interface BrickCodegenConfig {
   dev?: boolean;
 }
 //#endregion
-export { Any, AnyObject, BrickCodegenConfig, BrickModule, BrickModuleError, type BrickModuleInterface, type BrickModuleSpec };
+export { Any, AnyObject, BrickCodegenConfig, BrickError, BrickModule, BrickModuleError, type BrickModuleInterface, type BrickModuleSpec };

package/dist/index.js

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

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.1",
   "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.1"
   },
   "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,8 +4,11 @@
 export type { BrickModuleInterface, BrickModuleSpec } from "./BrickModule";
 // Main API exports
 export { default as BrickModule } from "./BrickModule";
+export { BrickError } from "./BrickError";
+
 /**
  * Error types for Brick modules
+ * @deprecated Use BrickError instead
  */
 export class BrickModuleError extends Error {
   constructor(