@arcote.tech/arc 0.0.23 → 0.0.25

package/dist/collection/collection.d.ts

@@ -1,5 +1,5 @@
 import { ArcContextElement } from "../context/element";
-import type { ArcIdAny } from "../elements/id";
+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";

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/elements/id.d.ts

@@ -1,10 +1,16 @@
 import type { util } from "../utils";
 import { ArcBranded } from "./branded";
 import { ArcString } from "./string";
+export declare class ArcCustomId<Brand extends string | symbol, CreateFn extends (...args: any[]) => string> extends ArcBranded<ArcString, Brand> {
+    private createFn;
+    constructor(name: Brand, createFn: CreateFn);
+    get(...args: Parameters<CreateFn>): util.GetType<this>;
+}
 export declare class ArcId<Brand extends string | symbol> extends ArcBranded<ArcString, Brand> {
     constructor(name: Brand);
     generate(): util.GetType<this>;
 }
-export type ArcIdAny = ArcId<any>;
+export type ArcIdAny = ArcId<any> | ArcCustomId<any, any>;
 export declare function id<Brand extends string | symbol>(name: Brand): ArcId<Brand>;
+export declare function customId<Brand extends string | symbol, CreateFn extends (...args: any[]) => string>(name: Brand, createFn: CreateFn): ArcCustomId<Brand, CreateFn>;
 //# sourceMappingURL=id.d.ts.map

package/dist/index.js

@@ -3,6 +3,146 @@ class ArcContextElement {
   $event;
 }
 
+// elements/optional.ts
+class ArcOptional {
+  parent;
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parse(value) {
+    if (!value)
+      return null;
+    return this.parent.parse(value);
+  }
+  serialize(value) {
+    if (value)
+      return this.parent.serialize(value);
+    return null;
+  }
+  deserialize(value) {
+    if (!value)
+      return null;
+    return this.parent.deserialize(value);
+  }
+}
+
+// elements/branded.ts
+class ArcBranded {
+  parent;
+  brand;
+  constructor(parent, brand) {
+    this.parent = parent;
+    this.brand = brand;
+  }
+  serialize(value) {
+    return this.parent.serialize(value);
+  }
+  deserialize(value) {
+    return this.parent.deserialize(value);
+  }
+  parse(value) {
+    return this.parent.parse(value);
+  }
+  optional() {
+    return new ArcOptional(this);
+  }
+}
+
+// elements/default.ts
+class ArcDefault {
+  parent;
+  defaultValueOrCallback;
+  constructor(parent, defaultValueOrCallback) {
+    this.parent = parent;
+    this.defaultValueOrCallback = defaultValueOrCallback;
+  }
+  parse(value) {
+    if (value)
+      return this.parent.parse(value);
+    if (typeof this.defaultValueOrCallback === "function") {
+      return this.defaultValueOrCallback();
+    } else
+      return this.defaultValueOrCallback;
+  }
+  serialize(value) {
+    return this.parent.serialize(value);
+  }
+  deserialize(value) {
+    if (value)
+      return this.parent.deserialize(value);
+    if (typeof this.defaultValueOrCallback === "function") {
+      return this.defaultValueOrCallback();
+    } else
+      return this.defaultValueOrCallback;
+  }
+}
+
+// elements/abstract.ts
+class ArcAbstract {
+  default(defaultValueOrCallback) {
+    return new ArcDefault(this, defaultValueOrCallback);
+  }
+  optional() {
+    return new ArcOptional(this);
+  }
+  branded(name) {
+    return new ArcBranded(this, name);
+  }
+}
+
+// elements/abstract-primitive.ts
+class ArcPrimitive extends ArcAbstract {
+  constructor() {
+    super();
+  }
+  serialize(value) {
+    return value;
+  }
+  parse(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+}
+
+// elements/string.ts
+class ArcString extends ArcPrimitive {
+}
+function string() {
+  return new ArcString;
+}
+
+// elements/id.ts
+class ArcCustomId extends ArcBranded {
+  createFn;
+  constructor(name, createFn) {
+    super(string(), name);
+    this.createFn = createFn;
+  }
+  get(...args) {
+    return this.createFn(...args);
+  }
+}
+
+class ArcId extends ArcBranded {
+  constructor(name) {
+    super(string(), name);
+  }
+  generate() {
+    var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+    return timestamp + "xxxxxxxxxxxxxxxx".replace(/[x]/g, function() {
+      return (Math.random() * 16 | 0).toString(16);
+    }).toLowerCase();
+  }
+}
+function id(name) {
+  return new ArcId(name);
+}
+function customId(name, createFn) {
+  return new ArcCustomId(name, createFn);
+}
+
 // context/query.ts
 class ArcQuery {
   lastResult;
@@ -54,8 +194,8 @@ class QueryCollectionResult {
   constructor(result) {
     this.result = result;
   }
-  get(id) {
-    return id ? this.result.find((r) => r._id === id) : undefined;
+  get(id2) {
+    return id2 ? this.result.find((r) => r._id === id2) : undefined;
   }
   map(callbackfn) {
     return this.result.map(callbackfn);
@@ -161,6 +301,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 +345,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);
@@ -208,10 +373,10 @@ class ArcIndexedItemsQueryBuilder extends ArcManyItemsQueryBuilder {
 
 // collection/queries/one-item.ts
 class ArcOneItemQuery extends ArcCollectionQuery {
-  id;
-  constructor(collection, id) {
+  id2;
+  constructor(collection, id2) {
     super(collection);
-    this.id = id;
+    this.id = id2;
   }
   onChange(change) {
     if (change.id !== this.id)
@@ -231,11 +396,11 @@ class ArcOneItemQuery extends ArcCollectionQuery {
 // collection/query-builders/one-item.ts
 class ArcOneItemQueryBuilder extends ArcQueryBuilder {
   collection;
-  id;
-  constructor(collection, id) {
+  id2;
+  constructor(collection, id2) {
     super();
     this.collection = collection;
-    this.id = id;
+    this.id = id2;
   }
   toQuery() {
     return new ArcOneItemQuery(this.collection, this.id);
@@ -243,19 +408,15 @@ 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;
+  id2;
   schema;
   options;
-  constructor(name, id, schema, options) {
+  constructor(name, id2, schema, options) {
     super();
     this.name = name;
-    this.id = id;
+    this.id = id2;
     this.schema = schema;
     this.options = options;
   }
@@ -274,17 +435,19 @@ class ArcCollection extends ArcContextElement {
   queryBuilder() {
     return {
       all: () => new ArcAllItemsQueryBuilder(this),
-      one: (id) => new ArcOneItemQueryBuilder(this, id)
+      one: (id2) => new ArcOneItemQueryBuilder(this, id2)
     };
   }
   commandContext(dataStorage, publishEvent) {
     const store = dataStorage.getStore(this.name);
     return {
       add: async (data) => {
-        const id = this.id.generate();
+        if (this.id instanceof ArcCustomId)
+          throw new Error("Collection with custom id not support 'add' method");
+        const id2 = this.id.generate();
         const parsed = this.schema.parse(data);
         const body = {
-          _id: id,
+          _id: id2,
           ...parsed
         };
         await store.set(body);
@@ -292,16 +455,16 @@ class ArcCollection extends ArcContextElement {
           type: "set",
           to: body
         });
-        return { id };
+        return { id: id2 };
       },
-      remove: async (id) => {
-        await store.remove(id);
+      remove: async (id2) => {
+        await store.remove(id2);
         return { success: true };
       },
-      set: async (id, data) => {
+      set: async (id2, data) => {
         const parsed = this.schema.parse(data);
         const body = {
-          _id: id,
+          _id: id2,
           ...parsed
         };
         await store.set(body);
@@ -314,12 +477,12 @@ class ArcCollection extends ArcContextElement {
       all: async () => {
         return store.findAll();
       },
-      one: async (id) => {
-        return store.findById(id);
+      one: async (id2) => {
+        return store.findById(id2);
       },
-      modify: async (id, data) => {
+      modify: async (id2, data) => {
         const deserialized = this.schema.serializePartial(data);
-        const { from, to } = await store.modify(id, deserialized);
+        const { from, to } = await store.modify(id2, deserialized);
         await publishEvent({
           type: "modify",
           changes: deserialized,
@@ -327,8 +490,8 @@ class ArcCollection extends ArcContextElement {
           to
         });
       },
-      edit: async (id, editCallback) => {
-        const { from, to } = await store.mutate(id, editCallback);
+      edit: async (id2, editCallback) => {
+        const { from, to } = await store.mutate(id2, editCallback);
         await publishEvent({
           type: "mutate",
           from,
@@ -344,8 +507,8 @@ class ArcCollection extends ArcContextElement {
 
 class ArcIndexedCollection extends ArcCollection {
   indexes;
-  constructor(name, id, schema, options, indexes) {
-    super(name, id, schema, options);
+  constructor(name, id2, schema, options, indexes) {
+    super(name, id2, schema, options);
     this.indexes = indexes;
   }
   commandContext(dataStorage, publishEvent) {
@@ -376,11 +539,10 @@ class ArcIndexedCollection extends ArcCollection {
     });
   }
 }
-// context/context.ts
-function context(version, elements, commands, listeners) {
-  return new ArcContext(version, elements, commands, listeners);
+function collection(name, id2, schema, options = {}) {
+  return new ArcCollection(name, id2, schema, options);
 }
-
+// context/context.ts
 class ArcContext {
   version;
   elements;
@@ -392,16 +554,16 @@ class ArcContext {
     this.elements = elements;
     this.commands = commands;
     this.listeners = listeners;
-    this.elementsMap = Object.fromEntries(elements.map((collection3) => [collection3.name, collection3]));
+    this.elementsMap = Object.fromEntries(elements.map((element) => [element.name, element]));
   }
   queryBuilder() {
     return new Proxy({}, {
       get: (target, name) => {
-        const collection3 = this.elementsMap[name];
-        if (!collection3) {
+        const element = this.elementsMap[name];
+        if (!element) {
           throw new Error(`Collection "${name}" not found`);
         }
-        return collection3.queryBuilder();
+        return element.queryBuilder();
       }
     });
   }
@@ -447,6 +609,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) {
@@ -499,30 +664,30 @@ class StoreState {
     };
     await this.applyChanges([change]);
   }
-  async remove(id) {
+  async remove(id2) {
     const change = {
       type: "delete",
-      id
+      id: id2
     };
     await this.applyChanges([change]);
   }
-  async modify(id, data) {
+  async modify(id2, data) {
     const change = {
       type: "modify",
-      id,
+      id: id2,
       data
     };
     const { from, to } = await this.applyChange(change);
     return { from, to };
   }
-  async mutate(id, editCallback) {
-    const object = await this.findById(id);
+  async mutate(id2, editCallback) {
+    const object = await this.findById(id2);
     const [draft, finalize] = create(object || {}, { enablePatches: true });
     await editCallback(draft);
     const [_, patches] = finalize();
     const change = {
       type: "mutate",
-      id,
+      id: id2,
       patches
     };
     const { from, to } = await this.applyChange(change);
@@ -623,12 +788,12 @@ class ForkedStoreState extends StoreState {
       this.notifyListeners(events);
     }
   }
-  async findById(id, listener) {
+  async findById(id2, listener) {
     if (listener)
-      this.listeners.set(listener, { callback: listener, id });
-    if (this.changedItems.has(id))
-      return this.changedItems.get(id);
-    return await this.master.findById(id);
+      this.listeners.set(listener, { callback: listener, id: id2 });
+    if (this.changedItems.has(id2))
+      return this.changedItems.get(id2);
+    return await this.master.findById(id2);
   }
   async findByIndex(index, data, listener) {
     if (listener)
@@ -636,16 +801,16 @@ class ForkedStoreState extends StoreState {
     const parentResult = await this.master.findByIndex(index, data);
     const results = new Map;
     parentResult.forEach((item) => results.set(item._id, item));
-    for (const [id, changedItem] of this.changedItems) {
+    for (const [id2, changedItem] of this.changedItems) {
       if (changedItem === null) {
-        results.delete(id);
+        results.delete(id2);
         continue;
       }
       const matches = Object.entries(data).every(([key, value]) => changedItem[key] === value);
       if (matches) {
-        results.set(id, changedItem);
+        results.set(id2, changedItem);
       } else {
-        results.delete(id);
+        results.delete(id2);
       }
     }
     return Array.from(results.values());
@@ -655,9 +820,9 @@ class ForkedStoreState extends StoreState {
       this.listeners.set(listener, { callback: listener });
     const parentResult = await this.master.findAll();
     return parentResult.map((item) => {
-      const id = item._id;
-      if (this.changedItems.has(id))
-        return this.changedItems.get(id);
+      const id2 = item._id;
+      if (this.changedItems.has(id2))
+        return this.changedItems.get(id2);
       return item;
     });
   }
@@ -785,19 +950,19 @@ class MasterStoreState extends StoreState {
       this.notifyListeners(events);
     }
   }
-  async findById(id, listener) {
-    if (!id)
+  async findById(id2, listener) {
+    if (!id2)
       return;
     if (listener)
-      this.listeners.set(listener, { callback: listener, id });
-    if (this.items.has(id))
-      return this.items.get(id);
+      this.listeners.set(listener, { callback: listener, id: id2 });
+    if (this.items.has(id2))
+      return this.items.get(id2);
     const transaction = await this.dataStorage.getReadTransaction();
-    const result = await transaction.findById(this.storeName, id);
+    const result = await transaction.findById(this.storeName, id2);
     const item = result && this.deserialize ? this.deserialize(result) : result;
     if (!item)
       return;
-    this.items.set(id, item);
+    this.items.set(id2, item);
     return item;
   }
   async findByIndex(index, data, listener) {
@@ -807,17 +972,16 @@ 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;
     }
     const transaction = await this.dataStorage.getReadTransaction();
     const dbResults = await transaction.findByIndex(this.storeName, index, data);
     const results = dbResults.map((item) => {
-      const id = item._id;
-      if (this.items.has(id))
-        return this.items.get(id);
+      const id2 = item._id;
+      if (this.items.has(id2))
+        return this.items.get(id2);
       const processedItem = this.deserialize ? this.deserialize(item) : item;
       return processedItem;
     });
@@ -831,9 +995,9 @@ class MasterStoreState extends StoreState {
     const transaction = await this.dataStorage.getReadTransaction();
     const dbResults = await transaction.findAll(this.storeName);
     const items = dbResults.map((item) => {
-      const id = item._id;
-      if (this.items.has(id))
-        return this.items.get(id);
+      const id2 = item._id;
+      if (this.items.has(id2))
+        return this.items.get(id2);
       const processedItem = this.deserialize ? this.deserialize(item) : item;
       this.items.set(processedItem._id, processedItem);
       return processedItem;
@@ -886,98 +1050,7 @@ class MasterDataStorage extends DataStorage {
     await this.rtcAdapter.sync(progressCallback);
   }
 }
-// elements/optional.ts
-class ArcOptional {
-  parent;
-  constructor(parent) {
-    this.parent = parent;
-  }
-  parse(value) {
-    if (!value)
-      return null;
-    return this.parent.parse(value);
-  }
-  serialize(value) {
-    if (value)
-      return this.parent.serialize(value);
-    return null;
-  }
-  deserialize(value) {
-    if (!value)
-      return null;
-    return this.parent.deserialize(value);
-  }
-}
-
-// elements/branded.ts
-class ArcBranded {
-  parent;
-  brand;
-  constructor(parent, brand) {
-    this.parent = parent;
-    this.brand = brand;
-  }
-  serialize(value) {
-    return this.parent.serialize(value);
-  }
-  deserialize(value) {
-    return this.parent.deserialize(value);
-  }
-  parse(value) {
-    return this.parent.parse(value);
-  }
-  optional() {
-    return new ArcOptional(this);
-  }
-}
-
-// elements/default.ts
-class ArcDefault {
-  parent;
-  defaultValueOrCallback;
-  constructor(parent, defaultValueOrCallback) {
-    this.parent = parent;
-    this.defaultValueOrCallback = defaultValueOrCallback;
-  }
-  parse(value) {
-    if (value)
-      return this.parent.parse(value);
-    if (typeof this.defaultValueOrCallback === "function") {
-      return this.defaultValueOrCallback();
-    } else
-      return this.defaultValueOrCallback;
-  }
-  serialize(value) {
-    return this.parent.serialize(value);
-  }
-  deserialize(value) {
-    if (value)
-      return this.parent.deserialize(value);
-    if (typeof this.defaultValueOrCallback === "function") {
-      return this.defaultValueOrCallback();
-    } else
-      return this.defaultValueOrCallback;
-  }
-}
-
-// elements/abstract.ts
-class ArcAbstract {
-  default(defaultValueOrCallback) {
-    return new ArcDefault(this, defaultValueOrCallback);
-  }
-  optional() {
-    return new ArcOptional(this);
-  }
-  branded(name) {
-    return new ArcBranded(this, name);
-  }
-}
-
 // elements/object.ts
-function object(element) {
-  return new ArcObject(element);
-}
-
 class ArcObject extends ArcAbstract {
   rawShape;
   constructor(rawShape) {
@@ -1040,12 +1113,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) {
@@ -1071,34 +1143,16 @@ class ArcArray extends ArcAbstract {
     return this.parent.deserialize(value);
   }
 }
-// elements/abstract-primitive.ts
-class ArcPrimitive extends ArcAbstract {
-  constructor() {
-    super();
-  }
-  serialize(value) {
-    return value;
-  }
-  parse(value) {
-    return value;
-  }
-  deserialize(value) {
-    return value;
-  }
+function array(element) {
+  return new ArcArray(element);
 }
-
 // 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();
@@ -1113,42 +1167,16 @@ class ArcDate extends ArcAbstract {
     return new Date(value);
   }
 }
-// elements/string.ts
-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);
-  }
-  generate() {
-    var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
-    return timestamp + "xxxxxxxxxxxxxxxx".replace(/[x]/g, function() {
-      return (Math.random() * 16 | 0).toString(16);
-    }).toLowerCase();
-  }
+function date() {
+  return new ArcDate;
 }
 // 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;
@@ -1182,11 +1210,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) {
@@ -1206,6 +1233,9 @@ class ArcStringEnum extends ArcAbstract {
     return this.values;
   }
 }
+function stringEnum(...values) {
+  return new ArcStringEnum(values);
+}
 // rtc/client.ts
 class RTCClient {
   storage;
@@ -1366,10 +1396,6 @@ class ArcStateQueryBuilder extends ArcQueryBuilder {
 }
 
 // state/state.ts
-function state(name, schema) {
-  return new ArcState(name, schema);
-}
-
 class ArcState extends ArcContextElement {
   name;
   schema;
@@ -1412,6 +1438,9 @@ class ArcState extends ArcContextElement {
     };
   }
 }
+function state(name, schema) {
+  return new ArcState(name, schema);
+}
 export {
   stringEnum,
   string,
@@ -1422,6 +1451,7 @@ export {
   number,
   id,
   date,
+  customId,
   context,
   collection,
   boolean,
@@ -1444,6 +1474,7 @@ export {
   ArcIndexedCollection,
   ArcId,
   ArcDate,
+  ArcCustomId,
   ArcCollectionQuery,
   ArcCollection,
   ArcBranded,

package/package.json

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