hane 1.0.0 → 1.1.1

package/src/native/addon.cc

@@ -1,231 +1,271 @@
-#include <napi.h>
-
-#include <optional>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "zsign_driver.h"
-
-namespace {
-
-std::optional<std::string> ReadOptionalString(const Napi::Env& env, const Napi::Object& obj, const char* key) {
-	if (!obj.Has(key)) {
-		return std::nullopt;
-	}
-
-	Napi::Value value = obj.Get(key);
-	if (value.IsUndefined() || value.IsNull()) {
-		return std::nullopt;
-	}
-
-	if (!value.IsString()) {
-		Napi::TypeError::New(env, std::string("Expected string for option \"") + key + "\"").ThrowAsJavaScriptException();
-		return std::nullopt;
-	}
-
-	return value.As<Napi::String>().Utf8Value();
-}
-
-bool ReadOptionalBool(const Napi::Env& env, const Napi::Object& obj, const char* key) {
-	if (!obj.Has(key)) {
-		return false;
-	}
-
-	Napi::Value value = obj.Get(key);
-	if (value.IsUndefined() || value.IsNull()) {
-		return false;
-	}
-
-	if (!value.IsBoolean()) {
-		Napi::TypeError::New(env, std::string("Expected boolean for option \"") + key + "\"").ThrowAsJavaScriptException();
-		return false;
-	}
-
-	return value.As<Napi::Boolean>().Value();
-}
-
-std::vector<std::string> ReadStringArray(const Napi::Env& env, const Napi::Object& obj, const char* key) {
-	std::vector<std::string> values;
-	if (!obj.Has(key)) {
-		return values;
-	}
-
-	Napi::Value value = obj.Get(key);
-	if (value.IsUndefined() || value.IsNull()) {
-		return values;
-	}
-
-	if (!value.IsArray()) {
-		Napi::TypeError::New(env, std::string("Expected array for option \"") + key + "\"").ThrowAsJavaScriptException();
-		return values;
-	}
-
-	Napi::Array arr = value.As<Napi::Array>();
-	values.reserve(arr.Length());
-	for (uint32_t i = 0; i < arr.Length(); i++) {
-		Napi::Value entry = arr.Get(i);
-		if (entry.IsUndefined() || entry.IsNull()) {
-			continue;
-		}
-		if (!entry.IsString()) {
-			Napi::TypeError::New(env, std::string("Expected string in \"") + key + "\" array").ThrowAsJavaScriptException();
-			return {};
-		}
-		values.push_back(entry.As<Napi::String>().Utf8Value());
-	}
-
-	return values;
-}
-
-int ReadZipLevel(const Napi::Env& env, const Napi::Object& obj) {
-	if (!obj.Has("zipLevel")) {
-		return -1;
-	}
-
-	Napi::Value value = obj.Get("zipLevel");
-	if (value.IsUndefined() || value.IsNull()) {
-		return -1;
-	}
-
-	if (!value.IsNumber()) {
-		Napi::TypeError::New(env, "Expected number for option \"zipLevel\"").ThrowAsJavaScriptException();
-		return -1;
-	}
-
-	int32_t level = value.As<Napi::Number>().Int32Value();
-	if (level < 0 || level > 9) {
-		Napi::RangeError::New(env, "\"zipLevel\" must be between 0 and 9").ThrowAsJavaScriptException();
-		return -1;
-	}
-
-	return level;
-}
-
-bool ParseOptions(const Napi::Env& env, const Napi::Object& optionsObject, ZSignBindingOptions& options) {
-	auto inputOpt = ReadOptionalString(env, optionsObject, "input");
-	if (!inputOpt || inputOpt->empty()) {
-		Napi::TypeError::New(env, "\"input\" must be a non-empty string").ThrowAsJavaScriptException();
-		return false;
-	}
-
-	options.input = *inputOpt;
-	if (auto cert = ReadOptionalString(env, optionsObject, "certificate")) {
-		options.certificate = *cert;
-	}
-	if (auto key = ReadOptionalString(env, optionsObject, "privateKey")) {
-		options.privateKey = *key;
-	}
-	if (auto prov = ReadOptionalString(env, optionsObject, "provisioningProfile")) {
-		options.provisioningProfile = *prov;
-	}
-	if (auto password = ReadOptionalString(env, optionsObject, "password")) {
-		options.password = *password;
-	}
-	if (auto bundleId = ReadOptionalString(env, optionsObject, "bundleId")) {
-		options.bundleId = *bundleId;
-	}
-	if (auto bundleVersion = ReadOptionalString(env, optionsObject, "bundleVersion")) {
-		options.bundleVersion = *bundleVersion;
-	}
-	if (auto displayName = ReadOptionalString(env, optionsObject, "bundleDisplayName")) {
-		options.bundleDisplayName = *displayName;
-	}
-	if (auto entitlements = ReadOptionalString(env, optionsObject, "entitlements")) {
-		options.entitlements = *entitlements;
-	}
-	if (auto output = ReadOptionalString(env, optionsObject, "output")) {
-		options.output = *output;
-	}
-	if (auto tempDir = ReadOptionalString(env, optionsObject, "tempDirectory")) {
-		options.tempDir = *tempDir;
-	}
-
-	options.dylibs = ReadStringArray(env, optionsObject, "dylibs");
-	if (env.IsExceptionPending()) {
-		return false;
-	}
-	options.debug = ReadOptionalBool(env, optionsObject, "debug");
-	options.force = ReadOptionalBool(env, optionsObject, "force");
-	options.adhoc = ReadOptionalBool(env, optionsObject, "adhoc");
-	options.weakInject = ReadOptionalBool(env, optionsObject, "weakInject");
-	options.install = ReadOptionalBool(env, optionsObject, "install");
-	options.quiet = ReadOptionalBool(env, optionsObject, "quiet");
-	options.check = ReadOptionalBool(env, optionsObject, "check");
-	options.sha256Only = ReadOptionalBool(env, optionsObject, "sha256Only");
-	options.zipLevel = ReadZipLevel(env, optionsObject);
-
-	if (env.IsExceptionPending()) {
-		return false;
-	}
-
-	return true;
-}
-
+#include <napi.h>
+
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "zsign_driver.h"
+
+namespace {
+
+std::optional<std::string> ReadOptionalString(const Napi::Env& env, const Napi::Object& obj, const char* key) {
+	if (!obj.Has(key)) {
+		return std::nullopt;
+	}
+
+	Napi::Value value = obj.Get(key);
+	if (value.IsUndefined() || value.IsNull()) {
+		return std::nullopt;
+	}
+
+	if (!value.IsString()) {
+		Napi::TypeError::New(env, std::string("Expected string for option \"") + key + "\"").ThrowAsJavaScriptException();
+		return std::nullopt;
+	}
+
+	return value.As<Napi::String>().Utf8Value();
+}
+
+bool ReadOptionalBool(const Napi::Env& env, const Napi::Object& obj, const char* key) {
+	if (!obj.Has(key)) {
+		return false;
+	}
+
+	Napi::Value value = obj.Get(key);
+	if (value.IsUndefined() || value.IsNull()) {
+		return false;
+	}
+
+	if (!value.IsBoolean()) {
+		Napi::TypeError::New(env, std::string("Expected boolean for option \"") + key + "\"").ThrowAsJavaScriptException();
+		return false;
+	}
+
+	return value.As<Napi::Boolean>().Value();
+}
+
+std::vector<std::string> ReadStringArray(const Napi::Env& env, const Napi::Object& obj, const char* key) {
+	std::vector<std::string> values;
+	if (!obj.Has(key)) {
+		return values;
+	}
+
+	Napi::Value value = obj.Get(key);
+	if (value.IsUndefined() || value.IsNull()) {
+		return values;
+	}
+
+	if (!value.IsArray()) {
+		Napi::TypeError::New(env, std::string("Expected array for option \"") + key + "\"").ThrowAsJavaScriptException();
+		return values;
+	}
+
+	Napi::Array arr = value.As<Napi::Array>();
+	values.reserve(arr.Length());
+	for (uint32_t i = 0; i < arr.Length(); i++) {
+		Napi::Value entry = arr.Get(i);
+		if (entry.IsUndefined() || entry.IsNull()) {
+			continue;
+		}
+		if (!entry.IsString()) {
+			Napi::TypeError::New(env, std::string("Expected string in \"") + key + "\" array").ThrowAsJavaScriptException();
+			return {};
+		}
+		values.push_back(entry.As<Napi::String>().Utf8Value());
+	}
+
+	return values;
+}
+
+int ReadZipLevel(const Napi::Env& env, const Napi::Object& obj) {
+	if (!obj.Has("zipLevel")) {
+		return -1;
+	}
+
+	Napi::Value value = obj.Get("zipLevel");
+	if (value.IsUndefined() || value.IsNull()) {
+		return -1;
+	}
+
+	if (!value.IsNumber()) {
+		Napi::TypeError::New(env, "Expected number for option \"zipLevel\"").ThrowAsJavaScriptException();
+		return -1;
+	}
+
+	int32_t level = value.As<Napi::Number>().Int32Value();
+	if (level < 0 || level > 9) {
+		Napi::RangeError::New(env, "\"zipLevel\" must be between 0 and 9").ThrowAsJavaScriptException();
+		return -1;
+	}
+
+	return level;
+}
+
+bool ParseOptions(const Napi::Env& env, const Napi::Object& optionsObject, ZSignBindingOptions& options) {
+	auto inputOpt = ReadOptionalString(env, optionsObject, "input");
+	if (!inputOpt || inputOpt->empty()) {
+		Napi::TypeError::New(env, "\"input\" must be a non-empty string").ThrowAsJavaScriptException();
+		return false;
+	}
+
+	options.input = *inputOpt;
+	if (auto cert = ReadOptionalString(env, optionsObject, "certificate")) {
+		options.certificate = *cert;
+	}
+	if (auto key = ReadOptionalString(env, optionsObject, "privateKey")) {
+		options.privateKey = *key;
+	}
+	if (auto prov = ReadOptionalString(env, optionsObject, "provisioningProfile")) {
+		options.provisioningProfile = *prov;
+	}
+	if (auto password = ReadOptionalString(env, optionsObject, "password")) {
+		options.password = *password;
+	}
+	if (auto bundleId = ReadOptionalString(env, optionsObject, "bundleId")) {
+		options.bundleId = *bundleId;
+	}
+	if (auto bundleVersion = ReadOptionalString(env, optionsObject, "bundleVersion")) {
+		options.bundleVersion = *bundleVersion;
+	}
+	if (auto displayName = ReadOptionalString(env, optionsObject, "bundleDisplayName")) {
+		options.bundleDisplayName = *displayName;
+	}
+	if (auto entitlements = ReadOptionalString(env, optionsObject, "entitlements")) {
+		options.entitlements = *entitlements;
+	}
+	if (auto output = ReadOptionalString(env, optionsObject, "output")) {
+		options.output = *output;
+	}
+	if (auto tempDir = ReadOptionalString(env, optionsObject, "tempDirectory")) {
+		options.tempDir = *tempDir;
+	}
+
+	options.dylibs = ReadStringArray(env, optionsObject, "dylibs");
+	if (env.IsExceptionPending()) {
+		return false;
+	}
+	options.debug = ReadOptionalBool(env, optionsObject, "debug");
+	options.force = ReadOptionalBool(env, optionsObject, "force");
+	options.adhoc = ReadOptionalBool(env, optionsObject, "adhoc");
+	options.weakInject = ReadOptionalBool(env, optionsObject, "weakInject");
+	options.install = ReadOptionalBool(env, optionsObject, "install");
+	options.quiet = ReadOptionalBool(env, optionsObject, "quiet");
+	options.check = ReadOptionalBool(env, optionsObject, "check");
+	options.sha256Only = ReadOptionalBool(env, optionsObject, "sha256Only");
+	options.zipLevel = ReadZipLevel(env, optionsObject);
+
+	if (env.IsExceptionPending()) {
+		return false;
+	}
+
+	return true;
+}
+
 Napi::Object BuildResultObject(const Napi::Env& env, const ZSignBindingResult& result) {
 	Napi::Object payload = Napi::Object::New(env);
 	payload.Set("exitCode", Napi::Number::New(env, result.exit_code));
 	payload.Set("success", Napi::Boolean::New(env, result.success));
-	payload.Set("installRequested", Napi::Boolean::New(env, result.install_requested));
-	payload.Set("checkRequested", Napi::Boolean::New(env, result.check_requested));
-	if (!result.output_path.empty()) {
-		payload.Set("outputPath", Napi::String::New(env, result.output_path));
+	payload.Set("installRequested", Napi::Boolean::New(env, result.install_requested));
+	payload.Set("checkRequested", Napi::Boolean::New(env, result.check_requested));
+	if (!result.output_path.empty()) {
+		payload.Set("outputPath", Napi::String::New(env, result.output_path));
 	}
 	return payload;
 }
 
-class SignWorker final : public Napi::AsyncWorker {
-public:
-	explicit SignWorker(Napi::Env env, ZSignBindingOptions options)
-		: Napi::AsyncWorker(env), deferred_(Napi::Promise::Deferred::New(env)), options_(std::move(options)) {}
-
-	void Execute() override {
-		result_ = RunZSignWithOptions(options_);
-	}
-
-	void OnOK() override {
-		deferred_.Resolve(BuildResultObject(Env(), result_));
-	}
-
-	void OnError(const Napi::Error& error) override {
-		deferred_.Reject(error.Value());
-	}
+struct SignAsyncContext {
+	napi_env env = nullptr;
+	napi_async_work work = nullptr;
+	napi_deferred deferred = nullptr;
+	ZSignBindingOptions options;
+	ZSignBindingResult result;
+	std::string error_message;
+};
 
-	Napi::Promise GetPromise() {
-		return deferred_.Promise();
-	}
+void ExecuteSign(napi_env /*env*/, void* data) {
+	auto* ctx = static_cast<SignAsyncContext*>(data);
+	ctx->result = RunZSignWithOptions(ctx->options);
+}
 
-private:
-	Napi::Promise::Deferred deferred_;
-	ZSignBindingOptions options_;
-	ZSignBindingResult result_;
-};
+void CompleteSign(napi_env env, napi_status status, void* data) {
+	auto* ctx = static_cast<SignAsyncContext*>(data);
+
+	if (status != napi_ok || !ctx->error_message.empty()) {
+		const char* message =
+			!ctx->error_message.empty() ? ctx->error_message.c_str() : "Async sign work failed";
+		napi_value msg = nullptr;
+		napi_value err = nullptr;
+		napi_create_string_utf8(env, message, NAPI_AUTO_LENGTH, &msg);
+		napi_create_error(env, nullptr, msg, &err);
+		napi_reject_deferred(env, ctx->deferred, err);
+	} else {
+		Napi::Env napiEnv(env);
+		Napi::Object payload = BuildResultObject(napiEnv, ctx->result);
+		napi_resolve_deferred(env, ctx->deferred, payload);
+	}
+
+	napi_delete_async_work(env, ctx->work);
+	delete ctx;
+}
 
 } // namespace
 
 Napi::Value Sign(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
+
+	if (info.Length() == 0 || !info[0].IsObject()) {
+		Napi::TypeError::New(env, "Options object is required").ThrowAsJavaScriptException();
+		return env.Undefined();
+	}
+
+	Napi::Object optionsObject = info[0].As<Napi::Object>();
+	ZSignBindingOptions options;
+	if (!ParseOptions(env, optionsObject, options)) {
+		return env.Undefined();
+	}
 
-	if (info.Length() == 0 || !info[0].IsObject()) {
-		Napi::TypeError::New(env, "Options object is required").ThrowAsJavaScriptException();
+	auto* ctx = new SignAsyncContext();
+	ctx->env = env;
+	ctx->options = std::move(options);
+
+	napi_value promise = nullptr;
+	napi_status status = napi_create_promise(env, &ctx->deferred, &promise);
+	if (status != napi_ok) {
+		delete ctx;
+		Napi::Error::New(env, "Failed to create Promise for sign()").ThrowAsJavaScriptException();
 		return env.Undefined();
 	}
 
-	Napi::Object optionsObject = info[0].As<Napi::Object>();
-	ZSignBindingOptions options;
-	if (!ParseOptions(env, optionsObject, options)) {
+	napi_value resourceName = nullptr;
+	status = napi_create_string_utf8(env, "zsign.sign", NAPI_AUTO_LENGTH, &resourceName);
+	if (status != napi_ok) {
+		delete ctx;
+		Napi::Error::New(env, "Failed to create async resource name").ThrowAsJavaScriptException();
 		return env.Undefined();
 	}
 
-	auto* worker = new SignWorker(env, std::move(options));
-	auto promise = worker->GetPromise();
-	worker->Queue();
-	return promise;
-}
+	status = napi_create_async_work(env, nullptr, resourceName, ExecuteSign, CompleteSign, ctx, &ctx->work);
+	if (status != napi_ok) {
+		delete ctx;
+		Napi::Error::New(env, "Failed to create async work for sign()").ThrowAsJavaScriptException();
+		return env.Undefined();
+	}
 
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-	exports.Set(Napi::String::New(env, "sign"), Napi::Function::New(env, Sign));
-	return exports;
-}
+	status = napi_queue_async_work(env, ctx->work);
+	if (status != napi_ok) {
+		napi_delete_async_work(env, ctx->work);
+		delete ctx;
+		Napi::Error::New(env, "Failed to queue async work for sign()").ThrowAsJavaScriptException();
+		return env.Undefined();
+	}
 
-NODE_API_MODULE(zsign, Init)
+	return Napi::Value(env, promise);
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+	exports.Set(Napi::String::New(env, "sign"), Napi::Function::New(env, Sign));
+	return exports;
+}
+
+NODE_API_MODULE(zsign, Init)

package/src/native/zsign_driver.cc

@@ -1,87 +1,87 @@
-#include "zsign_driver.h"
-
-#include <string>
-#include <vector>
-
-extern int zsign_cli_main(int argc, char** argv);
-extern int optind;
-#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
-extern int optreset;
-#endif
-
-namespace {
-
-void PushFlag(std::vector<std::string>& args, const char* flag, bool enabled) {
-	if (enabled) {
-		args.emplace_back(flag);
-	}
-}
-
-void PushOption(std::vector<std::string>& args, const char* flag, const std::string& value) {
-	if (!value.empty()) {
-		args.emplace_back(flag);
-		args.emplace_back(value);
-	}
-}
-
-} // namespace
-
-ZSignBindingResult RunZSignWithOptions(const ZSignBindingOptions& options) {
-	std::vector<std::string> args;
-	args.emplace_back("zsign");
-
-	PushFlag(args, "-d", options.debug);
-	PushFlag(args, "-f", options.force);
-	PushFlag(args, "-a", options.adhoc);
-	PushFlag(args, "-w", options.weakInject);
-	PushFlag(args, "-i", options.install);
-	PushFlag(args, "-q", options.quiet);
-	PushFlag(args, "-C", options.check);
-	PushFlag(args, "-2", options.sha256Only);
-
-	PushOption(args, "-c", options.certificate);
-	PushOption(args, "-k", options.privateKey);
-	PushOption(args, "-m", options.provisioningProfile);
-	PushOption(args, "-p", options.password);
-	PushOption(args, "-b", options.bundleId);
-	PushOption(args, "-r", options.bundleVersion);
-	PushOption(args, "-n", options.bundleDisplayName);
-	PushOption(args, "-e", options.entitlements);
-	PushOption(args, "-o", options.output);
-	PushOption(args, "-t", options.tempDir);
-
-	if (options.zipLevel >= 0) {
-		args.emplace_back("-z");
-		args.emplace_back(std::to_string(options.zipLevel));
-	}
-
-	for (const auto& dylib : options.dylibs) {
-		if (!dylib.empty()) {
-			args.emplace_back("-l");
-			args.emplace_back(dylib);
-		}
-	}
-
-	args.emplace_back(options.input);
-
-	std::vector<char*> argv;
-	argv.reserve(args.size());
-	for (auto& arg : args) {
-		argv.push_back(const_cast<char*>(arg.c_str()));
-	}
-
-	optind = 1;
-#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
-	optreset = 1;
-#endif
-
-	const int exitCode = zsign_cli_main(static_cast<int>(argv.size()), argv.data());
-
-	ZSignBindingResult result;
-	result.exit_code = exitCode;
-	result.success = (exitCode == 0);
-	result.output_path = options.output;
-	result.install_requested = options.install;
-	result.check_requested = options.check;
-	return result;
-}
+#include "zsign_driver.h"
+
+#include <string>
+#include <vector>
+
+extern int zsign_cli_main(int argc, char** const argv);
+extern int optind;
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+extern int optreset;
+#endif
+
+namespace {
+
+void PushFlag(std::vector<std::string>& args, const char* flag, bool enabled) {
+	if (enabled) {
+		args.emplace_back(flag);
+	}
+}
+
+void PushOption(std::vector<std::string>& args, const char* flag, const std::string& value) {
+	if (!value.empty()) {
+		args.emplace_back(flag);
+		args.emplace_back(value);
+	}
+}
+
+} // namespace
+
+ZSignBindingResult RunZSignWithOptions(const ZSignBindingOptions& options) {
+	std::vector<std::string> args;
+	args.emplace_back("zsign");
+
+	PushFlag(args, "-d", options.debug);
+	PushFlag(args, "-f", options.force);
+	PushFlag(args, "-a", options.adhoc);
+	PushFlag(args, "-w", options.weakInject);
+	PushFlag(args, "-i", options.install);
+	PushFlag(args, "-q", options.quiet);
+	PushFlag(args, "-C", options.check);
+	PushFlag(args, "-2", options.sha256Only);
+
+	PushOption(args, "-c", options.certificate);
+	PushOption(args, "-k", options.privateKey);
+	PushOption(args, "-m", options.provisioningProfile);
+	PushOption(args, "-p", options.password);
+	PushOption(args, "-b", options.bundleId);
+	PushOption(args, "-r", options.bundleVersion);
+	PushOption(args, "-n", options.bundleDisplayName);
+	PushOption(args, "-e", options.entitlements);
+	PushOption(args, "-o", options.output);
+	PushOption(args, "-t", options.tempDir);
+
+	if (options.zipLevel >= 0) {
+		args.emplace_back("-z");
+		args.emplace_back(std::to_string(options.zipLevel));
+	}
+
+	for (const auto& dylib : options.dylibs) {
+		if (!dylib.empty()) {
+			args.emplace_back("-l");
+			args.emplace_back(dylib);
+		}
+	}
+
+	args.emplace_back(options.input);
+
+	std::vector<char*> argv;
+	argv.reserve(args.size());
+	for (auto& arg : args) {
+		argv.push_back(const_cast<char*>(arg.c_str()));
+	}
+
+	optind = 1;
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+	optreset = 1;
+#endif
+
+	const int exitCode = zsign_cli_main(static_cast<int>(argv.size()), argv.data());
+
+	ZSignBindingResult result;
+	result.exit_code = exitCode;
+	result.success = (exitCode == 0);
+	result.output_path = options.output;
+	result.install_requested = options.install;
+	result.check_requested = options.check;
+	return result;
+}