@arcote.tech/arc 0.3.1 → 0.3.3

package/dist/model/live-query/live-query.d.ts

@@ -16,7 +16,8 @@ export type LiveQueryResult<T> = {
  *
  * Creates a live query that watches views and calls a callback when data changes.
  * Uses view's queryContext directly (applies protectBy restrictions).
- * Uses dataStorage.observeQueries() for reactivity.
+ * Uses dataStorage.observeQueries() for reactivity when available.
+ * Falls back to streaming mode (SSE) when no local storage.
  *
  * @example
  * ```typescript

package/dist/model/model-adapters.d.ts

@@ -2,12 +2,17 @@ import type { AuthAdapter } from "../adapters/auth-adapter";
 import type { CommandWire } from "../adapters/command-wire";
 import type { EventPublisher } from "../adapters/event-publisher";
 import type { EventWire } from "../adapters/event-wire";
+import type { QueryWire } from "../adapters/query-wire";
 import type { DataStorage } from "../data-storage";
+import type { StreamingQueryCache } from "../streaming";
 export type ModelAdapters = {
     dataStorage?: DataStorage;
     commandWire?: CommandWire;
     eventPublisher?: EventPublisher;
     eventWire?: EventWire;
     authAdapter?: AuthAdapter;
+    queryWire?: QueryWire;
+    /** Streaming mode cache - used when no local dataStorage */
+    streamingCache?: StreamingQueryCache;
 };
 //# sourceMappingURL=model-adapters.d.ts.map

package/dist/streaming/index.d.ts

@@ -0,0 +1,6 @@
+export { StreamingQueryCache } from "./streaming-query-cache";
+export type { CacheChangeListener, StreamingQueryCacheStore, } from "./streaming-query-cache";
+export { StreamingEventPublisher } from "./streaming-event-publisher";
+export { streamingLiveQuery } from "./streaming-live-query";
+export type { StreamingLiveQueryOptions } from "./streaming-live-query";
+//# sourceMappingURL=index.d.ts.map

package/dist/streaming/streaming-event-publisher.d.ts

@@ -0,0 +1,51 @@
+/**
+ * StreamingEventPublisher - Event publisher for streaming mode (no local database)
+ *
+ * When events are emitted:
+ * 1. Apply to local cache (optimistic update)
+ * 2. Send to server via EventWire
+ *
+ * This enables instant UI updates while syncing with server.
+ */
+import type { EventPublisher, EventWithSyncStatus } from "../adapters/event-publisher";
+import type { EventWire } from "../adapters/event-wire";
+import type { ArcEventAny } from "../context-element/event/event";
+import type { ArcEventInstance } from "../context-element/event/instance";
+import type { ArcViewAny } from "../context-element/view/view";
+import type { StreamingQueryCache } from "./streaming-query-cache";
+/**
+ * StreamingEventPublisher
+ */
+export declare class StreamingEventPublisher implements EventPublisher {
+    private readonly cache;
+    private readonly eventWire;
+    private views;
+    private subscribers;
+    constructor(cache: StreamingQueryCache, eventWire: EventWire);
+    /**
+     * Register views for event handling
+     */
+    registerViews(views: ArcViewAny[]): void;
+    /**
+     * Publish an event
+     * 1. Apply to local cache (optimistic)
+     * 2. Send to server
+     */
+    publish(event: ArcEventInstance<ArcEventAny>): Promise<void>;
+    /**
+     * Subscribe to events of a specific type
+     */
+    subscribe(eventType: string, callback: (event: ArcEventInstance<ArcEventAny>) => Promise<void> | void): () => void;
+    /**
+     * Mark events as synced - no-op in streaming mode
+     * (we don't track sync status locally)
+     */
+    markSynced(_eventIds: string[]): Promise<void>;
+    /**
+     * Get unsynced events - always empty in streaming mode
+     * (we send events immediately, don't queue them)
+     */
+    getUnsyncedEvents(_eventType?: string): Promise<EventWithSyncStatus[]>;
+    private notifySubscribers;
+}
+//# sourceMappingURL=streaming-event-publisher.d.ts.map

package/dist/streaming/streaming-live-query.d.ts

@@ -0,0 +1,25 @@
+/**
+ * StreamingLiveQuery - Live query implementation for streaming mode
+ *
+ * Uses SSE stream to get initial data and updates from server.
+ * Uses StreamingQueryCache for local state and reactivity.
+ * Deduplicates SSE streams - multiple queries on same view share one stream.
+ */
+import type { QueryWire } from "../adapters/query-wire";
+import type { ArcContextAny } from "../context/context";
+import type { LiveQueryResult, QueryContext } from "../model/live-query/live-query";
+import type { Model } from "../model/model";
+import type { StreamingQueryCache } from "./streaming-query-cache";
+export interface StreamingLiveQueryOptions {
+    queryWire: QueryWire;
+    cache: StreamingQueryCache;
+    authToken?: string | null;
+}
+/**
+ * Create a streaming live query
+ *
+ * Opens SSE stream to server, populates cache, and reacts to changes.
+ * Reuses existing streams for the same view (deduplication via cache).
+ */
+export declare function streamingLiveQuery<C extends ArcContextAny, TResult>(model: Model<C>, queryFn: (q: QueryContext<C>) => Promise<TResult>, callback: (data: TResult) => void, options: StreamingLiveQueryOptions): LiveQueryResult<TResult>;
+//# sourceMappingURL=streaming-live-query.d.ts.map

package/dist/streaming/streaming-query-cache.d.ts

@@ -0,0 +1,74 @@
+/**
+ * StreamingQueryCache - Lightweight in-memory cache for streaming mode
+ *
+ * Used when client connects without local database (no SQLite/IndexedDB).
+ * Holds view state in memory, receives data from SSE, applies local events.
+ *
+ * Features:
+ * - Stores view data in memory (Map-based)
+ * - Supports reactive queries with listeners
+ * - Applies view handlers for local event emission
+ * - Receives updates from SSE stream
+ * - Deduplicates SSE streams (one stream per view)
+ */
+import type { ArcEventAny } from "../context-element/event/event";
+import type { ArcEventInstance } from "../context-element/event/instance";
+import type { ArcViewAny } from "../context-element/view/view";
+import type { FindOptions } from "../data-storage/find-options";
+export type CacheChangeListener = () => void;
+export interface StreamingQueryCacheStore<Item extends {
+    _id: string;
+}> {
+    find(options?: FindOptions<Item>): Item[];
+    findOne(where?: Record<string, any>): Item | undefined;
+    subscribe(listener: CacheChangeListener): () => void;
+}
+/**
+ * StreamingQueryCache - Main cache class
+ */
+export declare class StreamingQueryCache {
+    private stores;
+    private views;
+    private activeStreams;
+    /**
+     * Register views that this cache will handle
+     */
+    registerViews(views: ArcViewAny[]): void;
+    /**
+     * Get a store for a specific view
+     */
+    getStore<Item extends {
+        _id: string;
+    }>(viewName: string): StreamingQueryCacheStore<Item>;
+    /**
+     * Check if a stream is already active for a view
+     */
+    hasActiveStream(viewName: string): boolean;
+    /**
+     * Register an active stream for a view (increment ref count if exists)
+     * Returns a function to unregister when done
+     */
+    registerStream(viewName: string, createStream: () => {
+        unsubscribe: () => void;
+    }): () => void;
+    /**
+     * Unregister from a stream (decrement ref count, close if zero)
+     */
+    private unregisterStream;
+    /**
+     * Set initial data for a view (from SSE stream)
+     */
+    setViewData<Item extends {
+        _id: string;
+    }>(viewName: string, items: Item[]): void;
+    /**
+     * Apply an event to update view state
+     * Runs view handlers to update the cache
+     */
+    applyEvent(event: ArcEventInstance<ArcEventAny>): Promise<void>;
+    /**
+     * Clear all cached data and close all streams
+     */
+    clear(): void;
+}
+//# sourceMappingURL=streaming-query-cache.d.ts.map

package/dist/token/index.d.ts

@@ -21,10 +21,7 @@
  *
  * // Define protection on view (not on token!)
  * const tasks = view("tasks", taskId, taskSchema)
- *   .protectBy(userToken, (params) => ({
- *     read: { userId: params.userId },
- *     write: { userId: params.userId },
- *   }));
+ *   .protectBy(userToken, (params) => ({ userId: params.userId }));
  *
  * // Create instance and use
  * const instance = userToken.create({ userId: "user_123" });
@@ -33,7 +30,7 @@
  * const securedStorage = secureDataStorage(dataStorage, instance, context);
  * ```
  */
-export { secureDataStorage, SecuredDataStorage, SecuredStoreState, } from "./secured-data-storage";
+export { SecuredDataStorage, SecuredStoreState, secureDataStorage, } from "./secured-data-storage";
 export { ArcToken, token, type ArcTokenAny } from "./token";
 export { TokenCache, type TokenCacheOptions } from "./token-cache";
 export type { ArcTokenData, TokenParams, TokenRule, TokenRuleContext, TokenRules, } from "./token-data";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",