@arcote.tech/arc 0.3.3 → 0.3.5

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

@@ -8,5 +8,12 @@ export * from "./context-element";
 export * from "./event";
 export * from "./listener";
 export * from "./route";
+export * from "./static-view";
 export * from "./view";
+import type { ArcStaticViewAny, ArcStaticViewRecord } from "./static-view";
+import type { ArcViewAny, ArcViewRecord } from "./view";
+/**
+ * Helper type to extract record type from any view (regular or static)
+ */
+export type ArcAnyViewRecord<View extends ArcViewAny | ArcStaticViewAny> = View extends ArcViewAny ? ArcViewRecord<View> : View extends ArcStaticViewAny ? ArcStaticViewRecord<View> : never;
 //# sourceMappingURL=index.d.ts.map

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: (Schema & ArcObject<any, any>) | 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;
+        };
+    }]>;
+    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

@@ -1931,6 +1931,84 @@ function route(name) {
     isPublic: false
   });
 }
+// src/context-element/static-view/static-view.ts
+class ArcStaticView extends ArcContextElement {
+  data;
+  constructor(data) {
+    super(data.name);
+    this.data = data;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get schema() {
+    return this.data.schema;
+  }
+  get items() {
+    return this.data.items;
+  }
+  description(description) {
+    return new ArcStaticView({
+      ...this.data,
+      description
+    });
+  }
+  addItems(items) {
+    return new ArcStaticView({
+      ...this.data,
+      items
+    });
+  }
+  queryContext(_adapters) {
+    const items = this.data.items;
+    return {
+      find: async (options) => {
+        let results = [...items];
+        if (options?.where) {
+          results = results.filter((item) => this.matchesWhere(item, options.where));
+        }
+        if (options?.orderBy) {
+          const entries = Object.entries(options.orderBy);
+          results.sort((a, b) => {
+            for (const [key, direction] of entries) {
+              const aVal = a[key];
+              const bVal = b[key];
+              if (aVal < bVal)
+                return direction === "asc" ? -1 : 1;
+              if (aVal > bVal)
+                return direction === "asc" ? 1 : -1;
+            }
+            return 0;
+          });
+        }
+        if (options?.limit) {
+          results = results.slice(0, options.limit);
+        }
+        return results;
+      },
+      findOne: async (where) => {
+        if (!where)
+          return items[0];
+        const item = items.find((item2) => this.matchesWhere(item2, where));
+        return item;
+      }
+    };
+  }
+  matchesWhere(item, where) {
+    return Object.entries(where).every(([key, value]) => {
+      return item[key] === value;
+    });
+  }
+}
+function staticView(name, id2, schema) {
+  const schemaObj = schema instanceof ArcObject ? schema : new ArcObject(schema);
+  return new ArcStaticView({
+    name,
+    id: id2,
+    schema: schemaObj,
+    items: []
+  });
+}
 // src/context-element/view/view.ts
 class ArcView extends ArcContextElement {
   data;
@@ -3551,6 +3629,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 +3640,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 +3715,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) {
@@ -3743,17 +3834,25 @@ class StreamingEventPublisher {
   }
 }
 // src/streaming/streaming-live-query.ts
+function isStaticView(element2) {
+  return element2 && "items" in element2 && !("getHandlers" in element2);
+}
 function streamingLiveQuery(model, queryFn, callback, options) {
   const { queryWire, cache, authToken } = options;
   let currentResult = undefined;
   const unsubscribers = [];
   const queriedViews = new Set;
+  const staticViews = 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`);
       }
+      if (isStaticView(element2)) {
+        staticViews.add(viewName);
+        return element2.queryContext(model.getAdapters());
+      }
       queriedViews.add(viewName);
       return {
         find: async (findOptions = {}) => {
@@ -3774,21 +3873,25 @@ function streamingLiveQuery(model, queryFn, callback, options) {
   };
   const setupStreams = async () => {
     queriedViews.clear();
+    staticViews.clear();
     await queryFn(queryContext);
+    if (queriedViews.size === 0 && staticViews.size > 0) {
+      executeQuery();
+      return;
+    }
     for (const viewName of queriedViews) {
       const store = cache.getStore(viewName);
       const cacheUnsub = store.subscribe(() => {
         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();
       }
     }
@@ -4234,6 +4337,7 @@ export {
   stringEnum,
   string,
   streamingLiveQuery,
+  staticView,
   secureDataStorage,
   route,
   resolveQueryChange,
@@ -4287,6 +4391,7 @@ export {
   ArcToken,
   ArcStringEnum,
   ArcString,
+  ArcStaticView,
   ArcRoute,
   ArcRecord,
   ArcOr,

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

@@ -4,6 +4,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.
+ * Static views are handled directly without SSE.
  */
 import type { QueryWire } from "../adapters/query-wire";
 import type { ArcContextAny } from "../context/context";
@@ -20,6 +21,7 @@ export interface StreamingLiveQueryOptions {
  *
  * Opens SSE stream to server, populates cache, and reacts to changes.
  * Reuses existing streams for the same view (deduplication via cache).
+ * Static views return data directly without SSE.
  */
 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

@@ -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.5",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc framework core rewrite with improved event emission and type safety",