@arcote.tech/arc-adapter-db-sqlite 0.3.3 → 0.4.1

package/dist/index.js

@@ -1352,7 +1352,364 @@ function apply(state, patches, applyOptions) {
 }
 var constructorString = Object.prototype.constructor.toString();
 
-// ../../../core-rewrite/dist/index.js
+// ../../../core/dist/index.js
+var TOKEN_PREFIX = "arc:token:";
+function hasLocalStorage() {
+  return typeof localStorage !== "undefined";
+}
+
+class AuthAdapter {
+  scopes = new Map;
+  setToken(token, scope = "default") {
+    if (!token) {
+      this.scopes.delete(scope);
+      if (hasLocalStorage())
+        localStorage.removeItem(TOKEN_PREFIX + scope);
+      return;
+    }
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) {
+        this.scopes.delete(scope);
+        if (hasLocalStorage())
+          localStorage.removeItem(TOKEN_PREFIX + scope);
+        return;
+      }
+      const payload = JSON.parse(atob(parts[1]));
+      this.scopes.set(scope, {
+        raw: token,
+        decoded: {
+          tokenName: payload.tokenName,
+          params: payload.params || {},
+          iat: payload.iat,
+          exp: payload.exp
+        }
+      });
+      if (hasLocalStorage())
+        localStorage.setItem(TOKEN_PREFIX + scope, token);
+    } catch {
+      this.scopes.delete(scope);
+      if (hasLocalStorage())
+        localStorage.removeItem(TOKEN_PREFIX + scope);
+    }
+  }
+  loadPersisted() {
+    if (!hasLocalStorage())
+      return;
+    for (let i = 0;i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(TOKEN_PREFIX)) {
+        const scope = key.slice(TOKEN_PREFIX.length);
+        const raw = localStorage.getItem(key);
+        if (raw) {
+          try {
+            const parts = raw.split(".");
+            if (parts.length !== 3)
+              continue;
+            const payload = JSON.parse(atob(parts[1]));
+            this.scopes.set(scope, {
+              raw,
+              decoded: {
+                tokenName: payload.tokenName,
+                params: payload.params || {},
+                iat: payload.iat,
+                exp: payload.exp
+              }
+            });
+          } catch {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    }
+  }
+  getToken(scope = "default") {
+    return this.scopes.get(scope)?.raw ?? null;
+  }
+  getDecoded(scope = "default") {
+    return this.scopes.get(scope)?.decoded ?? null;
+  }
+  getParams(scope = "default") {
+    return this.scopes.get(scope)?.decoded?.params ?? null;
+  }
+  getTokenName(scope = "default") {
+    return this.scopes.get(scope)?.decoded?.tokenName ?? null;
+  }
+  isAuthenticated(scope) {
+    if (scope !== undefined) {
+      return this.scopes.has(scope);
+    }
+    return this.scopes.size > 0;
+  }
+  isExpired(scope = "default") {
+    const entry = this.scopes.get(scope);
+    if (!entry?.decoded?.exp)
+      return false;
+    return Date.now() > entry.decoded.exp;
+  }
+  getAllScopes() {
+    return Array.from(this.scopes.keys());
+  }
+  clear() {
+    if (hasLocalStorage()) {
+      for (const scope of this.scopes.keys()) {
+        localStorage.removeItem(TOKEN_PREFIX + scope);
+      }
+    }
+    this.scopes.clear();
+  }
+}
+var eventWireInstanceCounter = 0;
+
+class EventWire {
+  baseUrl;
+  instanceId;
+  ws = null;
+  state = "disconnected";
+  scopeTokens = new Map;
+  lastHostEventId = null;
+  pendingEvents = [];
+  onEventCallback;
+  onSyncedCallback;
+  reconnectTimeout;
+  syncRequested = false;
+  viewSubscriptions = new Map;
+  viewSubCounter = 0;
+  pendingViewSubs = [];
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+    this.instanceId = ++eventWireInstanceCounter;
+  }
+  setScopeToken(scope, token) {
+    if (token === null) {
+      this.scopeTokens.delete(scope);
+    } else {
+      this.scopeTokens.set(scope, token);
+    }
+    if (this.state === "connected" && this.ws) {
+      if (token !== null) {
+        this.ws.send(JSON.stringify({
+          type: "scope:auth",
+          scope,
+          token
+        }));
+      }
+    }
+  }
+  hasScopeTokens() {
+    return this.scopeTokens.size > 0;
+  }
+  setLastHostEventId(id) {
+    this.lastHostEventId = id;
+  }
+  getLastHostEventId() {
+    return this.lastHostEventId;
+  }
+  connect() {
+    if (this.state !== "disconnected")
+      return;
+    this.state = "connecting";
+    let wsUrl;
+    if (this.baseUrl.startsWith("http://") || this.baseUrl.startsWith("https://")) {
+      wsUrl = this.baseUrl.replace(/^http/, "ws");
+    } else {
+      const protocol = typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:";
+      const host = typeof window !== "undefined" ? window.location.host : "localhost";
+      wsUrl = `${protocol}//${host}${this.baseUrl}`;
+    }
+    const url = `${wsUrl}/ws`;
+    try {
+      this.ws = new WebSocket(url);
+      this.ws.onopen = () => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.state = "connected";
+          this.sendAllScopeTokens();
+          this.requestSync();
+          this.flushPendingEvents();
+          this.flushPendingViewSubs();
+        } else {
+          console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
+        }
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.handleMessage(message);
+        } catch (err) {
+          console.error("EventWire: Failed to parse message", err);
+        }
+      };
+      this.ws.onclose = (event) => {
+        this.state = "disconnected";
+        this.ws = null;
+        console.log("EventWire disconnected");
+        this.scheduleReconnect();
+      };
+      this.ws.onerror = (err) => {
+        console.error("EventWire error:", err);
+        if (this.state === "connecting") {
+          this.state = "disconnected";
+          this.ws = null;
+        }
+      };
+    } catch (err) {
+      this.state = "disconnected";
+      this.ws = null;
+      console.error("EventWire: Failed to connect", err);
+      this.scheduleReconnect();
+    }
+  }
+  disconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = undefined;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.state = "disconnected";
+    this.syncRequested = false;
+  }
+  syncEvents(events) {
+    const isActuallyConnected = this.ws && this.ws.readyState === WebSocket.OPEN;
+    if (!isActuallyConnected) {
+      if (this.state === "connected" && !this.ws) {
+        this.state = "disconnected";
+      }
+      this.pendingEvents.push(...events);
+      if (this.state === "disconnected") {
+        this.connect();
+      }
+      return;
+    }
+    if (this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "sync-events",
+        events: events.map((e) => ({
+          localId: e.localId,
+          type: e.type,
+          payload: e.payload,
+          createdAt: e.createdAt
+        }))
+      }));
+    }
+  }
+  onEvent(callback) {
+    this.onEventCallback = callback;
+  }
+  onSynced(callback) {
+    this.onSyncedCallback = callback;
+  }
+  subscribeQuery(descriptor, callback, scope) {
+    const subscriptionId = `qs_${++this.viewSubCounter}_${Date.now()}`;
+    this.viewSubscriptions.set(subscriptionId, callback);
+    if (this.state === "connected" && this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "subscribe-query",
+        subscriptionId,
+        descriptor,
+        scope
+      }));
+    } else {
+      this.pendingViewSubs.push({ subscriptionId, descriptor, scope });
+    }
+    return subscriptionId;
+  }
+  unsubscribeQuery(subscriptionId) {
+    this.viewSubscriptions.delete(subscriptionId);
+    if (this.state === "connected" && this.ws) {
+      this.ws.send(JSON.stringify({
+        type: "unsubscribe-query",
+        subscriptionId
+      }));
+    }
+    this.pendingViewSubs = this.pendingViewSubs.filter((s) => s.subscriptionId !== subscriptionId);
+  }
+  getState() {
+    return this.state;
+  }
+  sendAllScopeTokens() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    for (const [scope, token] of this.scopeTokens) {
+      this.ws.send(JSON.stringify({
+        type: "scope:auth",
+        scope,
+        token
+      }));
+    }
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "events":
+        if (message.events && Array.isArray(message.events)) {
+          for (const event of message.events) {
+            if (this.onEventCallback) {
+              this.onEventCallback(event);
+            }
+          }
+        }
+        break;
+      case "sync-complete":
+        this.syncRequested = false;
+        if (message.lastHostEventId) {
+          this.lastHostEventId = message.lastHostEventId;
+        }
+        break;
+      case "query-data": {
+        const cb = this.viewSubscriptions.get(message.subscriptionId);
+        if (cb) {
+          cb(message.data);
+        }
+        break;
+      }
+      case "command-result":
+        break;
+      case "error":
+        console.error("EventWire error from host:", message.message);
+        break;
+    }
+  }
+  requestSync() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    if (this.syncRequested)
+      return;
+    this.syncRequested = true;
+    this.ws.send(JSON.stringify({
+      type: "request-sync",
+      lastHostEventId: this.lastHostEventId
+    }));
+  }
+  flushPendingEvents() {
+    if (this.pendingEvents.length > 0) {
+      this.syncEvents(this.pendingEvents);
+      this.pendingEvents = [];
+    }
+  }
+  flushPendingViewSubs() {
+    if (!this.ws || this.state !== "connected")
+      return;
+    for (const sub of this.pendingViewSubs) {
+      this.ws.send(JSON.stringify({
+        type: "subscribe-query",
+        subscriptionId: sub.subscriptionId,
+        descriptor: sub.descriptor,
+        scope: sub.scope
+      }));
+    }
+    this.pendingViewSubs = [];
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimeout)
+      return;
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = undefined;
+      this.connect();
+    }, 3000);
+  }
+}
 var EVENT_TABLES = {
   events: "events",
   tags: "event_tags",
@@ -1442,6 +1799,18 @@ class LocalEventPublisher {
     }
   }
   async notifySubscribers(event) {
+    const wildcardSubs = this.subscribers.get("*");
+    if (wildcardSubs) {
+      for (const callback of wildcardSubs) {
+        try {
+          const result = callback(event);
+          if (result instanceof Promise)
+            await result;
+        } catch (error) {
+          console.error(`[EventPublisher] Wildcard subscriber error:`, error);
+        }
+      }
+    }
     const subs = this.subscribers.get(event.type);
     if (!subs || subs.size === 0)
       return;
@@ -1564,8 +1933,8 @@ class ArcOptional {
     return null;
   }
   deserialize(value) {
-    if (!value)
-      return null;
+    if (value == null)
+      return;
     return this.parent.deserialize(value);
   }
   validate(value) {
@@ -1601,6 +1970,9 @@ class ArcBranded {
     this.parent = parent;
     this.brand = brand;
   }
+  get name() {
+    return this.brand;
+  }
   serialize(value) {
     return this.parent.serialize(value);
   }
@@ -2059,12 +2431,6 @@ class ArcObject extends ArcAbstract {
     return new ArcObject(partialShape);
   }
 }
-class ArcContextElement {
-  name;
-  constructor(name) {
-    this.name = name;
-  }
-}
 class ArcPrimitive extends ArcAbstract {
   serialize(value) {
     return value;
@@ -2328,6 +2694,24 @@ class ArcNumber extends ArcPrimitive {
     };
   }
 }
+class ArcFragmentBase {
+  is(type) {
+    return this.types.includes(type);
+  }
+}
+
+class ArcContextElement extends ArcFragmentBase {
+  name;
+  types = ["context-element"];
+  get id() {
+    return this.name;
+  }
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+}
+
 class ArcEvent extends ArcContextElement {
   data;
   eventId = id("event");
@@ -2430,6 +2814,43 @@ class ArcEvent extends ArcContextElement {
     return ArcEvent.sharedDatabaseStoreSchema();
   }
 }
+class AggregateBase {
+  value;
+  _id;
+  #adapters;
+  constructor(row, adapters) {
+    this._id = row._id;
+    const { _id, ...rest } = row;
+    this.value = rest;
+    this.#adapters = adapters;
+  }
+  toJSON() {
+    return { _id: this._id, ...this.value };
+  }
+  get ctx() {
+    const events = this.constructor.__aggregateEvents ?? [];
+    const adapters = this.#adapters;
+    const result = {};
+    for (const entry of events) {
+      const arcEvent = entry.event;
+      result[arcEvent.name] = {
+        emit: async (payload) => {
+          if (!adapters.eventPublisher) {
+            throw new Error(`Cannot emit event "${arcEvent.name}": no eventPublisher adapter available`);
+          }
+          const eventInstance = {
+            type: arcEvent.name,
+            payload,
+            id: `${Date.now()}_${Math.random().toString(36).slice(2)}`,
+            createdAt: new Date
+          };
+          await adapters.eventPublisher.publish(eventInstance);
+        }
+      };
+    }
+    return result;
+  }
+}
 class DataStorage {
   async commitChanges(changes) {
     await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
@@ -2489,6 +2910,9 @@ class StoreState {
   applySerializedChanges(changes) {
     return Promise.all(changes.map((change) => this.applyChange(change)));
   }
+  get listenerCount() {
+    return this.listeners.size;
+  }
   unsubscribe(listener4) {
     this.listeners.delete(listener4);
   }
@@ -3070,9 +3494,182 @@ function extractDatabaseAgnosticSchema(arcObject, tableName) {
   };
 }
 var dateValidator = typeValidatorBuilder("Date", (value) => value instanceof Date);
+function buildContextAccessor(context2, adapters, contextMethod, onCall) {
+  const result = {};
+  for (const element2 of context2.elements) {
+    const ctxFn = element2[contextMethod];
+    if (typeof ctxFn !== "function")
+      continue;
+    const methods = ctxFn.call(element2, adapters);
+    if (!methods || typeof methods !== "object")
+      continue;
+    const wrapped = {};
+    for (const [methodName, method] of Object.entries(methods)) {
+      if (typeof method !== "function")
+        continue;
+      wrapped[methodName] = (...args) => onCall({ element: element2.name, method: methodName, args }, () => method(...args));
+    }
+    result[element2.name] = wrapped;
+  }
+  return result;
+}
+function executeDescriptor(descriptor, context2, adapters, contextMethod) {
+  const element2 = context2.get(descriptor.element);
+  if (!element2) {
+    throw new Error(`Element '${descriptor.element}' not found in context`);
+  }
+  const ctxFn = element2[contextMethod];
+  if (typeof ctxFn !== "function") {
+    throw new Error(`Element '${descriptor.element}' has no ${contextMethod}`);
+  }
+  const methods = ctxFn.call(element2, adapters);
+  const method = methods?.[descriptor.method];
+  if (typeof method !== "function") {
+    throw new Error(`Method '${descriptor.method}' not found on '${descriptor.element}'`);
+  }
+  return method(...descriptor.args);
+}
+
+class ScopedModel {
+  context;
+  scopeName;
+  parent;
+  authAdapter;
+  scopedAdapters;
+  tokenListeners = new Set;
+  constructor(parent, scopeName) {
+    this.parent = parent;
+    this.context = parent.context;
+    this.scopeName = scopeName;
+    this.authAdapter = new AuthAdapter;
+    this.scopedAdapters = {
+      ...parent.getAdapters(),
+      authAdapter: this.authAdapter,
+      scope: this
+    };
+  }
+  setToken(token) {
+    this.authAdapter.setToken(token);
+    const eventWire = this.parent.getAdapters().eventWire;
+    if (eventWire) {
+      eventWire.setScopeToken(this.scopeName, token);
+      if (token && eventWire.getState() === "disconnected") {
+        eventWire.connect();
+      }
+    }
+    for (const listener4 of this.tokenListeners) {
+      listener4();
+    }
+  }
+  getToken() {
+    return this.authAdapter.getToken();
+  }
+  getDecoded() {
+    return this.authAdapter.getDecoded();
+  }
+  getParams() {
+    return this.authAdapter.getParams();
+  }
+  isAuthenticated() {
+    return this.authAdapter.isAuthenticated();
+  }
+  onTokenChange(listener4) {
+    this.tokenListeners.add(listener4);
+    return () => {
+      this.tokenListeners.delete(listener4);
+    };
+  }
+  getAdapters() {
+    return this.scopedAdapters;
+  }
+  getEnvironment() {
+    return this.parent.getEnvironment();
+  }
+  getAuth() {
+    return { scope: this.scopeName, token: this.getToken() };
+  }
+  executeCommand(name, params) {
+    const wire = this.parent.getAdapters().commandWire;
+    if (!wire) {
+      throw new Error(`Cannot execute command "${name}": no commandWire available.`);
+    }
+    return wire.executeCommand(name, params, this.getAuth());
+  }
+  remoteQuery(viewName, options) {
+    const wire = this.parent.getAdapters().queryWire;
+    if (!wire) {
+      throw new Error(`Cannot query "${viewName}": no queryWire available.`);
+    }
+    return wire.query(viewName, options, this.getAuth());
+  }
+  subscribeQuery(descriptor, callback) {
+    const wire = this.parent.getAdapters().eventWire;
+    if (!wire) {
+      throw new Error(`Cannot subscribe to query: no eventWire available.`);
+    }
+    return wire.subscribeQuery(descriptor, callback, this.scopeName);
+  }
+  get query() {
+    return buildContextAccessor(this.context, this.scopedAdapters, "queryContext", (descriptor) => descriptor);
+  }
+  get command() {
+    return buildContextAccessor(this.context, this.scopedAdapters, "mutateContext", (descriptor) => descriptor);
+  }
+  callQuery(descriptor) {
+    return executeDescriptor(descriptor, this.context, this.scopedAdapters, "queryContext");
+  }
+  callCommand(descriptor) {
+    return executeDescriptor(descriptor, this.context, this.scopedAdapters, "mutateContext");
+  }
+}
+
+class Model {
+  context;
+  adapters;
+  environment;
+  initialized = false;
+  scopes = new Map;
+  constructor(context2, options) {
+    this.context = context2;
+    this.adapters = options.adapters;
+    this.environment = options.environment;
+  }
+  async init() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.adapters.eventPublisher) {
+      const views = this.context.elements.filter((element2) => ("getHandlers" in element2) && ("databaseStoreSchema" in element2) && ("schema" in element2));
+      this.adapters.eventPublisher.registerViews(views);
+    }
+    for (const element2 of this.context.elements) {
+      if (element2.init) {
+        await element2.init(this.environment, this.adapters);
+      }
+    }
+    this.initialized = true;
+  }
+  getAdapters() {
+    return this.adapters;
+  }
+  getEnvironment() {
+    return this.environment;
+  }
+  scope(name) {
+    let s = this.scopes.get(name);
+    if (!s) {
+      s = new ScopedModel(this, name);
+      this.scopes.set(name, s);
+    }
+    return s;
+  }
+}
 class StreamingQueryCache {
   stores = new Map;
   views = [];
+  activeStreams = new Map;
+  pendingUnsubscribes = new Map;
+  static UNSUBSCRIBE_DELAY_MS = 5000;
   registerViews(views) {
     this.views = views;
     for (const view3 of views) {
@@ -3087,10 +3684,74 @@ class StreamingQueryCache {
     }
     return this.stores.get(viewName);
   }
-  setViewData(viewName, items) {
+  hasData(viewName) {
     const store = this.stores.get(viewName);
-    if (store) {
-      store.setAll(items);
+    return store ? store.hasData() : false;
+  }
+  hasActiveStream(viewName) {
+    return this.activeStreams.has(viewName);
+  }
+  registerStream(viewName, createStream) {
+    const pending = this.pendingUnsubscribes.get(viewName);
+    if (pending) {
+      clearTimeout(pending);
+      this.pendingUnsubscribes.delete(viewName);
+    }
+    const existing = this.activeStreams.get(viewName);
+    if (existing) {
+      existing.refCount++;
+      return {
+        unsubscribe: () => this.unregisterStream(viewName),
+        wasReused: true
+      };
+    }
+    const streamConn = createStream();
+    this.activeStreams.set(viewName, {
+      unsubscribe: streamConn.unsubscribe,
+      refCount: 1
+    });
+    return {
+      unsubscribe: () => this.unregisterStream(viewName),
+      wasReused: false
+    };
+  }
+  unregisterStream(viewName) {
+    const stream = this.activeStreams.get(viewName);
+    if (!stream)
+      return;
+    stream.refCount--;
+    if (stream.refCount <= 0) {
+      const timeout = setTimeout(() => {
+        this.pendingUnsubscribes.delete(viewName);
+        const current2 = this.activeStreams.get(viewName);
+        if (current2 && current2.refCount <= 0) {
+          current2.unsubscribe();
+          this.activeStreams.delete(viewName);
+        }
+      }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
+      this.pendingUnsubscribes.set(viewName, timeout);
+    }
+  }
+  subscribeQuery(descriptor, eventWire, scope) {
+    const key = descriptor.element;
+    const { unsubscribe } = this.registerStream(key, () => {
+      const subId = eventWire.subscribeQuery(descriptor, (data) => {
+        this.setViewData(descriptor.element, data);
+      }, scope);
+      return { unsubscribe: () => eventWire.unsubscribeQuery(subId) };
+    });
+    return unsubscribe;
+  }
+  setViewData(viewName, data) {
+    const store = this.stores.get(viewName);
+    if (!store)
+      return;
+    if (Array.isArray(data)) {
+      store.setAll(data);
+    } else if (data && typeof data === "object" && "_id" in data) {
+      store.setAll([data]);
+    } else {
+      store.setAll([]);
     }
   }
   async applyEvent(event3) {
@@ -3124,6 +3785,10 @@ class StreamingQueryCache {
     }
   }
   clear() {
+    for (const stream of this.activeStreams.values()) {
+      stream.unsubscribe();
+    }
+    this.activeStreams.clear();
     for (const store of this.stores.values()) {
       store.clear();
     }
@@ -3133,32 +3798,39 @@ class StreamingQueryCache {
 class StreamingStore {
   data = new Map;
   listeners = new Set;
+  initialized = false;
+  hasData() {
+    return this.initialized;
+  }
   setAll(items) {
+    this.initialized = true;
     this.data.clear();
     for (const item of items) {
       this.data.set(item._id, item);
     }
-    this.notifyListeners();
+    this.notifyListeners(null);
   }
   set(id3, item) {
     this.data.set(id3, item);
-    this.notifyListeners();
+    this.notifyListeners([{ type: "set", id: id3, item }]);
   }
   modify(id3, updates) {
     const existing = this.data.get(id3);
     if (existing) {
-      this.data.set(id3, { ...existing, ...updates });
-      this.notifyListeners();
+      const updated = { ...existing, ...updates };
+      this.data.set(id3, updated);
+      this.notifyListeners([{ type: "set", id: id3, item: updated }]);
     }
   }
   remove(id3) {
     if (this.data.delete(id3)) {
-      this.notifyListeners();
+      this.notifyListeners([{ type: "delete", id: id3, item: null }]);
     }
   }
   clear() {
+    this.initialized = false;
     this.data.clear();
-    this.notifyListeners();
+    this.notifyListeners(null);
   }
   find(options = {}) {
     let results = Array.from(this.data.values());
@@ -3177,9 +3849,9 @@ class StreamingStore {
       this.listeners.delete(listener4);
     };
   }
-  notifyListeners() {
+  notifyListeners(events) {
     for (const listener4 of this.listeners) {
-      listener4();
+      listener4(events);
     }
   }
 }
@@ -3248,6 +3920,7 @@ class StreamingEventPublisher {
     }
   }
 }
+
 class SecuredStoreState {
   store;
   tokenInstance;
@@ -4042,6 +4715,7 @@ class BunSQLiteDatabase {
   db;
   constructor(filename = ":memory:") {
     this.db = new Database(filename);
+    this.db.exec("PRAGMA journal_mode=WAL");
   }
   async exec(sql, params) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-sqlite",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",