@arcote.tech/arc 0.3.2 → 0.3.4

package/dist/context-element/static-view/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./static-view";
+export * from "./static-view-data";
+//# sourceMappingURL=index.d.ts.map

package/dist/context-element/static-view/static-view-data.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Static View Data - Type definitions for static view configuration
+ */
+import type { ArcObjectAny } from "../../elements/object";
+/**
+ * Static view data structure
+ */
+export interface ArcStaticViewData {
+    name: string;
+    id: any;
+    schema: ArcObjectAny;
+    items: any[];
+    description?: string;
+}
+//# sourceMappingURL=static-view-data.d.ts.map

package/dist/context-element/static-view/static-view.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Arc Static View - Read-only view with hardcoded data
+ *
+ * Static views contain data defined at build time, not populated from events.
+ * Useful for product catalogs, pricing tiers, configuration options, etc.
+ *
+ * Features:
+ * - Define items at build time via addItems()
+ * - Query via find/findOne (same interface as regular views)
+ * - No event handlers (read-only)
+ * - No database storage (in-memory)
+ * - Always public (no protectBy)
+ *
+ * @example
+ * ```typescript
+ * const products = staticView("products", productId, {
+ *   name: string(),
+ *   price: number(),
+ * }).addItems([
+ *   { _id: "basic", name: "Basic Plan", price: 9.99 },
+ *   { _id: "pro", name: "Pro Plan", price: 29.99 },
+ * ]);
+ * ```
+ */
+import type { ArcObjectAny, ArcRawShape } from "../../elements/object";
+import { ArcObject } from "../../elements/object";
+import type { ModelAdapters } from "../../model/model-adapters";
+import type { Merge } from "../../utils";
+import type { $type } from "../../utils/types/get-type";
+import { ArcContextElement } from "../context-element";
+import type { ArcStaticViewData } from "./static-view-data";
+/** Item type for static view */
+export type ArcStaticViewItem<Id, Schema extends ArcObjectAny> = {
+    _id: Id extends {
+        deserialize: (...args: any) => any;
+    } ? $type<Id> : Id;
+} & $type<Schema>;
+/**
+ * Arc Static View class
+ */
+export declare class ArcStaticView<const Data extends ArcStaticViewData> extends ArcContextElement<Data["name"]> {
+    private readonly data;
+    constructor(data: Data);
+    /**
+     * Get view ID schema
+     */
+    get id(): Data["id"];
+    /**
+     * Get view schema
+     */
+    get schema(): Data["schema"];
+    /**
+     * Get static items
+     */
+    get items(): Data["items"];
+    /**
+     * Set view description for documentation
+     */
+    description<const Desc extends string>(description: Desc): ArcStaticView<Merge<Data, {
+        description: Desc;
+    }>>;
+    /**
+     * Add static items to the view
+     */
+    addItems<const Items extends ArcStaticViewItem<Data["id"], Data["schema"]>[]>(items: Items): ArcStaticView<Merge<Data, {
+        items: Items;
+    }>>;
+    /**
+     * Generate query context for this static view
+     * Returns find/findOne methods that query the static items
+     */
+    queryContext(_adapters: ModelAdapters): {
+        find: (options?: {
+            where?: Record<string, any>;
+            orderBy?: Record<string, "asc" | "desc">;
+            limit?: number;
+        }) => Promise<Data["items"]>;
+        findOne: (where?: Record<string, any>) => Promise<Data["items"][number] | undefined>;
+    };
+    /**
+     * Check if an item matches a where clause
+     */
+    private matchesWhere;
+}
+/**
+ * Create a new static view with the given name, ID schema, and data schema
+ *
+ * @param name - Unique view name
+ * @param id - ID schema for view records
+ * @param schema - Data schema for view records
+ * @returns New static view instance ready for configuration
+ *
+ * @example
+ * ```typescript
+ * const plans = staticView("plans", planId, {
+ *   name: string(),
+ *   price: number(),
+ * }).addItems([
+ *   { _id: "free", name: "Free", price: 0 },
+ *   { _id: "pro", name: "Pro", price: 19.99 },
+ * ]);
+ * ```
+ */
+export declare function staticView<const Name extends string, Id, Schema extends ArcObjectAny | ArcRawShape>(name: Name, id: Id, schema: Schema): ArcStaticView<{
+    name: Name;
+    id: Id;
+    schema: ArcObject<ArcRawShape, [{
+        name: "type";
+        validator: (value: any) => false | {
+            current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            expected: "object";
+        };
+    }, {
+        name: "schema";
+        validator: (value: any) => false | {
+            [x: string]: unknown;
+        };
+    }]> | (Schema & ArcObject<any, any>);
+    items: [];
+}>;
+/**
+ * Type alias for any static view (used in collections)
+ */
+export type ArcStaticViewAny = ArcStaticView<any>;
+/**
+ * Helper type to extract static view record type
+ */
+export type ArcStaticViewRecord<View extends ArcStaticViewAny> = View extends ArcStaticView<infer Data> ? ArcStaticViewItem<Data["id"], Data["schema"]> : never;
+//# sourceMappingURL=static-view.d.ts.map

package/dist/index.js

@@ -3536,6 +3536,7 @@ function mutationExecutor(model) {
 class StreamingQueryCache {
   stores = new Map;
   views = [];
+  activeStreams = new Map;
   registerViews(views) {
     this.views = views;
     for (const view3 of views) {
@@ -3550,6 +3551,42 @@ class StreamingQueryCache {
     }
     return this.stores.get(viewName);
   }
+  hasData(viewName) {
+    const store = this.stores.get(viewName);
+    return store ? store.hasData() : false;
+  }
+  hasActiveStream(viewName) {
+    return this.activeStreams.has(viewName);
+  }
+  registerStream(viewName, createStream) {
+    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) {
+      stream.unsubscribe();
+      this.activeStreams.delete(viewName);
+    }
+  }
   setViewData(viewName, items) {
     const store = this.stores.get(viewName);
     if (store) {
@@ -3587,6 +3624,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();
     }
@@ -3596,6 +3637,9 @@ class StreamingQueryCache {
 class StreamingStore {
   data = new Map;
   listeners = new Set;
+  hasData() {
+    return this.data.size > 0;
+  }
   setAll(items) {
     this.data.clear();
     for (const item of items) {
@@ -3716,7 +3760,6 @@ 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) {
@@ -3747,14 +3790,19 @@ function streamingLiveQuery(model, queryFn, callback, options) {
     await queryFn(queryContext);
     for (const viewName of queriedViews) {
       const store = cache.getStore(viewName);
-      const unsub = store.subscribe(() => {
+      const cacheUnsub = store.subscribe(() => {
         executeQuery();
       });
-      unsubscribers.push(unsub);
-      const streamConn = queryWire.stream(viewName, {}, (data) => {
-        cache.setViewData(viewName, data);
-      }, authToken);
-      streamConnections.push(streamConn);
+      unsubscribers.push(cacheUnsub);
+      const { unsubscribe: streamUnsub, wasReused } = cache.registerStream(viewName, () => {
+        return queryWire.stream(viewName, {}, (data) => {
+          cache.setViewData(viewName, data);
+        }, authToken);
+      });
+      unsubscribers.push(streamUnsub);
+      if (wasReused && cache.hasData(viewName)) {
+        executeQuery();
+      }
     }
   };
   setupStreams();
@@ -3766,9 +3814,6 @@ function streamingLiveQuery(model, queryFn, callback, options) {
       for (const unsub of unsubscribers) {
         unsub();
       }
-      for (const conn of streamConnections) {
-        conn.unsubscribe();
-      }
     }
   };
 }

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

@@ -3,6 +3,7 @@
  *
  * 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";
@@ -18,6 +19,7 @@ export interface StreamingLiveQueryOptions {
  * 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

@@ -9,6 +9,7 @@
  * - 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";
@@ -28,6 +29,7 @@ export interface StreamingQueryCacheStore<Item extends {
 export declare class StreamingQueryCache {
     private stores;
     private views;
+    private activeStreams;
     /**
      * Register views that this cache will handle
      */
@@ -38,6 +40,28 @@ export declare class StreamingQueryCache {
     getStore<Item extends {
         _id: string;
     }>(viewName: string): StreamingQueryCacheStore<Item>;
+    /**
+     * Check if a store has any data
+     */
+    hasData(viewName: string): boolean;
+    /**
+     * 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 object with unsubscribe function and whether stream was reused
+     */
+    registerStream(viewName: string, createStream: () => {
+        unsubscribe: () => void;
+    }): {
+        unsubscribe: () => void;
+        wasReused: boolean;
+    };
+    /**
+     * Unregister from a stream (decrement ref count, close if zero)
+     */
+    private unregisterStream;
     /**
      * Set initial data for a view (from SSE stream)
      */
@@ -50,7 +74,7 @@ export declare class StreamingQueryCache {
      */
     applyEvent(event: ArcEventInstance<ArcEventAny>): Promise<void>;
     /**
-     * Clear all cached data
+     * Clear all cached data and close all streams
      */
     clear(): void;
 }

package/package.json

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