@arcote.tech/arc 0.0.26 → 0.0.27

package/dist/context/context.d.ts

@@ -15,7 +15,7 @@ declare class ArcContext<const C extends ArcContextElementAny[], const Cmds exte
         [Collection in C[number] as Collection["name"]]: ReturnType<Collection["queryBuilder"]>;
     };
     commandContext(client: string, dataStorage: DataStorage, publishEvent: (event: any) => Promise<void>): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; } & {
-        $client: string;
+        $client: any;
     };
     commandsClient(client: string, dataStorage: DataStorage, catchErrorCallback: (error: any) => void): CommandsClient<Cmds>;
 }

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

@@ -16,9 +16,17 @@ export declare class MasterDataStorage extends DataStorage {
         _id: string;
     }>(storeName: string): StoreState<Item>;
     applyChanges(changes: DataStorageChanges[]): Promise<void[]>;
+    applySerializedChanges(changes: any[]): Promise<{
+        from: {
+            _id: string;
+        } | null;
+        to: {
+            _id: string;
+        } | null;
+    }[][]>;
     commitChanges(changes: DataStorageChanges[]): Promise<void>;
     fork(): ForkedDataStorage;
-    sync(progressCallback: ({ store, size }: {
+    sync(progressCallback: ({ store, size, }: {
         store: string;
         size: number;
     }) => void): Promise<void>;

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

@@ -27,6 +27,10 @@ export declare abstract class StoreState<Item extends {
         from: Item | null;
         to: Item | null;
     }>;
+    applySerializedChanges(changes: StoreStateChange<any>[]): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }[]>;
     unsubscribe(listener: QueryListenerCallback<Item>): void;
     protected notifyListeners(events: ListenerEvent<Item>[]): void;
 }

package/dist/elements/abstract-primitive.d.ts

@@ -1,5 +1,5 @@
-import { ArcAbstract } from "./abstract";
-export declare abstract class ArcPrimitive<T> extends ArcAbstract {
+import { ArcAbstract, type Validators } from "./abstract";
+export declare abstract class ArcPrimitive<V extends Validators, T> extends ArcAbstract<V> {
     constructor();
     serialize(value: T): T;
     parse(value: T): T;

package/dist/elements/abstract.d.ts

@@ -2,12 +2,28 @@ import { ArcBranded } from "./branded";
 import { ArcDefault } from "./default";
 import type { ArcElement } from "./element";
 import { ArcOptional } from "./optional";
-export declare abstract class ArcAbstract implements ArcElement {
+export type CheckFn<T> = (value: any) => T | undefined;
+export type Validator<T> = {
+    name: string;
+    validator: CheckFn<T>;
+};
+export type Validators = Validator<any>[];
+export type GetValidator<A extends ArcAbstract<any>> = A extends ArcAbstract<infer T> ? T : [];
+export declare abstract class ArcAbstract<V extends Validators> implements ArcElement {
+    protected validations: V;
     abstract serialize(value: any): any;
     abstract deserialize(value: any): any;
     abstract parse(value: any): any;
     default(defaultValueOrCallback: (() => ReturnType<this["deserialize"]>) | ReturnType<this["deserialize"]>): ArcDefault<this>;
     optional(): ArcOptional<this>;
     branded<Brand extends string | symbol>(name: Brand): ArcBranded<this, Brand>;
+    protected clone(): this;
+    validate(value: any): { [Key in V[number] as Key["name"]]: ReturnType<Key["validator"]>; };
+    protected pipeValidation<Name extends string, Val extends CheckFn<any>>(name: Name, validator: Val): ArcAbstract<[...V, {
+        name: Name;
+        validator: Val;
+    }]>;
+    getValidations(): V;
 }
+export type ArcAbstractAny = ArcAbstract<any>;
 //# sourceMappingURL=abstract.d.ts.map

package/dist/elements/array.d.ts

@@ -1,7 +1,7 @@
 import { type util } from "../utils";
 import { ArcAbstract } from "./abstract";
 import type { ArcElement } from "./element";
-export declare class ArcArray<E extends ArcElement> extends ArcAbstract {
+export declare class ArcArray<E extends ArcElement> extends ArcAbstract<[]> {
     private parent;
     constructor(parent: E);
     parse(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["parse"]>[];

package/dist/elements/boolean.d.ts

@@ -1,5 +1,5 @@
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcBoolean extends ArcPrimitive<boolean> {
+export declare class ArcBoolean extends ArcPrimitive<[], boolean> {
 }
 export declare function boolean(): ArcBoolean;
 //# sourceMappingURL=boolean.d.ts.map

package/dist/elements/branded.d.ts

@@ -1,8 +1,8 @@
 import { type util } from "../utils";
-import { ArcAbstract } from "./abstract";
+import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
 import { ArcOptional } from "./optional";
-export declare class ArcBranded<E extends ArcAbstract, Brand extends string | symbol> implements ArcElement {
+export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string | symbol> implements ArcElement {
     private parent;
     private brand;
     constructor(parent: E, brand: Brand);
@@ -16,6 +16,7 @@ export declare class ArcBranded<E extends ArcAbstract, Brand extends string | sy
         __brand: Brand;
     };
     optional(): ArcOptional<this>;
+    validate(value: unknown): unknown;
 }
-export type ArcBrandedAny = ArcBranded<ArcAbstract, any>;
+export type ArcBrandedAny = ArcBranded<ArcAbstractAny, any>;
 //# sourceMappingURL=branded.d.ts.map

package/dist/elements/class.d.ts

@@ -0,0 +1,25 @@
+import type { util } from "../utils";
+import type { ArcElement } from "./element";
+import type { ArcRawShape } from "./object";
+import { ArcOptional } from "./optional";
+export declare function ArcClass<E extends ArcRawShape>(shape: E): {
+    new (): { [key in keyof E]: ReturnType<E[key]["deserialize"]>; };
+} & {
+    create<T extends {
+        new (): any;
+    }>(this: T, data: { [key in keyof E]: util.FirstArgument<E[key]["deserialize"]>; }): InstanceType<T>;
+};
+export declare class ArcInstanceOf<E> implements ArcElement {
+    private Class;
+    constructor(Class: {
+        new (): E;
+    });
+    serialize(value: unknown): unknown;
+    deserialize(value: unknown): E;
+    parse(value: unknown): unknown;
+    optional(): ArcOptional<this>;
+}
+export declare function instanceOf<E>(element: {
+    new (): E;
+}): ArcInstanceOf<E>;
+//# sourceMappingURL=class.d.ts.map

package/dist/elements/date.d.ts

@@ -1,5 +1,5 @@
 import { ArcAbstract } from "./abstract";
-export declare class ArcDate extends ArcAbstract {
+export declare class ArcDate extends ArcAbstract<[]> {
     constructor();
     parse(value: string | number | Date): Date;
     serialize(value: Date): number;

package/dist/elements/default.d.ts

@@ -4,6 +4,7 @@ export declare class ArcDefault<E extends ArcElement> implements ArcElement {
     private parent;
     private defaultValueOrCallback;
     constructor(parent: E, defaultValueOrCallback: (() => ReturnType<E["deserialize"]>) | ReturnType<E["deserialize"]>);
+    validate(value: unknown): unknown;
     parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]>;
     serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
     deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;

package/dist/elements/element.d.ts

@@ -2,5 +2,6 @@ export interface ArcElement {
     serialize(value: unknown): unknown;
     deserialize(value: unknown): unknown;
     parse(value: unknown): unknown;
+    validate(value: unknown): unknown;
 }
 //# sourceMappingURL=element.d.ts.map

package/dist/elements/number.d.ts

@@ -1,5 +1,24 @@
+import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcNumber extends ArcPrimitive<number> {
+export declare class ArcNumber<V extends Validators = []> extends ArcPrimitive<V, number> {
+    min(min: number): ArcNumber<[...V, {
+        name: "min";
+        validator: (value: any) => {
+            current: any;
+            min: number;
+        } | undefined;
+    }]>;
+    max(max: number): ArcNumber<[...V, {
+        name: "max";
+        validator: (value: any) => {
+            current: any;
+            max: number;
+        } | undefined;
+    }]>;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcNumber<GetValidator<import("./abstract").ArcAbstract<[...V, {
+        name: Name;
+        validator: Fn;
+    }]>>>;
 }
-export declare function number(): ArcNumber;
+export declare function number(): ArcNumber<[]>;
 //# sourceMappingURL=number.d.ts.map

package/dist/elements/object.d.ts

@@ -4,7 +4,7 @@ import type { ArcElement } from "./element";
 export declare type ArcRawShape = {
     [k: string]: ArcElement;
 };
-export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract {
+export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract<[]> {
     private rawShape;
     constructor(rawShape: E);
     parse(value: {
@@ -38,7 +38,13 @@ export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract {
     }>): {
         [key in keyof E]: ReturnType<E[key]["serialize"]>;
     };
+    pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>>;
+    validate(value: any): {
+        [key in keyof E]: ReturnType<E[key]["validate"]>;
+    };
 }
 export type ArcObjectAny = ArcObject<any>;
+export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E> ? Exclude<keyof E, symbol> : never;
+export type ArcObjectValueByKey<T extends ArcObjectAny, K extends ArcObjectKeys<T>> = T extends ArcObject<infer E> ? E[K] : never;
 export declare function object<E extends ArcRawShape>(element: E): ArcObject<E>;
 //# sourceMappingURL=object.d.ts.map

package/dist/elements/optional.d.ts

@@ -1,5 +1,5 @@
 import { type util } from "../utils";
-import { ArcAbstract } from "./abstract";
+import { type ArcAbstractAny } from "./abstract";
 import type { ArcElement } from "./element";
 export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     private parent;
@@ -7,6 +7,7 @@ export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     parse(value: util.FirstArgument<E["parse"]> | null | undefined): ReturnType<E["parse"]> | null;
     serialize(value: util.FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
     deserialize(value: util.FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
+    validate(value: unknown): unknown;
 }
-export type ArcOptionalAny = ArcOptional<ArcAbstract>;
+export type ArcOptionalAny = ArcOptional<ArcAbstractAny>;
 //# sourceMappingURL=optional.d.ts.map

package/dist/elements/or.d.ts

@@ -0,0 +1,12 @@
+import type { util } from "../utils";
+import type { ArcElement } from "./element";
+export declare class ArcOr<T extends ArcElement[]> implements ArcElement {
+    private elements;
+    constructor(elements: T);
+    serialize(value: util.FirstArgument<T[number]["serialize"]>): ReturnType<T[number]["serialize"]>;
+    deserialize(value: util.FirstArgument<T[number]["deserialize"]>): ReturnType<T[number]["deserialize"]>;
+    parse(value: util.FirstArgument<T[number]["parse"]>): ReturnType<T[number]["parse"]>;
+    private isTypeOf;
+}
+export declare function or<T extends ArcElement[]>(...elements: T): ArcOr<T>;
+//# sourceMappingURL=or.d.ts.map

package/dist/elements/record.d.ts

@@ -5,7 +5,7 @@ import type { ArcId } from "./id";
 import type { ArcNumber } from "./number";
 import type { ArcString } from "./string";
 type ArcKey = ArcString | ArcNumber | ArcId<any>;
-export declare class ArcRecord<Key extends ArcKey, E extends ArcElement> extends ArcAbstract {
+export declare class ArcRecord<Key extends ArcKey, E extends ArcElement> extends ArcAbstract<[]> {
     private key;
     private element;
     constructor(key: Key, element: E);

package/dist/elements/string-enum.d.ts

@@ -1,5 +1,5 @@
 import { ArcAbstract } from "./abstract";
-export declare class ArcStringEnum<const T extends string[]> extends ArcAbstract {
+export declare class ArcStringEnum<const T extends string[]> extends ArcAbstract<[]> {
     private values;
     constructor(values: T);
     parse<Value extends T[number]>(value: Value): Value;

package/dist/elements/string.d.ts

@@ -1,5 +1,24 @@
+import type { CheckFn, GetValidator, Validators } from "./abstract";
 import { ArcPrimitive } from "./abstract-primitive";
-export declare class ArcString extends ArcPrimitive<string> {
+export declare class ArcString<V extends Validators = []> extends ArcPrimitive<V, string> {
+    minLength(min: number): ArcString<[...V, {
+        name: "minLength";
+        validator: (value: any) => {
+            currentLength: any;
+            minLength: number;
+        } | undefined;
+    }]>;
+    maxLength(max: number): ArcString<[...V, {
+        name: "maxLength";
+        validator: (value: any) => {
+            currentLength: any;
+            maxLength: number;
+        } | undefined;
+    }]>;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcString<GetValidator<import("./abstract").ArcAbstract<[...V, {
+        name: Name;
+        validator: Fn;
+    }]>>>;
 }
-export declare function string(): ArcString;
+export declare function string(): ArcString<[]>;
 //# sourceMappingURL=string.d.ts.map

package/dist/elements/tests/example.d.ts

@@ -0,0 +1,6 @@
+export declare const instanceof_parse: (value: {
+    test: string;
+}) => {
+    test: string;
+};
+//# sourceMappingURL=example.d.ts.map

package/dist/elements/tests/test.d.ts

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

package/dist/index.js

@@ -24,6 +24,11 @@ class ArcOptional {
       return null;
     return this.parent.deserialize(value);
   }
+  validate(value) {
+    if (!value)
+      return {};
+    return this.parent.validate(value);
+  }
 }
 
 // elements/branded.ts
@@ -46,6 +51,9 @@ class ArcBranded {
   optional() {
     return new ArcOptional(this);
   }
+  validate(value) {
+    return this.parent.validate(value);
+  }
 }
 
 // elements/default.ts
@@ -56,6 +64,9 @@ class ArcDefault {
     this.parent = parent;
     this.defaultValueOrCallback = defaultValueOrCallback;
   }
+  validate(value) {
+    throw new Error("Method not implemented.");
+  }
   parse(value) {
     if (value)
       return this.parent.parse(value);
@@ -79,6 +90,7 @@ class ArcDefault {
 
 // elements/abstract.ts
 class ArcAbstract {
+  validations = [];
   default(defaultValueOrCallback) {
     return new ArcDefault(this, defaultValueOrCallback);
   }
@@ -88,6 +100,25 @@ class ArcAbstract {
   branded(name) {
     return new ArcBranded(this, name);
   }
+  clone() {
+    const Constructor = this.constructor;
+    const newInstance = Object.assign(new Constructor, this);
+    return newInstance;
+  }
+  validate(value) {
+    return this.validations.reduce((acc, { name, validator }) => {
+      acc[name] = validator(value);
+      return acc;
+    }, {});
+  }
+  pipeValidation(name, validator) {
+    const newInstance = this.clone();
+    newInstance.validations = [...this.validations, { name, validator }];
+    return newInstance;
+  }
+  getValidations() {
+    return this.validations;
+  }
 }
 
 // elements/abstract-primitive.ts
@@ -108,6 +139,28 @@ class ArcPrimitive extends ArcAbstract {
 
 // elements/string.ts
 class ArcString extends ArcPrimitive {
+  minLength(min) {
+    return this.validation("minLength", (value) => {
+      if (value.length < min)
+        return {
+          currentLength: value.length,
+          minLength: min
+        };
+    });
+  }
+  maxLength(max) {
+    return this.validation("maxLength", (value) => {
+      if (value.length > max)
+        return {
+          currentLength: value.length,
+          maxLength: max
+        };
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
 }
 function string() {
   return new ArcString;
@@ -693,6 +746,9 @@ class StoreState {
     const { from, to } = await this.applyChange(change);
     return { from, to };
   }
+  applySerializedChanges(changes) {
+    return Promise.all(changes.map((change) => this.applyChange(change)));
+  }
   unsubscribe(listener) {
     this.listeners.delete(listener);
   }
@@ -1037,6 +1093,9 @@ class MasterDataStorage extends DataStorage {
   async applyChanges(changes) {
     return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
   }
+  applySerializedChanges(changes) {
+    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
+  }
   async commitChanges(changes) {
     await Promise.all([
       this.applyChanges(changes),
@@ -1112,6 +1171,20 @@ class ArcObject extends ArcAbstract {
       return acc;
     }, {});
   }
+  pick(...keys) {
+    return new ArcObject(Object.fromEntries(keys.map((key) => [key, this.rawShape[key]])));
+  }
+  validate(value) {
+    console.log(this.rawShape);
+    return Object.entries(this.rawShape).reduce((acc, [key, element]) => {
+      if (!element.validate) {
+        return acc;
+      }
+      console.log(element);
+      acc[key] = element.validate(value[key]);
+      return acc;
+    }, {});
+  }
 }
 function object(element) {
   return new ArcObject(element);
@@ -1131,6 +1204,8 @@ class ArcArray extends ArcAbstract {
     return value.map((v) => this.parent.serialize(v));
   }
   deserialize(value) {
+    if (!Array.isArray(value))
+      return [];
     return value.map((v) => this.parent.deserialize(v));
   }
   deserializePath(path, value) {
@@ -1172,6 +1247,22 @@ function date() {
 }
 // elements/number.ts
 class ArcNumber extends ArcPrimitive {
+  min(min) {
+    return this.validation("min", (value) => {
+      if (value < min)
+        return { current: value, min };
+    });
+  }
+  max(max) {
+    return this.validation("max", (value) => {
+      if (value > max)
+        return { current: value, max };
+    });
+  }
+  validation(name, validator) {
+    const instance = this.pipeValidation(name, validator);
+    return instance;
+  }
 }
 function number() {
   return new ArcNumber;

package/dist/tests/query/query.test.d.ts

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

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

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

package/dist/tests/validation.test.d.ts

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

package/dist/tests/validations/number.test.d.ts

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

package/dist/tests/validations/string.test.d.ts

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

package/dist/tests/validations/validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.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.26",
+  "version": "0.0.27",
   "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.",