@arcote.tech/arc 0.1.11 → 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/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/index.js

@@ -1621,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;
@@ -1895,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) {
@@ -1980,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);
     }
   }
 }
@@ -2079,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;
@@ -2240,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);
@@ -2470,7 +2570,7 @@ class PostgreSQLReadTransaction {
     }
     let query2 = `
       SELECT * 
-      FROM "${store}" 
+      FROM "${table.name}" 
       WHERE ${whereClause.sql}
       ${orderByClause}
     `;
@@ -2502,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]
@@ -3033,7 +3133,7 @@ class SQLiteReadTransaction {
     }
     const query2 = `
       SELECT * 
-      FROM ${store} 
+      FROM ${table.name} 
       WHERE ${whereClause.sql}
       ${orderByClause}
       ${limit ? `LIMIT ${limit}` : ""}
@@ -3055,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) {
@@ -3395,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;
@@ -3540,6 +3548,7 @@ class EventPublisher {
   }
 }
 
+// model/model.ts
 class ModelBase {
   token = null;
   setAuthToken(token) {
@@ -3559,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);
@@ -3591,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) => {
@@ -3603,7 +3621,9 @@ class Model extends ModelBase {
             eventPublisher.runAsyncListeners();
             return result;
           } catch (error) {
-            this.catchErrorCallback(error);
+            if (this.catchErrorCallback) {
+              this.catchErrorCallback(error);
+            }
             return error;
           }
         };
@@ -3625,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) => {
@@ -3637,7 +3660,9 @@ class Model extends ModelBase {
             eventPublisher.runAsyncListeners();
             return result;
           } catch (error) {
-            this.catchErrorCallback(error);
+            if (this.catchErrorCallback) {
+              this.catchErrorCallback(error);
+            }
             throw error;
           }
         };
@@ -3654,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;
@@ -3661,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;
@@ -3778,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);
@@ -4565,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.11",
+  "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.",