@arcote.tech/arc 0.3.1 → 0.3.2

package/dist/index.js

@@ -48,14 +48,20 @@ class AuthAdapter {
 }
 // src/adapters/wire.ts
 class Wire {
-  baseUrl;
   token = null;
+  baseUrl;
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
   }
   setAuthToken(token) {
     this.token = token;
   }
+  getAuthToken() {
+    return this.token;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
   async fetch(endpoint, options = {}) {
     const headers = new Headers(options.headers);
     if (this.token) {
@@ -241,6 +247,62 @@ class EventWire {
     }, 3000);
   }
 }
+// src/adapters/query-wire.ts
+class QueryWire extends Wire {
+  constructor(baseUrl) {
+    super(baseUrl);
+  }
+  async query(viewName, options = {}) {
+    const response = await this.fetch(`/query/${viewName}`, {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Query ${viewName} failed: ${response.status} ${errorText}`);
+    }
+    return await response.json();
+  }
+  stream(viewName, options, callback, token) {
+    const params = new URLSearchParams;
+    if (options?.where) {
+      params.set("where", JSON.stringify(options.where));
+    }
+    if (options?.orderBy) {
+      params.set("orderBy", JSON.stringify(options.orderBy));
+    }
+    if (options?.limit) {
+      params.set("limit", String(options.limit));
+    }
+    const authToken = token ?? this.getAuthToken();
+    if (authToken) {
+      params.set("token", authToken);
+    }
+    const queryString = params.toString();
+    const url = `${this.getBaseUrl()}/stream/${viewName}${queryString ? `?${queryString}` : ""}`;
+    const eventSource = new EventSource(url);
+    eventSource.onmessage = (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        if (message.type === "data") {
+          callback(message.data);
+        }
+      } catch (err) {
+        console.error("QueryWire: Failed to parse SSE message", err);
+      }
+    };
+    eventSource.onerror = (err) => {
+      console.error("QueryWire: SSE error", err);
+    };
+    const unsubscribe = () => {
+      eventSource.close();
+    };
+    return {
+      eventSource,
+      unsubscribe
+    };
+  }
+}
 // src/adapters/event-publisher.ts
 var EVENT_TABLES = {
   events: "events",
@@ -252,6 +314,7 @@ class LocalEventPublisher {
   dataStorage;
   views = [];
   syncCallback;
+  subscribers = new Map;
   constructor(dataStorage) {
     this.dataStorage = dataStorage;
   }
@@ -261,6 +324,21 @@ class LocalEventPublisher {
   registerViews(views) {
     this.views = views;
   }
+  subscribe(eventType, callback) {
+    if (!this.subscribers.has(eventType)) {
+      this.subscribers.set(eventType, new Set);
+    }
+    this.subscribers.get(eventType).add(callback);
+    return () => {
+      const subs = this.subscribers.get(eventType);
+      if (subs) {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          this.subscribers.delete(eventType);
+        }
+      }
+    };
+  }
   async publish(event) {
     const allChanges = [];
     const storedEvent = {
@@ -309,10 +387,30 @@ class LocalEventPublisher {
     const viewChanges = await this.collectViewChanges(event);
     allChanges.push(...viewChanges);
     await this.dataStorage.commitChanges(allChanges);
+    await this.notifySubscribers(event);
     if (this.syncCallback) {
       this.syncCallback(event);
     }
   }
+  async notifySubscribers(event) {
+    const subs = this.subscribers.get(event.type);
+    if (!subs || subs.size === 0)
+      return;
+    const promises = [];
+    for (const callback of subs) {
+      try {
+        const result = callback(event);
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (error) {
+        console.error(`Listener error for event "${event.type}":`, error);
+      }
+    }
+    if (promises.length > 0) {
+      await Promise.all(promises.map((p) => p.catch((e) => console.error(e))));
+    }
+  }
   async markSynced(eventIds) {
     const syncStatusStore = this.dataStorage.getStore(EVENT_TABLES.syncStatus);
     const changes = eventIds.map((eventId) => ({
@@ -423,13 +521,6 @@ function contextMerge(...contexts) {
   const allElements = contexts.flatMap((ctx) => ctx.elements);
   return new ArcContext(allElements);
 }
-// src/context-element/context-element.ts
-class ArcContextElement {
-  name;
-  constructor(name) {
-    this.name = name;
-  }
-}
 // src/elements/optional.ts
 class ArcOptional {
   parent;
@@ -958,6 +1049,14 @@ function object(element) {
   return new ArcObject(element);
 }
 
+// src/context-element/context-element.ts
+class ArcContextElement {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+}
+
 // src/context-element/command/command.ts
 class ArcCommand extends ArcContextElement {
   data;
@@ -1502,17 +1601,13 @@ class ArcEvent extends ArcContextElement {
     });
     const tagsSchema = new ArcObject({
       _id: new ArcString().primaryKey(),
-      eventId: new ArcString().foreignKey("events", "_id", {
-        onDelete: "CASCADE"
-      }),
+      eventId: new ArcString().index(),
       tagKey: new ArcString().index(),
       tagValue: new ArcString().index()
     });
     const syncStatusSchema = new ArcObject({
       _id: new ArcString().primaryKey(),
-      eventId: new ArcString().foreignKey("events", "_id", {
-        onDelete: "CASCADE"
-      }),
+      eventId: new ArcString().index(),
       synced: new ArcBoolean().index(),
       timestamp: new ArcNumber,
       retryCount: new ArcNumber
@@ -1537,6 +1632,305 @@ function event(name, payload) {
     protections: []
   });
 }
+// src/context-element/listener/listener.ts
+class ArcListener extends ArcContextElement {
+  data;
+  unsubscribers = [];
+  constructor(data) {
+    super(data.name);
+    this.data = data;
+  }
+  description(description) {
+    return new ArcListener({
+      ...this.data,
+      description
+    });
+  }
+  listenTo(events) {
+    return new ArcListener({
+      ...this.data,
+      eventElements: events
+    });
+  }
+  query(elements) {
+    return new ArcListener({
+      ...this.data,
+      queryElements: elements
+    });
+  }
+  mutate(elements) {
+    return new ArcListener({
+      ...this.data,
+      mutationElements: elements
+    });
+  }
+  async() {
+    return new ArcListener({
+      ...this.data,
+      isAsync: true
+    });
+  }
+  handle(handler) {
+    return new ArcListener({
+      ...this.data,
+      handler
+    });
+  }
+  get eventElements() {
+    return this.data.eventElements || [];
+  }
+  get isAsync() {
+    return this.data.isAsync;
+  }
+  async init(environment, adapters) {
+    if (environment !== "server") {
+      return;
+    }
+    if (!this.data.handler) {
+      console.warn(`Listener "${this.data.name}" has no handler`);
+      return;
+    }
+    if (!adapters.eventPublisher) {
+      console.warn(`Listener "${this.data.name}" cannot subscribe: no eventPublisher adapter`);
+      return;
+    }
+    for (const eventElement of this.data.eventElements) {
+      const unsubscribe = adapters.eventPublisher.subscribe(eventElement.name, async (event2) => {
+        await this.handleEvent(event2, adapters);
+      });
+      this.unsubscribers.push(unsubscribe);
+    }
+  }
+  async handleEvent(event2, adapters) {
+    if (!this.data.handler)
+      return;
+    const context2 = this.buildListenerContext(adapters);
+    if (this.data.isAsync) {
+      Promise.resolve(this.data.handler(context2, event2)).catch((error) => {
+        console.error(`Async listener "${this.data.name}" error:`, error);
+      });
+    } else {
+      await this.data.handler(context2, event2);
+    }
+  }
+  buildListenerContext(adapters) {
+    const context2 = {};
+    const elementMap = new Map;
+    for (const element of this.data.queryElements) {
+      if (element.queryContext) {
+        const elementContext = element.queryContext(adapters);
+        context2[element.name] = elementContext;
+        elementMap.set(element, elementContext);
+      }
+    }
+    for (const element of this.data.mutationElements) {
+      if (element.mutateContext) {
+        const elementContext = element.mutateContext(adapters);
+        context2[element.name] = elementContext;
+        elementMap.set(element, elementContext);
+      }
+    }
+    context2.get = (element) => {
+      const cached = elementMap.get(element);
+      if (cached)
+        return cached;
+      if (element.queryContext) {
+        const ctx = element.queryContext(adapters);
+        elementMap.set(element, ctx);
+        return ctx;
+      }
+      if (element.mutateContext) {
+        const ctx = element.mutateContext(adapters);
+        elementMap.set(element, ctx);
+        return ctx;
+      }
+      throw new Error(`Element "${element.name}" has no context available`);
+    };
+    if (adapters.authAdapter) {
+      const decoded = adapters.authAdapter.getDecoded();
+      if (decoded) {
+        context2.$auth = {
+          params: decoded.params,
+          tokenName: decoded.tokenName
+        };
+      }
+    }
+    return context2;
+  }
+  destroy() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+}
+function listener(name) {
+  return new ArcListener({
+    name,
+    eventElements: [],
+    queryElements: [],
+    mutationElements: [],
+    isAsync: false
+  });
+}
+// src/context-element/route/route.ts
+class ArcRoute extends ArcContextElement {
+  data;
+  constructor(data) {
+    super(data.name);
+    this.data = data;
+  }
+  description(description) {
+    return new ArcRoute({
+      ...this.data,
+      description
+    });
+  }
+  path(path) {
+    return new ArcRoute({
+      ...this.data,
+      path
+    });
+  }
+  public() {
+    return new ArcRoute({
+      ...this.data,
+      isPublic: true
+    });
+  }
+  query(elements) {
+    return new ArcRoute({
+      ...this.data,
+      queryElements: elements
+    });
+  }
+  mutate(elements) {
+    return new ArcRoute({
+      ...this.data,
+      mutationElements: elements
+    });
+  }
+  protectBy(token, check) {
+    const existingProtections = this.data.protections || [];
+    return new ArcRoute({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    });
+  }
+  handle(handlers) {
+    return new ArcRoute({
+      ...this.data,
+      handlers
+    });
+  }
+  get routePath() {
+    return this.data.path || `/${this.data.name}`;
+  }
+  get fullPath() {
+    return `/route${this.routePath}`;
+  }
+  get isPublic() {
+    return this.data.isPublic;
+  }
+  get hasProtections() {
+    return (this.data.protections?.length ?? 0) > 0;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  getHandler(method) {
+    return this.data.handlers?.[method];
+  }
+  matchesPath(pathname) {
+    const routePath = this.fullPath;
+    const routeParts = routePath.split("/").filter(Boolean);
+    const pathParts = pathname.split("/").filter(Boolean);
+    if (routeParts.length !== pathParts.length) {
+      return { matches: false, params: {} };
+    }
+    const params = {};
+    for (let i = 0;i < routeParts.length; i++) {
+      const routePart = routeParts[i];
+      const pathPart = pathParts[i];
+      if (routePart.startsWith(":")) {
+        const paramName = routePart.slice(1);
+        params[paramName] = pathPart;
+      } else if (routePart !== pathPart) {
+        return { matches: false, params: {} };
+      }
+    }
+    return { matches: true, params };
+  }
+  async verifyProtections(tokens) {
+    if (this.data.isPublic) {
+      return true;
+    }
+    if (!this.data.protections || this.data.protections.length === 0) {
+      return true;
+    }
+    for (const protection of this.data.protections) {
+      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
+      if (!tokenInstance) {
+        return false;
+      }
+      const allowed = await protection.check(tokenInstance);
+      if (!allowed) {
+        return false;
+      }
+    }
+    return true;
+  }
+  buildContext(adapters, authParams) {
+    const context2 = {};
+    const elementMap = new Map;
+    for (const element of this.data.queryElements) {
+      if (element.queryContext) {
+        const elementContext = element.queryContext(adapters);
+        context2[element.name] = elementContext;
+        elementMap.set(element, elementContext);
+      }
+    }
+    for (const element of this.data.mutationElements) {
+      if (element.mutateContext) {
+        const elementContext = element.mutateContext(adapters);
+        context2[element.name] = elementContext;
+        elementMap.set(element, elementContext);
+      }
+    }
+    context2.get = (element) => {
+      const cached = elementMap.get(element);
+      if (cached)
+        return cached;
+      if (element.queryContext) {
+        const ctx = element.queryContext(adapters);
+        elementMap.set(element, ctx);
+        return ctx;
+      }
+      if (element.mutateContext) {
+        const ctx = element.mutateContext(adapters);
+        elementMap.set(element, ctx);
+        return ctx;
+      }
+      throw new Error(`Element "${element.name}" has no context available`);
+    };
+    if (authParams) {
+      context2.$auth = authParams;
+    }
+    return context2;
+  }
+}
+function route(name) {
+  return new ArcRoute({
+    name,
+    path: undefined,
+    description: undefined,
+    queryElements: [],
+    mutationElements: [],
+    handlers: {},
+    protections: [],
+    isPublic: false
+  });
+}
 // src/context-element/view/view.ts
 class ArcView extends ArcContextElement {
   data;
@@ -1596,20 +1990,22 @@ class ArcView extends ArcContextElement {
     const getReadRestrictions = () => {
       if (protections.length === 0)
         return null;
-      if (!adapters.authAdapter)
-        return null;
+      if (!adapters.authAdapter) {
+        return false;
+      }
       const decoded = adapters.authAdapter.getDecoded();
-      if (!decoded)
-        return null;
+      if (!decoded) {
+        return false;
+      }
       for (const protection of protections) {
         if (protection.token.name === decoded.tokenName) {
-          const rules = protection.protectionFn(decoded.params);
-          if (rules.read === false)
+          const restrictions = protection.protectionFn(decoded.params);
+          if (restrictions === false)
             return false;
-          return rules.read ?? null;
+          return restrictions ?? {};
         }
       }
-      return null;
+      return false;
     };
     const applyRestrictions = (options) => {
       const restrictions = getReadRestrictions();
@@ -1623,30 +2019,39 @@ class ArcView extends ArcContextElement {
     };
     return {
       find: async (options) => {
-        if (!adapters.dataStorage) {
-          console.warn(`View "${viewName}" query: no dataStorage available`);
-          return [];
-        }
         const restrictedOptions = applyRestrictions(options);
         if (restrictedOptions === false) {
           return [];
         }
-        const store = adapters.dataStorage.getStore(viewName);
-        return store.find(restrictedOptions);
+        if (adapters.dataStorage) {
+          const store = adapters.dataStorage.getStore(viewName);
+          return store.find(restrictedOptions);
+        }
+        if (adapters.queryWire) {
+          return adapters.queryWire.query(viewName, restrictedOptions);
+        }
+        console.warn(`View "${viewName}" query: no dataStorage or queryWire available`);
+        return [];
       },
       findOne: async (where) => {
-        if (!adapters.dataStorage) {
-          console.warn(`View "${viewName}" query: no dataStorage available`);
-          return;
-        }
         const restrictions = getReadRestrictions();
         if (restrictions === false) {
           return;
         }
-        const store = adapters.dataStorage.getStore(viewName);
         const mergedWhere = restrictions && Object.keys(restrictions).length > 0 ? { ...where, ...restrictions } : where;
-        const results = await store.find({ where: mergedWhere });
-        return results[0];
+        if (adapters.dataStorage) {
+          const store = adapters.dataStorage.getStore(viewName);
+          const results = await store.find({ where: mergedWhere });
+          return results[0];
+        }
+        if (adapters.queryWire) {
+          const results = await adapters.queryWire.query(viewName, {
+            where: mergedWhere
+          });
+          return results[0];
+        }
+        console.warn(`View "${viewName}" query: no dataStorage or queryWire available`);
+        return;
       }
     };
   }
@@ -1851,12 +2256,12 @@ class StoreState {
   applySerializedChanges(changes) {
     return Promise.all(changes.map((change) => this.applyChange(change)));
   }
-  unsubscribe(listener) {
-    this.listeners.delete(listener);
+  unsubscribe(listener4) {
+    this.listeners.delete(listener4);
   }
   notifyListeners(events) {
-    for (const listener of this.listeners.values()) {
-      listener.callback(events);
+    for (const listener4 of this.listeners.values()) {
+      listener4.callback(events);
     }
   }
 }
@@ -1869,7 +2274,7 @@ function deepMerge(target, source) {
       output[key] = undefined;
       continue;
     }
-    if (isObject(source[key]) && isObject(target[key])) {
+    if (isPlainObject(source[key]) && isPlainObject(target[key])) {
       output[key] = deepMerge(target[key], source[key]);
     } else {
       output[key] = source[key];
@@ -1877,8 +2282,8 @@ function deepMerge(target, source) {
   }
   return output;
 }
-function isObject(item) {
-  return item && typeof item === "object" && !Array.isArray(item);
+function isPlainObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && Object.prototype.toString.call(item) === "[object Object]";
 }
 // src/utils/murmur-hash.ts
 function murmurHash(key, seed = 0) {
@@ -2011,9 +2416,9 @@ class ForkedStoreState extends StoreState {
       this.notifyListeners(events);
     }
   }
-  async find(options, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
+  async find(options, listener4) {
+    if (listener4) {
+      this.listeners.set(listener4, { callback: listener4 });
     }
     const parentResults = await this.master.find(options);
     const results = new Map;
@@ -2172,9 +2577,9 @@ class MasterStoreState extends StoreState {
       this.notifyListeners(events);
     }
   }
-  async find(options, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
+  async find(options, listener4) {
+    if (listener4) {
+      this.listeners.set(listener4, { callback: listener4 });
     }
     const transaction = await this.dataStorage.getReadTransaction();
     const results = await transaction.find(this.storeName, options);
@@ -2364,13 +2769,13 @@ class ObservableDataStorage {
   commitChanges(changes) {
     return this.source.commitChanges(changes);
   }
-  trackQuery(storeName, options, result, listener) {
+  trackQuery(storeName, options, result, listener4) {
     const key = this.getQueryKey(storeName, options);
     this.trackedQueries.set(key, {
       storeName,
       options,
       result,
-      listener
+      listener: listener4
     });
   }
   handleStoreChange(storeName, events) {
@@ -2427,15 +2832,15 @@ class ObservableStoreState {
     if (cached !== undefined) {
       return cached;
     }
-    const listener = (events) => {
+    const listener4 = (events) => {
       this.observable.handleStoreChange(this.storeName, events);
     };
-    const result = await this.source.find(options, listener);
-    this.observable.trackQuery(this.storeName, options, result, listener);
+    const result = await this.source.find(options, listener4);
+    this.observable.trackQuery(this.storeName, options, result, listener4);
     return result;
   }
-  unsubscribe(listener) {
-    this.source.unsubscribe(listener);
+  unsubscribe(listener4) {
+    this.source.unsubscribe(listener4);
   }
   async set(item) {
     return this.source.set(item);
@@ -3127,33 +3532,276 @@ function mutationExecutor(model) {
     }
   });
 }
-// src/model/live-query/live-query.ts
-function createQueryContext(model, observableStorage) {
-  const adapters = model.getAdapters();
-  const observableAdapters = {
-    ...adapters,
-    dataStorage: observableStorage
-  };
-  return new Proxy({}, {
+// src/streaming/streaming-query-cache.ts
+class StreamingQueryCache {
+  stores = new Map;
+  views = [];
+  registerViews(views) {
+    this.views = views;
+    for (const view3 of views) {
+      if (!this.stores.has(view3.name)) {
+        this.stores.set(view3.name, new StreamingStore);
+      }
+    }
+  }
+  getStore(viewName) {
+    if (!this.stores.has(viewName)) {
+      this.stores.set(viewName, new StreamingStore);
+    }
+    return this.stores.get(viewName);
+  }
+  setViewData(viewName, items) {
+    const store = this.stores.get(viewName);
+    if (store) {
+      store.setAll(items);
+    }
+  }
+  async applyEvent(event3) {
+    for (const view3 of this.views) {
+      const handlers = view3.getHandlers();
+      const handler = handlers[event3.type];
+      if (!handler)
+        continue;
+      const store = this.stores.get(view3.name);
+      if (!store)
+        continue;
+      const ctx = {
+        set: async (id3, data) => {
+          store.set(String(id3), { _id: String(id3), ...data });
+        },
+        modify: async (id3, data) => {
+          store.modify(String(id3), data);
+        },
+        remove: async (id3) => {
+          store.remove(String(id3));
+        },
+        find: async (options) => {
+          return store.find(options);
+        },
+        findOne: async (where) => {
+          return store.findOne(where);
+        },
+        $auth: {}
+      };
+      await handler(ctx, event3);
+    }
+  }
+  clear() {
+    for (const store of this.stores.values()) {
+      store.clear();
+    }
+  }
+}
+
+class StreamingStore {
+  data = new Map;
+  listeners = new Set;
+  setAll(items) {
+    this.data.clear();
+    for (const item of items) {
+      this.data.set(item._id, item);
+    }
+    this.notifyListeners();
+  }
+  set(id3, item) {
+    this.data.set(id3, item);
+    this.notifyListeners();
+  }
+  modify(id3, updates) {
+    const existing = this.data.get(id3);
+    if (existing) {
+      this.data.set(id3, { ...existing, ...updates });
+      this.notifyListeners();
+    }
+  }
+  remove(id3) {
+    if (this.data.delete(id3)) {
+      this.notifyListeners();
+    }
+  }
+  clear() {
+    this.data.clear();
+    this.notifyListeners();
+  }
+  find(options = {}) {
+    let results = Array.from(this.data.values());
+    if (options.where) {
+      results = results.filter((item) => checkItemMatchesWhere(item, options.where));
+    }
+    return applyOrderByAndLimit(results, options);
+  }
+  findOne(where) {
+    const results = this.find({ where });
+    return results[0];
+  }
+  subscribe(listener4) {
+    this.listeners.add(listener4);
+    return () => {
+      this.listeners.delete(listener4);
+    };
+  }
+  notifyListeners() {
+    for (const listener4 of this.listeners) {
+      listener4();
+    }
+  }
+}
+// src/streaming/streaming-event-publisher.ts
+class StreamingEventPublisher {
+  cache;
+  eventWire;
+  views = [];
+  subscribers = new Map;
+  constructor(cache, eventWire) {
+    this.cache = cache;
+    this.eventWire = eventWire;
+  }
+  registerViews(views) {
+    this.views = views;
+    this.cache.registerViews(views);
+  }
+  async publish(event3) {
+    await this.cache.applyEvent(event3);
+    await this.notifySubscribers(event3);
+    this.eventWire.syncEvents([
+      {
+        localId: event3.id,
+        type: event3.type,
+        payload: event3.payload,
+        createdAt: event3.createdAt.toISOString()
+      }
+    ]);
+  }
+  subscribe(eventType, callback) {
+    if (!this.subscribers.has(eventType)) {
+      this.subscribers.set(eventType, new Set);
+    }
+    this.subscribers.get(eventType).add(callback);
+    return () => {
+      const subs = this.subscribers.get(eventType);
+      if (subs) {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          this.subscribers.delete(eventType);
+        }
+      }
+    };
+  }
+  async markSynced(_eventIds) {}
+  async getUnsyncedEvents(_eventType) {
+    return [];
+  }
+  async notifySubscribers(event3) {
+    const subs = this.subscribers.get(event3.type);
+    if (!subs || subs.size === 0)
+      return;
+    const promises = [];
+    for (const callback of subs) {
+      try {
+        const result = callback(event3);
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (error) {
+        console.error(`Listener error for event "${event3.type}":`, error);
+      }
+    }
+    if (promises.length > 0) {
+      await Promise.all(promises.map((p) => p.catch((e) => console.error(e))));
+    }
+  }
+}
+// src/streaming/streaming-live-query.ts
+function streamingLiveQuery(model, queryFn, callback, options) {
+  const { queryWire, cache, authToken } = options;
+  let currentResult = undefined;
+  const unsubscribers = [];
+  const streamConnections = [];
+  const queriedViews = new Set;
+  const queryContext = new Proxy({}, {
     get(_target, viewName) {
       const element2 = model.context.get(viewName);
       if (!element2) {
         throw new Error(`View '${viewName}' not found in context`);
       }
-      return element2.queryContext(observableAdapters);
+      queriedViews.add(viewName);
+      return {
+        find: async (findOptions = {}) => {
+          const store = cache.getStore(viewName);
+          return store.find(findOptions);
+        },
+        findOne: async (where) => {
+          const store = cache.getStore(viewName);
+          return store.findOne(where);
+        }
+      };
     }
   });
+  const executeQuery = async () => {
+    const result = await queryFn(queryContext);
+    currentResult = result;
+    callback(result);
+  };
+  const setupStreams = async () => {
+    queriedViews.clear();
+    await queryFn(queryContext);
+    for (const viewName of queriedViews) {
+      const store = cache.getStore(viewName);
+      const unsub = store.subscribe(() => {
+        executeQuery();
+      });
+      unsubscribers.push(unsub);
+      const streamConn = queryWire.stream(viewName, {}, (data) => {
+        cache.setViewData(viewName, data);
+      }, authToken);
+      streamConnections.push(streamConn);
+    }
+  };
+  setupStreams();
+  return {
+    get result() {
+      return currentResult;
+    },
+    unsubscribe: () => {
+      for (const unsub of unsubscribers) {
+        unsub();
+      }
+      for (const conn of streamConnections) {
+        conn.unsubscribe();
+      }
+    }
+  };
 }
+// src/model/live-query/live-query.ts
 function liveQuery(model, queryFn, callback) {
   let currentResult = undefined;
   const adapters = model.getAdapters();
-  if (!adapters.dataStorage) {
-    throw new Error("liveQuery requires dataStorage adapter");
+  if (!adapters.dataStorage && adapters.streamingCache && adapters.queryWire) {
+    return streamingLiveQuery(model, queryFn, callback, {
+      queryWire: adapters.queryWire,
+      cache: adapters.streamingCache,
+      authToken: adapters.authAdapter?.getToken?.() ?? null
+    });
+  }
+  if (!adapters.dataStorage && !adapters.queryWire) {
+    throw new Error("liveQuery requires dataStorage or queryWire adapter");
   }
-  const observableStorage = observeQueries(adapters.dataStorage, () => {
+  const observableStorage = adapters.dataStorage ? observeQueries(adapters.dataStorage, () => {
     executeQuery();
+  }) : null;
+  const observableAdapters = {
+    ...adapters,
+    dataStorage: observableStorage ?? undefined
+  };
+  const queryContext = new Proxy({}, {
+    get(_target, viewName) {
+      const element2 = model.context.get(viewName);
+      if (!element2) {
+        throw new Error(`View '${viewName}' not found in context`);
+      }
+      return element2.queryContext(observableAdapters);
+    }
   });
-  const queryContext = createQueryContext(model, observableStorage);
   const executeQuery = async () => {
     const result = await queryFn(queryContext);
     currentResult = result;
@@ -3165,7 +3813,7 @@ function liveQuery(model, queryFn, callback) {
       return currentResult;
     },
     unsubscribe: () => {
-      observableStorage.clear();
+      observableStorage?.clear();
     }
   };
 }
@@ -3552,7 +4200,9 @@ export {
   token,
   stringEnum,
   string,
+  streamingLiveQuery,
   secureDataStorage,
+  route,
   resolveQueryChange,
   record,
   or,
@@ -3562,6 +4212,7 @@ export {
   mutationExecutor,
   murmurHash,
   liveQuery,
+  listener,
   id,
   file,
   extractDatabaseAgnosticSchema,
@@ -3581,9 +4232,12 @@ export {
   Wire,
   TokenInstance,
   TokenCache,
+  StreamingQueryCache,
+  StreamingEventPublisher,
   StoreState,
   SecuredStoreState,
   SecuredDataStorage,
+  QueryWire,
   ObservableDataStorage,
   Model,
   MasterStoreState,
@@ -3600,11 +4254,13 @@ export {
   ArcToken,
   ArcStringEnum,
   ArcString,
+  ArcRoute,
   ArcRecord,
   ArcOr,
   ArcOptional,
   ArcObject,
   ArcNumber,
+  ArcListener,
   ArcId,
   ArcFile,
   ArcEvent,