@photostructure/sqlite 0.0.1

package/src/shims/node_errors.h

@@ -0,0 +1,66 @@
+#ifndef SRC_SHIMS_NODE_ERRORS_H_
+#define SRC_SHIMS_NODE_ERRORS_H_
+
+#include <napi.h>
+
+#include <string>
+
+namespace node {
+
+// Error throwing utilities matching Node.js patterns
+inline void THROW_ERR_INVALID_STATE(Napi::Env env,
+                                    const char *message = nullptr) {
+  const char *msg = message ? message : "Invalid state";
+  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_INVALID_ARG_TYPE(Napi::Env env,
+                                       const char *message = nullptr) {
+  const char *msg = message ? message : "Invalid argument type";
+  Napi::TypeError::New(env, msg).ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_OUT_OF_RANGE(Napi::Env env,
+                                   const char *message = nullptr) {
+  const char *msg = message ? message : "Value out of range";
+  Napi::RangeError::New(env, msg).ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_INVALID_ARG_VALUE(Napi::Env env,
+                                        const char *message = nullptr) {
+  const char *msg = message ? message : "Invalid argument value";
+  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_SQLITE_ERROR(Napi::Env env,
+                                   const char *message = nullptr) {
+  const char *msg = message ? message : "SQLite error";
+  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_CONSTRUCT_CALL_REQUIRED(Napi::Env env) {
+  Napi::TypeError::New(env, "Class constructor cannot be invoked without 'new'")
+      .ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_INVALID_URL_SCHEME(Napi::Env env,
+                                         const char *scheme = nullptr) {
+  std::string msg = "Invalid URL scheme";
+  if (scheme) {
+    msg += ": ";
+    msg += scheme;
+  }
+  Napi::TypeError::New(env, msg).ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_LOAD_SQLITE_EXTENSION(Napi::Env env,
+                                            const char *message = nullptr) {
+  const char *msg = message ? message : "Failed to load SQLite extension";
+  Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+}
+
+// Macro wrappers for compatibility (removed to avoid conflicts)
+
+} // namespace node
+
+#endif // SRC_SHIMS_NODE_ERRORS_H_

package/src/shims/node_mem-inl.h

@@ -0,0 +1,8 @@
+#ifndef SRC_SHIMS_NODE_MEM_INL_H_
+#define SRC_SHIMS_NODE_MEM_INL_H_
+
+#include "node_mem.h"
+
+// Inline implementations
+
+#endif // SRC_SHIMS_NODE_MEM_INL_H_

package/src/shims/node_mem.h

@@ -0,0 +1,31 @@
+#ifndef SRC_SHIMS_NODE_MEM_H_
+#define SRC_SHIMS_NODE_MEM_H_
+
+#include <cstdlib>
+#include <memory>
+
+namespace node {
+
+// Memory allocation wrappers
+template <typename T> T *Malloc(size_t count) {
+  return static_cast<T *>(std::malloc(sizeof(T) * count));
+}
+
+template <typename T> T *Realloc(T *ptr, size_t count) {
+  return static_cast<T *>(std::realloc(ptr, sizeof(T) * count));
+}
+
+inline void Free(void *ptr) { std::free(ptr); }
+
+// Memory tracker stub
+class MemoryTracker {
+public:
+  template <typename T> void TrackField(const char *, const T &) {}
+
+  template <typename T>
+  void TrackFieldWithSize(const char *, const T &, size_t) {}
+};
+
+} // namespace node
+
+#endif // SRC_SHIMS_NODE_MEM_H_

package/src/shims/node_url.h

@@ -0,0 +1,23 @@
+#ifndef SRC_SHIMS_NODE_URL_H_
+#define SRC_SHIMS_NODE_URL_H_
+
+#include <string>
+
+namespace node {
+namespace url {
+
+// URL utilities - minimal implementation
+class URL {
+public:
+  explicit URL(const std::string &input) : href_(input) {}
+
+  const std::string &href() const { return href_; }
+
+private:
+  std::string href_;
+};
+
+} // namespace url
+} // namespace node
+
+#endif // SRC_SHIMS_NODE_URL_H_

package/src/shims/promise_resolver.h

@@ -0,0 +1,31 @@
+#ifndef SRC_SHIMS_PROMISE_RESOLVER_H_
+#define SRC_SHIMS_PROMISE_RESOLVER_H_
+
+#include <napi.h>
+
+namespace node {
+
+// Promise resolver wrapper for N-API
+class PromiseResolver {
+public:
+  static PromiseResolver Create(Napi::Env env) {
+    auto deferred = Napi::Promise::Deferred::New(env);
+    return PromiseResolver(deferred);
+  }
+
+  Napi::Promise GetPromise() { return deferred_.Promise(); }
+
+  void Resolve(Napi::Value value) { deferred_.Resolve(value); }
+
+  void Reject(Napi::Value value) { deferred_.Reject(value); }
+
+private:
+  explicit PromiseResolver(Napi::Promise::Deferred deferred)
+      : deferred_(deferred) {}
+
+  Napi::Promise::Deferred deferred_;
+};
+
+} // namespace node
+
+#endif // SRC_SHIMS_PROMISE_RESOLVER_H_

package/src/shims/util-inl.h

@@ -0,0 +1,18 @@
+#ifndef SRC_SHIMS_UTIL_INL_H_
+#define SRC_SHIMS_UTIL_INL_H_
+
+#include "util.h"
+
+namespace node {
+
+inline void THROW_ERR_INVALID_ARG_TYPE(Napi::Env env, const char *message) {
+  Napi::TypeError::New(env, message).ThrowAsJavaScriptException();
+}
+
+inline void THROW_ERR_OUT_OF_RANGE(Napi::Env env, const char *message) {
+  Napi::RangeError::New(env, message).ThrowAsJavaScriptException();
+}
+
+} // namespace node
+
+#endif // SRC_SHIMS_UTIL_INL_H_

package/src/shims/util.h

@@ -0,0 +1,101 @@
+#ifndef SRC_SHIMS_UTIL_H_
+#define SRC_SHIMS_UTIL_H_
+
+#include <napi.h>
+
+#include <algorithm>
+#include <string>
+#include <unordered_map>
+
+namespace node {
+
+// Environment class for Node.js context
+class Environment {
+public:
+  static Environment *GetCurrent(Napi::Env env) {
+    // Store per-environment instances
+    static thread_local std::unordered_map<napi_env,
+                                           std::unique_ptr<Environment>>
+        instances;
+    auto it = instances.find(env);
+    if (it == instances.end()) {
+      auto result = instances.emplace(env, std::make_unique<Environment>(env));
+      return result.first->second.get();
+    }
+    return it->second.get();
+  }
+
+  explicit Environment(Napi::Env env) : env_(env) {}
+
+  Napi::Env env() const { return env_; }
+  napi_env raw_env() const { return env_; }
+
+  // String caching for common strings (simplified)
+  Napi::String href_string() const { return Napi::String::New(env_, "href"); }
+  Napi::String timeout_string() const {
+    return Napi::String::New(env_, "timeout");
+  }
+  Napi::String backup_string() const {
+    return Napi::String::New(env_, "backup");
+  }
+  Napi::String constants_string() const {
+    return Napi::String::New(env_, "constants");
+  }
+
+  // Permission system stub
+  class Permission {
+  public:
+    bool is_granted() const { return true; }
+  };
+
+  Permission *permission() {
+    static Permission perm;
+    return &perm;
+  }
+
+private:
+  Napi::Env env_;
+};
+
+// String utilities
+inline std::string ToLower(const std::string &str) {
+  std::string result = str;
+  std::transform(result.begin(), result.end(), result.begin(), ::tolower);
+  return result;
+}
+
+// Template helpers for setting constructor functions
+template <typename T>
+void SetConstructorFunction(Napi::Env env, Napi::Object target,
+                            const char *name, Napi::Function constructor) {
+  target.Set(name, constructor);
+}
+
+// Template helpers for setting prototype methods
+template <typename T>
+void SetProtoMethod(napi_env env, Napi::Function constructor, const char *name,
+                    napi_callback callback) {
+  // This would need more sophisticated implementation for full compatibility
+  // For now, we'll handle this in the class definitions
+}
+
+template <typename T>
+void SetProtoMethodNoSideEffect(napi_env env, Napi::Function constructor,
+                                const char *name, napi_callback callback) {
+  SetProtoMethod<T>(env, constructor, name, callback);
+}
+
+// Getter helpers
+template <typename T>
+void SetSideEffectFreeGetter(napi_env env, Napi::Function constructor,
+                             Napi::String name, napi_callback callback) {
+  // Simplified implementation
+}
+
+// Error throwing helpers
+void THROW_ERR_INVALID_ARG_TYPE(Napi::Env env, const char *message);
+void THROW_ERR_OUT_OF_RANGE(Napi::Env env, const char *message);
+
+} // namespace node
+
+#endif // SRC_SHIMS_UTIL_H_