@arcote.tech/arc 0.1.10 → 0.1.12

package/dist/command/command-definition.d.ts

@@ -0,0 +1,5 @@
+export type CommandDefinition = {
+    readonly commandName: string;
+    readonly parameters: any;
+};
+//# sourceMappingURL=command-definition.d.ts.map

package/dist/context/context.d.ts

@@ -21,11 +21,15 @@ export type ArcCommandContext<E extends ArcContextElementAny[]> = ArcContextElem
 export type RemoveFalseAndResolvedPromiseFromArray<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends false ? RemoveFalseAndResolvedPromiseFromArray<Rest> : First extends Promise<{
     default: infer Inner;
 }> ? RemoveFalseAndResolvedPromiseFromArray<[Inner, ...Rest]> : [First, ...RemoveFalseAndResolvedPromiseFromArray<Rest>] : [];
+export type FindElementByName<E extends ArcContextElementAny[], Name extends string> = E extends [
+    infer First extends ArcContextElementAny,
+    ...infer Rest extends ArcContextElementAny[]
+] ? First["name"] extends Name ? First : FindElementByName<Rest, Name> : never;
 export declare class ArcContext<const E extends ArcContextElementAny[]> {
     readonly elements: E;
     private elementsSet;
     constructor(elements: E);
-    get<Element extends E[number]>(name: Element["name"]): Element;
+    get<Name extends E[number]["name"]>(name: Name): FindElementByName<E, Name>;
     getSyncListeners(eventType: string, authContext: AuthContext): EventListener<any>[];
     getAsyncListeners(eventType: string, authContext: AuthContext): EventListener<any>[];
     pipe<const NewElements extends (ArcContextElementAny | false | Promise<{

package/dist/context/event.d.ts

@@ -31,6 +31,7 @@ export type ArcEventInstance<Event extends ArcEventAny> = {
     payload: Event["payload"] extends ArcObjectAny ? $type<Event["payload"]> : undefined;
 } & EventMetadata;
 export type ArcEventAny = ArcEvent<any, any>;
+export type ArcEventPayload<Event extends ArcEventAny> = Event extends ArcEvent<any, infer PayloadShape extends ArcObjectAny> ? $type<PayloadShape> : undefined;
 export declare function event<const Name extends string, PayloadShape extends ArcObjectAny | ArcRawShape | undefined>(name: Name, payload?: PayloadShape): ArcEvent<Name, PayloadShape extends ArcRawShape ? ArcObject<PayloadShape, [{
     name: "type";
     validator: (value: any) => false | {

package/dist/context/index.d.ts

@@ -7,4 +7,5 @@ export * from "./query-builder-context";
 export * from "./query-builders";
 export * from "./query-cache";
 export * from "./reactive-query";
+export * from "./translator";
 //# sourceMappingURL=index.d.ts.map

package/dist/context/translator.d.ts

@@ -0,0 +1,4 @@
+import type { ArcEventAny, ArcEventInstance, ArcEventPayload } from "./event";
+export type Translation<From extends ArcEventAny, To extends ArcEventAny> = (event: ArcEventInstance<From>) => ArcEventPayload<To>;
+export declare function translate<From extends ArcEventAny, To extends ArcEventAny>(from: From, to: To, translation: Translation<From, To>): import("..").ArcListener<`${From["name"]}To${To["name"]}Translator`, [To], [From]>;
+//# sourceMappingURL=translator.d.ts.map

package/dist/data-storage/store-state-master.d.ts

@@ -6,7 +6,7 @@ export declare class MasterStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
-    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>): Promise<{
+    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>, transactionCache?: Map<string, Item>): Promise<{
         from: Item | null;
         to: Item | null;
         event: ListenerEvent<Item>;

package/dist/elements/object.d.ts

@@ -2,6 +2,7 @@ import type { DatabaseAgnosticColumnInfo } from "../database/database-store";
 import { type objectUtil, type util } from "../utils";
 import { ArcAbstract, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
+import { ArcOptional } from "./optional";
 export declare type ArcRawShape = {
     [k: string]: ArcElement;
 };
@@ -64,13 +65,19 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>, V>;
     omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
     entries(): [string, ArcElement][];
+    keys(): (keyof E)[];
     toJsonSchema(): any;
     /** Generate database-agnostic column information */
     getColumnData(): DatabaseAgnosticColumnInfo;
     /** Merge this ArcObject with another shape */
     merge<OtherShape extends ArcRawShape>(otherShape: OtherShape): ArcObject<E & OtherShape, V>;
+    /** Create a partial version of this ArcObject where all fields are optional */
+    partial(): ArcObjectPartial<this>;
 }
 export type ArcObjectAny = ArcObject<any, any>;
+export type ArcObjectPartial<T extends ArcObjectAny> = T extends ArcObject<infer E, infer V> ? ArcObject<{
+    [K in keyof E]: ArcOptional<E[K]>;
+}, V> : never;
 export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E, any> ? Exclude<keyof E, symbol> : never;
 export type ArcObjectValueByKey<T extends ArcObjectAny, K extends ArcObjectKeys<T>> = T extends ArcObject<infer E, any> ? E[K] : never;
 export type ArcRawShapeType<Shape extends ArcRawShape> = {

package/dist/index.js

@@ -414,6 +414,9 @@ class ArcObject extends ArcAbstract {
   entries() {
     return Object.entries(this.rawShape);
   }
+  keys() {
+    return Object.keys(this.rawShape);
+  }
   toJsonSchema() {
     const properties = {};
     const required = [];
@@ -450,6 +453,13 @@ class ArcObject extends ArcAbstract {
     const mergedShape = { ...this.rawShape, ...otherShape };
     return new ArcObject(mergedShape);
   }
+  partial() {
+    const partialShape = Object.fromEntries(Object.entries(this.rawShape).map(([key, element]) => [
+      key,
+      element instanceof ArcOptional ? element : new ArcOptional(element)
+    ]));
+    return new ArcObject(partialShape);
+  }
 }
 function object(element) {
   return new ArcObject(element);
@@ -1611,14 +1621,16 @@ var sharedEventDatabaseSchema = null;
 function getSharedEventDatabaseSchema() {
   if (!sharedEventDatabaseSchema) {
     sharedEventDatabaseSchema = {
-      tables: [{
-        name: "events",
-        schema: eventSchema,
-        options: {
-          softDelete: false,
-          versioning: true
+      tables: [
+        {
+          name: "events",
+          schema: eventSchema,
+          options: {
+            softDelete: false,
+            versioning: true
+          }
         }
-      }]
+      ]
     };
   }
   return sharedEventDatabaseSchema;
@@ -1885,6 +1897,104 @@ class ReactiveQueryBuilder {
 function reactive(fn) {
   return (context2) => new ReactiveQueryBuilder(context2, fn);
 }
+// listener/listener.ts
+class ArcListener extends ArcContextElement {
+  name;
+  _description;
+  _elements;
+  _eventElements;
+  _handler;
+  _isAsync = false;
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  use(elements) {
+    const clone = this.clone();
+    clone._elements = elements;
+    return clone;
+  }
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
+  }
+  listenTo(events) {
+    const clone = this.clone();
+    clone._eventElements = events;
+    return clone;
+  }
+  async() {
+    const clone = this.clone();
+    clone._isAsync = true;
+    return clone;
+  }
+  handle(handler) {
+    const clone = this.clone();
+    clone._handler = handler;
+    return clone;
+  }
+  observer = (authContext) => {
+    if (!this._handler || !this._elements || !this._eventElements) {
+      return {};
+    }
+    const eventTypes = this._eventElements.filter((element2) => element2 instanceof ArcEvent).map((event2) => event2.name);
+    return eventTypes.reduce((acc, eventType) => {
+      acc[eventType] = {
+        handler: async (event2, dataStorage, publishEvent) => {
+          const ctx = new Proxy({}, {
+            get: (target, name) => {
+              if (name === "$auth") {
+                return authContext;
+              }
+              if (name === "get") {
+                return (e) => {
+                  const element3 = this._elements.find((element4) => element4.name === e.name);
+                  if (!element3) {
+                    throw new Error(`Element "${String(e.name)}" not found in listener "${this.name}"`);
+                  }
+                  if (!element3.commandContext) {
+                    throw new Error(`Element "${String(e.name)}" does not have a command context`);
+                  }
+                  return element3.commandContext(dataStorage, publishEvent, authContext);
+                };
+              }
+              const element2 = this._elements.find((element3) => element3.name === name);
+              if (!element2) {
+                throw new Error(`Element "${element2}" not found in listener "${this.name}"`);
+              }
+              if (!element2.commandContext) {
+                throw new Error(`Element "${String(name)}" does not have a command context`);
+              }
+              return element2.commandContext(dataStorage, publishEvent, authContext);
+            }
+          });
+          await this._handler(ctx, event2);
+        },
+        isAsync: this._isAsync
+      };
+      return acc;
+    }, {});
+  };
+  clone() {
+    const clone = new ArcListener(this.name);
+    clone._description = this._description;
+    clone._elements = this._elements;
+    clone._eventElements = this._eventElements;
+    clone._handler = this._handler;
+    clone._isAsync = this._isAsync;
+    return clone;
+  }
+}
+function listener(name) {
+  return new ArcListener(name);
+}
+// context/translator.ts
+function translate(from, to, translation) {
+  return listener(`${from.name}To${to.name}Translator`).listenTo([from]).use([to]).handle((ctx, event2) => {
+    ctx.get(from).emit(translation(event2));
+  });
+}
 // data-storage/data-storage.abstract.ts
 class DataStorage {
   async commitChanges(changes) {
@@ -1970,12 +2080,12 @@ class StoreState {
   applySerializedChanges(changes) {
     return Promise.all(changes.map((change) => this.applyChange(change)));
   }
-  unsubscribe(listener) {
-    this.listeners.delete(listener);
+  unsubscribe(listener3) {
+    this.listeners.delete(listener3);
   }
   notifyListeners(events) {
-    for (const listener of this.listeners.values()) {
-      listener.callback(events);
+    for (const listener3 of this.listeners.values()) {
+      listener3.callback(events);
     }
   }
 }
@@ -2069,9 +2179,9 @@ class ForkedStoreState extends StoreState {
       this.notifyListeners(events);
     }
   }
-  async find(options, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
+  async find(options, listener3) {
+    if (listener3) {
+      this.listeners.set(listener3, { callback: listener3 });
     }
     const parentResults = await this.master.find(options);
     const results = new Map;
@@ -2131,10 +2241,13 @@ class MasterStoreState extends StoreState {
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
-  async applyChangeAndReturnEvent(transaction, change) {
+  async applyChangeAndReturnEvent(transaction, change, transactionCache) {
     if (change.type === "set") {
       await transaction.set(this.storeName, change.data);
       const item = this.deserialize ? this.deserialize(change.data) : change.data;
+      if (transactionCache) {
+        transactionCache.set(change.data._id, item);
+      }
       return {
         from: null,
         to: item,
@@ -2158,10 +2271,18 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "modify") {
-      const existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      let existing;
+      if (transactionCache && transactionCache.has(change.id)) {
+        existing = transactionCache.get(change.id);
+      } else {
+        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      }
       const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
+      if (transactionCache) {
+        transactionCache.set(change.id, item);
+      }
       return {
         from: null,
         to: item,
@@ -2173,10 +2294,18 @@ class MasterStoreState extends StoreState {
       };
     }
     if (change.type === "mutate") {
-      const existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      let existing;
+      if (transactionCache && transactionCache.has(change.id)) {
+        existing = transactionCache.get(change.id);
+      } else {
+        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
+      }
       const updated = apply2(existing || {}, change.patches);
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
+      if (transactionCache) {
+        transactionCache.set(change.id, item);
+      }
       return {
         from: null,
         to: item,
@@ -2191,16 +2320,18 @@ class MasterStoreState extends StoreState {
   }
   async applyChange(change) {
     const transaction = await this.dataStorage.getReadWriteTransaction();
-    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
+    const transactionCache = new Map;
+    const { event: event3, from, to } = await this.applyChangeAndReturnEvent(transaction, change, transactionCache);
     await transaction.commit();
     this.notifyListeners([event3]);
     return { from, to };
   }
   async applyChanges(changes) {
     const transaction = await this.dataStorage.getReadWriteTransaction();
+    const transactionCache = new Map;
     const events = [];
     for (const change of changes) {
-      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change);
+      const { event: event3 } = await this.applyChangeAndReturnEvent(transaction, change, transactionCache);
       if (event3)
         events.push(event3);
     }
@@ -2209,9 +2340,9 @@ class MasterStoreState extends StoreState {
       this.notifyListeners(events);
     }
   }
-  async find(options, listener) {
-    if (listener) {
-      this.listeners.set(listener, { callback: listener });
+  async find(options, listener3) {
+    if (listener3) {
+      this.listeners.set(listener3, { callback: listener3 });
     }
     const transaction = await this.dataStorage.getReadTransaction();
     const results = await transaction.find(this.storeName, options);
@@ -2439,7 +2570,7 @@ class PostgreSQLReadTransaction {
     }
     let query2 = `
       SELECT * 
-      FROM "${store}" 
+      FROM "${table.name}" 
       WHERE ${whereClause.sql}
       ${orderByClause}
     `;
@@ -2471,7 +2602,7 @@ class PostgreSQLReadWriteTransaction extends PostgreSQLReadTransaction {
     if (!table) {
       throw new Error(`Store ${store} not found`);
     }
-    const query2 = `UPDATE "${store}" SET "deleted" = $1, "lastUpdate" = $2 WHERE "${table.primaryKey}" = $3`;
+    const query2 = `UPDATE "${table.name}" SET "deleted" = $1, "lastUpdate" = $2 WHERE "${table.primaryKey}" = $3`;
     this.queries.push({
       sql: query2,
       params: [true, new Date().toISOString(), id3]
@@ -3002,7 +3133,7 @@ class SQLiteReadTransaction {
     }
     const query2 = `
       SELECT * 
-      FROM ${store} 
+      FROM ${table.name} 
       WHERE ${whereClause.sql}
       ${orderByClause}
       ${limit ? `LIMIT ${limit}` : ""}
@@ -3024,7 +3155,7 @@ class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
     if (!table) {
       throw new Error(`Store ${store} not found`);
     }
-    const query2 = `UPDATE ${store} SET deleted = 1, lastUpdate = ? WHERE ${table.primaryKey} = ?`;
+    const query2 = `UPDATE ${table.name} SET deleted = 1, lastUpdate = ? WHERE ${table.primaryKey} = ?`;
     await this.db.exec(query2, [new Date().toISOString(), id3]);
   }
   async set(store, item) {
@@ -3364,99 +3495,7 @@ var createSQLiteAdapterFactory = (db) => {
     return adapter;
   };
 };
-// listener/listener.ts
-class ArcListener extends ArcContextElement {
-  name;
-  _description;
-  _elements;
-  _eventElements;
-  _handler;
-  _isAsync = false;
-  constructor(name) {
-    super();
-    this.name = name;
-  }
-  use(elements) {
-    const clone = this.clone();
-    clone._elements = elements;
-    return clone;
-  }
-  description(description) {
-    const clone = this.clone();
-    clone._description = description;
-    return clone;
-  }
-  listenTo(events) {
-    const clone = this.clone();
-    clone._eventElements = events;
-    return clone;
-  }
-  async() {
-    const clone = this.clone();
-    clone._isAsync = true;
-    return clone;
-  }
-  handle(handler) {
-    const clone = this.clone();
-    clone._handler = handler;
-    return clone;
-  }
-  observer = (authContext) => {
-    if (!this._handler || !this._elements || !this._eventElements) {
-      return {};
-    }
-    const eventTypes = this._eventElements.filter((element3) => element3 instanceof ArcEvent).map((event3) => event3.name);
-    return eventTypes.reduce((acc, eventType) => {
-      acc[eventType] = {
-        handler: async (event3, dataStorage, publishEvent) => {
-          const ctx = new Proxy({}, {
-            get: (target, name) => {
-              if (name === "$auth") {
-                return authContext;
-              }
-              if (name === "get") {
-                return (e) => {
-                  const element4 = this._elements.find((element5) => element5.name === e.name);
-                  if (!element4) {
-                    throw new Error(`Element "${String(e.name)}" not found in listener "${this.name}"`);
-                  }
-                  if (!element4.commandContext) {
-                    throw new Error(`Element "${String(e.name)}" does not have a command context`);
-                  }
-                  return element4.commandContext(dataStorage, publishEvent, authContext);
-                };
-              }
-              const element3 = this._elements.find((element4) => element4.name === name);
-              if (!element3) {
-                throw new Error(`Element "${element3}" not found in listener "${this.name}"`);
-              }
-              if (!element3.commandContext) {
-                throw new Error(`Element "${String(name)}" does not have a command context`);
-              }
-              return element3.commandContext(dataStorage, publishEvent, authContext);
-            }
-          });
-          await this._handler(ctx, event3);
-        },
-        isAsync: this._isAsync
-      };
-      return acc;
-    }, {});
-  };
-  clone() {
-    const clone = new ArcListener(this.name);
-    clone._description = this._description;
-    clone._elements = this._elements;
-    clone._eventElements = this._eventElements;
-    clone._handler = this._handler;
-    clone._isAsync = this._isAsync;
-    return clone;
-  }
-}
-function listener(name) {
-  return new ArcListener(name);
-}
-// model/model.ts
+// model/event-publisher.ts
 class EventPublisher {
   context;
   dataStorage;
@@ -3509,6 +3548,7 @@ class EventPublisher {
   }
 }
 
+// model/model.ts
 class ModelBase {
   token = null;
   setAuthToken(token) {
@@ -3528,12 +3568,18 @@ class Model extends ModelBase {
     this.catchErrorCallback = catchErrorCallback;
   }
   async query(queryBuilderFn, authContext) {
+    if (!this.dataStorage) {
+      throw new Error("DataStorage is required for query operations");
+    }
     const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
     const queryBuilder = this.context.queryBuilder(queryContext, authContext);
     const query2 = queryBuilderFn(queryBuilder).toQuery(queryContext);
     return query2.run(this.dataStorage);
   }
   subscribe(queryBuilderFn, callback, authContext) {
+    if (!this.dataStorage) {
+      throw new Error("DataStorage is required for subscribe operations");
+    }
     const queryContext = new QueryBuilderContext(this.queryCache, this.dataStorage);
     const queryBuilder = this.context.queryBuilder(queryContext, authContext);
     const query2 = queryBuilderFn(queryBuilder).toQuery(queryContext);
@@ -3560,6 +3606,9 @@ class Model extends ModelBase {
           throw new Error(`Element "${String(name)}" does not have a command client`);
         }
         return async (arg) => {
+          if (!this.dataStorage) {
+            throw new Error("DataStorage is required for command operations");
+          }
           const forkedDataStorage = this.dataStorage.fork();
           const eventPublisher = new EventPublisher(this.context, this.dataStorage, authContext);
           const publishEvent = async (event3) => {
@@ -3572,7 +3621,9 @@ class Model extends ModelBase {
             eventPublisher.runAsyncListeners();
             return result;
           } catch (error) {
-            this.catchErrorCallback(error);
+            if (this.catchErrorCallback) {
+              this.catchErrorCallback(error);
+            }
             return error;
           }
         };
@@ -3594,6 +3645,9 @@ class Model extends ModelBase {
           if (!handler) {
             throw new Error(`Method ${method} not allowed for route ${String(name)}`);
           }
+          if (!this.dataStorage) {
+            throw new Error("DataStorage is required for route operations");
+          }
           const forkedDataStorage = this.dataStorage.fork();
           const eventPublisher = new EventPublisher(this.context, this.dataStorage, authContext);
           const publishEvent = async (event3) => {
@@ -3606,7 +3660,9 @@ class Model extends ModelBase {
             eventPublisher.runAsyncListeners();
             return result;
           } catch (error) {
-            this.catchErrorCallback(error);
+            if (this.catchErrorCallback) {
+              this.catchErrorCallback(error);
+            }
             throw error;
           }
         };
@@ -3623,6 +3679,8 @@ class RemoteModelClient extends ModelBase {
   apiBaseUrl;
   client;
   catchErrorCallback;
+  queryCache = new QueryCache;
+  inFlightRequests = new Map;
   constructor(context3, apiBaseUrl, client, catchErrorCallback) {
     super();
     this.context = context3;
@@ -3630,6 +3688,26 @@ class RemoteModelClient extends ModelBase {
     this.client = client;
     this.catchErrorCallback = catchErrorCallback;
   }
+  generateCacheKey(element3, queryType, params) {
+    return `${element3}:${queryType}:${JSON.stringify(params)}`;
+  }
+  async executeQuery(queryTracking) {
+    const response = await fetch(`${this.apiBaseUrl}/query`, {
+      method: "POST",
+      headers: this.getAuthHeaders(),
+      body: JSON.stringify({
+        query: {
+          element: queryTracking.element,
+          queryType: queryTracking.queryType,
+          params: queryTracking.params
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Query failed: ${response.statusText}`);
+    }
+    return await response.json();
+  }
   schemaContainsBlobOrFile(schema) {
     if (!schema)
       return false;
@@ -3747,21 +3825,23 @@ class RemoteModelClient extends ModelBase {
       }
     });
     queryBuilderFn(queryBuilderProxy);
-    const response = await fetch(`${this.apiBaseUrl}/query`, {
-      method: "POST",
-      headers: this.getAuthHeaders(),
-      body: JSON.stringify({
-        query: {
-          element: queryTracking.element,
-          queryType: queryTracking.queryType,
-          params: queryTracking.params
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Query failed: ${response.statusText}`);
+    const cacheKey = this.generateCacheKey(queryTracking.element, queryTracking.queryType, queryTracking.params);
+    const cachedResult = this.queryCache.get([cacheKey]);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    if (this.inFlightRequests.has(cacheKey)) {
+      return this.inFlightRequests.get(cacheKey);
+    }
+    const requestPromise = this.executeQuery(queryTracking);
+    this.inFlightRequests.set(cacheKey, requestPromise);
+    try {
+      const result = await requestPromise;
+      this.queryCache.set([cacheKey], result);
+      return result;
+    } finally {
+      this.inFlightRequests.delete(cacheKey);
     }
-    return await response.json();
   }
   subscribe(queryBuilderFn, callback, authContext) {
     const result = this.query(queryBuilderFn, authContext);
@@ -4534,6 +4614,7 @@ function view(name, id3, schema) {
 }
 export {
   view,
+  translate,
   stringEnum,
   string,
   staticView,

package/dist/model/EventPublisher.d.ts

@@ -0,0 +1,12 @@
+import type { ArcContextAny, AuthContext } from "../context";
+import type { DataStorage } from "../data-storage";
+export declare class EventPublisher<C extends ArcContextAny> {
+    private readonly context;
+    private readonly dataStorage;
+    private readonly authContext;
+    private asyncEvents;
+    constructor(context: C, dataStorage: DataStorage, authContext: AuthContext);
+    publishEvent(event: any, commandDataStorage: DataStorage): Promise<void>;
+    runAsyncListeners(): Promise<void>;
+}
+//# sourceMappingURL=EventPublisher.d.ts.map

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

@@ -0,0 +1,12 @@
+import type { ArcContextAny, AuthContext } from "../context";
+import type { DataStorage } from "../data-storage";
+export declare class EventPublisher<C extends ArcContextAny> {
+    private readonly context;
+    private readonly dataStorage;
+    private readonly authContext;
+    private asyncEvents;
+    constructor(context: C, dataStorage: DataStorage, authContext: AuthContext);
+    publishEvent(event: any, commandDataStorage: DataStorage): Promise<void>;
+    runAsyncListeners(): Promise<void>;
+}
+//# sourceMappingURL=event-publisher.d.ts.map

package/dist/model/model.d.ts

@@ -19,10 +19,10 @@ export declare abstract class ModelBase<C extends ArcContextAny> {
 }
 export declare class Model<C extends ArcContextAny> extends ModelBase<C> {
     private readonly context;
-    private readonly dataStorage;
-    private readonly catchErrorCallback;
+    private readonly dataStorage?;
+    private readonly catchErrorCallback?;
     private queryCache;
-    constructor(context: C, dataStorage: DataStorage, catchErrorCallback: (error: any) => void);
+    constructor(context: C, dataStorage?: DataStorage | undefined, catchErrorCallback?: ((error: any) => void) | undefined);
     query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, authContext: AuthContext): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
     subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void, authContext: AuthContext): {
         result: ReturnType<Q["toQuery"]>["lastResult"];
@@ -37,7 +37,17 @@ export declare class RemoteModelClient<C extends ArcContextAny> extends ModelBas
     private readonly apiBaseUrl;
     private readonly client;
     private readonly catchErrorCallback;
+    private queryCache;
+    private inFlightRequests;
     constructor(context: C, apiBaseUrl: string, client: string, catchErrorCallback: (error: any) => void);
+    /**
+     * Generate a cache key from query details
+     */
+    private generateCacheKey;
+    /**
+     * Execute the actual HTTP query request
+     */
+    private executeQuery;
     /**
      * Check if a schema contains blob or file elements
      */

package/dist/query/query-definition.d.ts

@@ -0,0 +1,8 @@
+export type QueryDefinition<TResult = any> = {
+    readonly contextElementName: string;
+    readonly queryAlias: string;
+    readonly parameters: any[];
+    readonly restrictions?: any;
+};
+export type QueryDefinitionResult<QD extends QueryDefinition> = QD extends QueryDefinition<infer T> ? T : unknown;
+//# sourceMappingURL=query-definition.d.ts.map

package/dist/server/query-handler.d.ts

@@ -0,0 +1,43 @@
+import type { ArcContextAny } from "../context";
+import type { AuthContext } from "../context/element";
+import type { DataStorage } from "../data-storage";
+import { QueryDefinition } from "../strategies";
+export declare class QueryHandler<C extends ArcContextAny> {
+    private model;
+    constructor(context: C, dataStorage: DataStorage, catchErrorCallback?: (error: any) => void);
+    /**
+     * Handle HTTP query requests
+     */
+    handleQuery(queryDefinition: QueryDefinition, authContext: AuthContext): Promise<any>;
+    /**
+     * Handle HTTP query requests with streaming for real-time updates
+     */
+    handleQueryWithStream(queryDefinition: QueryDefinition, authContext: AuthContext, streamCallback: (result: any) => void): Promise<any>;
+    /**
+     * Handle query sync requests for cache strategy
+     */
+    handleQuerySync(queryDefinition: QueryDefinition, authContext: AuthContext, syncData: {
+        id: string;
+        version?: string;
+    }[]): Promise<{
+        updates: any[];
+    }>;
+}
+/**
+ * Helper function to create HTTP handlers for different frameworks
+ */
+export declare function createHttpQueryHandlers<C extends ArcContextAny>(context: C, dataStorage: DataStorage, catchErrorCallback?: (error: any) => void): {
+    /**
+     * Handle POST /query
+     */
+    handleQueryRequest: (req: Request) => Promise<Response>;
+    /**
+     * Handle POST /query-stream/:streamId
+     */
+    handleQueryStreamRequest: (req: Request, streamId: string) => Promise<Response>;
+    /**
+     * Handle POST /query-sync
+     */
+    handleQuerySyncRequest: (req: Request) => Promise<Response>;
+};
+//# sourceMappingURL=query-handler.d.ts.map

package/dist/strategies/cache-strategy.d.ts

@@ -0,0 +1,20 @@
+import type { ArcContextAny } from "../context";
+import type { AuthContext } from "../context/element";
+import type { DataStorage } from "../data-storage";
+import type { QueryDefinition } from "../query/query-definition";
+import type { CommandDefinition } from "../command/command-definition";
+import type { ModelStrategy } from "./model-strategy";
+export declare class CacheStrategy<C extends ArcContextAny> implements ModelStrategy {
+    private readonly dataStorage;
+    private dataStorageStrategy;
+    private leaderStrategy;
+    constructor(context: C, dataStorage: DataStorage, apiBaseUrl: string);
+    setAuthToken(token: string | null): void;
+    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
+    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
+    private extractSyncData;
+    private syncWithLeader;
+    private updateCache;
+    private establishLiveUpdates;
+}
+//# sourceMappingURL=cache-strategy.d.ts.map

package/dist/strategies/datastorage-strategy.d.ts

@@ -0,0 +1,15 @@
+import type { ArcContextAny } from "../context";
+import type { AuthContext } from "../context/element";
+import type { DataStorage } from "../data-storage";
+import type { QueryDefinition } from "../query/query-definition";
+import type { CommandDefinition } from "../command/command-definition";
+import type { ModelStrategy } from "./model-strategy";
+export declare class DataStorageStrategy<C extends ArcContextAny> implements ModelStrategy {
+    private readonly context;
+    readonly dataStorage: DataStorage;
+    private readonly catchErrorCallback?;
+    constructor(context: C, dataStorage: DataStorage, catchErrorCallback?: ((error: any) => void) | undefined);
+    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
+    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
+}
+//# sourceMappingURL=datastorage-strategy.d.ts.map

package/dist/strategies/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./model-strategy";
+export * from "./datastorage-strategy";
+export * from "./leader-strategy";
+export * from "./cache-strategy";
+export type { QueryDefinition } from "../query/query-definition";
+export type { CommandDefinition } from "../command/command-definition";
+//# sourceMappingURL=index.d.ts.map

package/dist/strategies/leader-strategy.d.ts

@@ -0,0 +1,16 @@
+import type { AuthContext } from "../context/element";
+import type { QueryDefinition } from "../query/query-definition";
+import type { CommandDefinition } from "../command/command-definition";
+import type { ModelStrategy } from "./model-strategy";
+export declare class LeaderStrategy implements ModelStrategy {
+    private readonly apiBaseUrl;
+    private token;
+    constructor(apiBaseUrl: string);
+    setAuthToken(token: string | null): void;
+    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
+    private queryWithStream;
+    private readStream;
+    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
+    private getAuthHeaders;
+}
+//# sourceMappingURL=leader-strategy.d.ts.map

package/dist/strategies/model-strategy.d.ts

@@ -0,0 +1,9 @@
+import type { AuthContext } from "../context/element";
+import type { QueryDefinition } from "../query/query-definition";
+import type { CommandDefinition } from "../command/command-definition";
+export interface ModelStrategy {
+    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
+    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
+    setAuthToken?(token: string | null): void;
+}
+//# sourceMappingURL=model-strategy.d.ts.map

package/dist/strategies/query-strategy.d.ts

@@ -0,0 +1,20 @@
+import type { AuthContext } from "../context/element";
+export interface QueryDefinition {
+    contextElementName: string;
+    queryAlias: string;
+    parameters: any[];
+    restrictions?: any;
+}
+export interface CommandDefinition {
+    contextElementName: string;
+    parameters: any;
+}
+export interface ModelStrategy {
+    query(queryDefinition: QueryDefinition, authContext: AuthContext, callback?: (result: any) => void): Promise<any>;
+    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
+    setAuthToken?(token: string | null): void;
+}
+export interface QueryStrategy extends ModelStrategy {
+    execute(queryDefinition: QueryDefinition, authContext: AuthContext, callback?: (result: any) => void): Promise<any>;
+}
+//# sourceMappingURL=query-strategy.d.ts.map

package/dist/view/query-builders/new-query-builder.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=new-query-builder.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",