@arcote.tech/arc 0.3.3 → 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

@@ -3551,6 +3551,10 @@ 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);
   }
@@ -3558,14 +3562,20 @@ class StreamingQueryCache {
     const existing = this.activeStreams.get(viewName);
     if (existing) {
       existing.refCount++;
-      return () => this.unregisterStream(viewName);
+      return {
+        unsubscribe: () => this.unregisterStream(viewName),
+        wasReused: true
+      };
     }
     const streamConn = createStream();
     this.activeStreams.set(viewName, {
       unsubscribe: streamConn.unsubscribe,
       refCount: 1
     });
-    return () => this.unregisterStream(viewName);
+    return {
+      unsubscribe: () => this.unregisterStream(viewName),
+      wasReused: false
+    };
   }
   unregisterStream(viewName) {
     const stream = this.activeStreams.get(viewName);
@@ -3627,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) {
@@ -3781,14 +3794,13 @@ function streamingLiveQuery(model, queryFn, callback, options) {
         executeQuery();
       });
       unsubscribers.push(cacheUnsub);
-      const streamAlreadyExists = cache.hasActiveStream(viewName);
-      const streamUnsub = cache.registerStream(viewName, () => {
+      const { unsubscribe: streamUnsub, wasReused } = cache.registerStream(viewName, () => {
         return queryWire.stream(viewName, {}, (data) => {
           cache.setViewData(viewName, data);
         }, authToken);
       });
       unsubscribers.push(streamUnsub);
-      if (streamAlreadyExists) {
+      if (wasReused && cache.hasData(viewName)) {
         executeQuery();
       }
     }

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

@@ -40,17 +40,24 @@ 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 a function to unregister when done
+     * Returns object with unsubscribe function and whether stream was reused
      */
     registerStream(viewName: string, createStream: () => {
         unsubscribe: () => void;
-    }): () => void;
+    }): {
+        unsubscribe: () => void;
+        wasReused: boolean;
+    };
     /**
      * Unregister from a stream (decrement ref count, close if zero)
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.3.3",
+  "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",