@arcote.tech/arc 0.0.22 → 0.0.24

package/dist/collection/collection.d.ts

@@ -3,6 +3,7 @@ import type { ArcIdAny } from "../elements/id";
 import { type ArcObjectAny } from "../elements/object";
 import { objectUtil, type DeepPartial, type util } from "../utils";
 import type { DataStorage } from "../data-storage";
+import type { IndexQueryArgument } from "../db";
 import { ArcAllItemsQueryBuilder } from "./query-builders/all-items";
 import { ArcIndexedItemsQueryBuilder } from "./query-builders/indexed";
 import { ArcOneItemQueryBuilder } from "./query-builders/one-item";
@@ -27,6 +28,11 @@ type CollectionCommandContext<Id extends ArcIdAny, Schema extends ArcObjectAny>
     edit: (id: util.GetType<Id>, editCallback: (item: Deserialize<Id, Schema>) => Promise<void> | void) => Promise<void>;
     modify: (id: util.GetType<Id>, data: objectUtil.addQuestionMarks<DeepPartial<util.FirstArgument<Schema["serialize"]>>>) => Promise<any>;
 };
+type IndexValue<Schema extends ArcObjectAny, Indexes extends keyof ReturnType<Schema["deserialize"]>, I extends {
+    [name: string]: Indexes[];
+}, func extends keyof I> = {
+    [Key in I[func][number]]: util.GetType<Schema>[Key];
+};
 export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> extends ArcContextElement<{
     type: "delete";
     from: CollectionItem<ArcCollection<Name, Id, Schema>>;
@@ -68,14 +74,10 @@ export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdA
     readonly indexes: I;
     constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>, indexes: I);
     commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): CollectionCommandContext<Id, Schema> & {
-        [func in keyof I]: (args: {
-            [Key in I[func][number]]: util.GetType<Schema>[Key];
-        }) => Deserialize<Id, Schema>[];
+        [func in keyof I]: (args: IndexValue<Schema, Indexes, I, func>) => Deserialize<Id, Schema>[];
     };
     queryBuilder(): CollectionQueryBuilder<ArcCollection<Name, Id, Schema>> & {
-        [func in keyof I]: (args: {
-            [Key in I[func][number]]: util.GetType<Schema>[Key];
-        }) => ArcIndexedItemsQueryBuilder<ArcIndexedCollection<Name, Id, Schema, Indexes, I>>;
+        [func in keyof I]: (args: objectUtil.simplify<IndexQueryArgument<objectUtil.simplify<IndexValue<Schema, Indexes, I, func>>>>) => ArcIndexedItemsQueryBuilder<ArcIndexedCollection<Name, Id, Schema, Indexes, I>>;
     };
 }
 export type ArcCollectionAny = ArcCollection<any, any, any>;

package/dist/collection/utils/index-query.d.ts

@@ -0,0 +1,6 @@
+import { IndexQueryArgument } from "./interface";
+export declare function indexQueryPredicate<T>(
+  item: T,
+  query: IndexQueryArgument<any>,
+): boolean;
+//# sourceMappingURL=index-query.d.ts.map

package/dist/db/index-query.d.ts

@@ -0,0 +1,3 @@
+import { type IndexQueryArgument } from "./interface";
+export declare function indexQueryPredicate<T>(item: T, query: IndexQueryArgument<any>): boolean;
+//# sourceMappingURL=index-query.d.ts.map

package/dist/db/interface.d.ts

@@ -1,7 +1,21 @@
 import type { ArcContextAny } from "../context";
+export type IndexQueryArgument<T> = T | ({
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+} & ({
+    $gt: T;
+} | {
+    $gte: T;
+} | {
+    $lt: T;
+} | {
+    $lte: T;
+}));
 export interface ReadTransaction {
     findById(store: string, id: any): Promise<any | undefined>;
-    findByIndex(store: string, index: string, data: any): Promise<any[]>;
+    findByIndex(store: string, index: string, data: IndexQueryArgument<any>): Promise<any[]>;
     findAll(store: string): Promise<any[]>;
 }
 export interface ReadWriteTransaction extends ReadTransaction {

package/dist/index.js

@@ -161,6 +161,34 @@ class ArcAllItemsQueryBuilder extends ArcManyItemsQueryBuilder {
   }
 }
 
+// db/index-query.ts
+function indexQueryPredicate(item, query) {
+  if (!("$gt" in query) && !("$gte" in query) && !("$lt" in query) && !("$lte" in query)) {
+    return Object.entries(query).every(([key, value]) => item[key] === value);
+  }
+  if (query.$gt) {
+    const isGreaterThan = Object.entries(query.$gt).every(([key, value]) => item[key] > value);
+    if (!isGreaterThan)
+      return false;
+  }
+  if (query.$gte) {
+    const isGreaterThanOrEqual = Object.entries(query.$gte).every(([key, value]) => item[key] >= value);
+    if (!isGreaterThanOrEqual)
+      return false;
+  }
+  if (query.$lt) {
+    const isLessThan = Object.entries(query.$lt).every(([key, value]) => item[key] < value);
+    if (!isLessThan)
+      return false;
+  }
+  if (query.$lte) {
+    const isLessThanOrEqual = Object.entries(query.$lte).every(([key, value]) => item[key] <= value);
+    if (!isLessThanOrEqual)
+      return false;
+  }
+  return true;
+}
+
 // collection/queries/indexed.ts
 class ArcIndexedItemsQuery extends ArcManyItemsQuery {
   index;
@@ -177,10 +205,7 @@ class ArcIndexedItemsQuery extends ArcManyItemsQuery {
   checkItem(item) {
     if (!super.checkItem(item))
       return false;
-    const correct = Object.entries(this.data).every(([key, value]) => item[key] === value);
-    if (!correct)
-      return false;
-    return true;
+    return indexQueryPredicate(item, this.data);
   }
   async fetch(store) {
     const results = await store.findByIndex(this.index, this.data, this.bindedChangeHandler);
@@ -243,10 +268,6 @@ class ArcOneItemQueryBuilder extends ArcQueryBuilder {
 }
 
 // collection/collection.ts
-function collection(name, id, schema, options = {}) {
-  return new ArcCollection(name, id, schema, options);
-}
-
 class ArcCollection extends ArcContextElement {
   name;
   id;
@@ -376,11 +397,10 @@ class ArcIndexedCollection extends ArcCollection {
     });
   }
 }
-// context/context.ts
-function context(version, elements, commands, listeners) {
-  return new ArcContext(version, elements, commands, listeners);
+function collection(name, id, schema, options = {}) {
+  return new ArcCollection(name, id, schema, options);
 }
-
+// context/context.ts
 class ArcContext {
   version;
   elements;
@@ -447,6 +467,9 @@ class ArcContext {
     });
   }
 }
+function context(version, elements, commands, listeners) {
+  return new ArcContext(version, elements, commands, listeners);
+}
 // data-storage/data-storage.abstract.ts
 class DataStorage {
   async commitChanges(changes) {
@@ -786,6 +809,8 @@ class MasterStoreState extends StoreState {
     }
   }
   async findById(id, listener) {
+    if (!id)
+      return;
     if (listener)
       this.listeners.set(listener, { callback: listener, id });
     if (this.items.has(id))
@@ -805,8 +830,7 @@ class MasterStoreState extends StoreState {
       const results2 = Array.from(this.items.values()).filter((item) => {
         if (!item)
           return false;
-        const notCorrect = Object.entries(data).some(([key, value]) => item[key] !== value);
-        return !notCorrect;
+        return indexQueryPredicate(item, data);
       });
       return results2;
     }
@@ -972,10 +996,6 @@ class ArcAbstract {
 }
 
 // elements/object.ts
-function object(element) {
-  return new ArcObject(element);
-}
-
 class ArcObject extends ArcAbstract {
   rawShape;
   constructor(rawShape) {
@@ -1038,12 +1058,11 @@ class ArcObject extends ArcAbstract {
     }, {});
   }
 }
-
-// elements/array.ts
-function array(element) {
-  return new ArcArray(element);
+function object(element) {
+  return new ArcObject(element);
 }
 
+// elements/array.ts
 class ArcArray extends ArcAbstract {
   parent;
   constructor(parent) {
@@ -1069,6 +1088,9 @@ class ArcArray extends ArcAbstract {
     return this.parent.deserialize(value);
   }
 }
+function array(element) {
+  return new ArcArray(element);
+}
 // elements/abstract-primitive.ts
 class ArcPrimitive extends ArcAbstract {
   constructor() {
@@ -1086,17 +1108,12 @@ class ArcPrimitive extends ArcAbstract {
 }
 
 // elements/boolean.ts
+class ArcBoolean extends ArcPrimitive {
+}
 function boolean() {
   return new ArcBoolean;
 }
-
-class ArcBoolean extends ArcPrimitive {
-}
 // elements/date.ts
-function date() {
-  return new ArcDate;
-}
-
 class ArcDate extends ArcAbstract {
   constructor() {
     super();
@@ -1111,19 +1128,17 @@ class ArcDate extends ArcAbstract {
     return new Date(value);
   }
 }
+function date() {
+  return new ArcDate;
+}
 // elements/string.ts
+class ArcString extends ArcPrimitive {
+}
 function string() {
   return new ArcString;
 }
 
-class ArcString extends ArcPrimitive {
-}
-
 // elements/id.ts
-function id(name) {
-  return new ArcId(name);
-}
-
 class ArcId extends ArcBranded {
   constructor(name) {
     super(string(), name);
@@ -1135,18 +1150,16 @@ class ArcId extends ArcBranded {
     }).toLowerCase();
   }
 }
+function id(name) {
+  return new ArcId(name);
+}
 // elements/number.ts
+class ArcNumber extends ArcPrimitive {
+}
 function number() {
   return new ArcNumber;
 }
-
-class ArcNumber extends ArcPrimitive {
-}
 // elements/record.ts
-function record(key, element) {
-  return new ArcRecord(key, element);
-}
-
 class ArcRecord extends ArcAbstract {
   key;
   element;
@@ -1180,11 +1193,10 @@ class ArcRecord extends ArcAbstract {
     }, {});
   }
 }
-// elements/string-enum.ts
-function stringEnum(...values) {
-  return new ArcStringEnum(values);
+function record(key, element) {
+  return new ArcRecord(key, element);
 }
-
+// elements/string-enum.ts
 class ArcStringEnum extends ArcAbstract {
   values;
   constructor(values) {
@@ -1204,6 +1216,9 @@ class ArcStringEnum extends ArcAbstract {
     return this.values;
   }
 }
+function stringEnum(...values) {
+  return new ArcStringEnum(values);
+}
 // rtc/client.ts
 class RTCClient {
   storage;
@@ -1364,10 +1379,6 @@ class ArcStateQueryBuilder extends ArcQueryBuilder {
 }
 
 // state/state.ts
-function state(name, schema) {
-  return new ArcState(name, schema);
-}
-
 class ArcState extends ArcContextElement {
   name;
   schema;
@@ -1410,6 +1421,9 @@ class ArcState extends ArcContextElement {
     };
   }
 }
+function state(name, schema) {
+  return new ArcState(name, schema);
+}
 export {
   stringEnum,
   string,

package/dist/tests/query-notification-optimization.test.d.ts

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

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "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.",