@arcote.tech/arc 0.0.27 → 0.1.2

package/dist/db/sqliteAdapter.d.ts

@@ -0,0 +1,39 @@
+import { type ArcContextAny } from "../context";
+import type { StoreTable } from "../context/element";
+import type { FindOptions, WhereCondition } from "../data-storage/types";
+import type { DatabaseAdapter, DBAdapterFactory, ReadTransaction, ReadWriteTransaction } from "./interface";
+export interface SQLiteDatabase {
+    exec(sql: string, params?: any[]): Promise<any>;
+}
+declare class SQLiteReadTransaction implements ReadTransaction {
+    protected db: SQLiteDatabase;
+    protected tables: Map<string, StoreTable>;
+    constructor(db: SQLiteDatabase, tables: Map<string, StoreTable>);
+    protected getId(store: string, id: any): any;
+    protected buildWhereClause(where?: WhereCondition): {
+        sql: string;
+        params: any[];
+    };
+    protected getOperatorSymbol(operator: string): string;
+    protected buildOrderByClause(orderBy?: Record<string, "asc" | "desc">): string;
+    find<T>(store: string, options: FindOptions<T>): Promise<T[]>;
+}
+declare class SQLiteReadWriteTransaction extends SQLiteReadTransaction implements ReadWriteTransaction {
+    remove(store: string, id: any): Promise<void>;
+    set(store: string, item: any): Promise<void>;
+    commit(): Promise<void>;
+    private serializeValue;
+}
+export declare class SQLiteAdapter implements DatabaseAdapter {
+    private db;
+    private context;
+    private tables;
+    constructor(db: SQLiteDatabase, context: ArcContextAny);
+    initialize(): Promise<void>;
+    private createTableIfNotExists;
+    readWriteTransaction(stores?: string[]): SQLiteReadWriteTransaction;
+    readTransaction(stores?: string[]): SQLiteReadTransaction;
+}
+export declare const createSQLiteAdapterFactory: (db: SQLiteDatabase) => DBAdapterFactory;
+export {};
+//# sourceMappingURL=sqliteAdapter.d.ts.map

package/dist/dist/index.d.ts

@@ -0,0 +1,513 @@
+export function view(name: any, id3: any, schema: any): ArcView;
+export function stringEnum(...values: any[]): ArcStringEnum;
+export function string(): ArcString;
+export function state(name: any, schema: any): ArcState;
+export function rtcClientFactory(token: any): (storage: any) => RTCClient;
+export function record(key: any, element: any): ArcRecord;
+export function reactive(fn: any): (context2: any) => ReactiveQueryBuilder;
+export function object(element: any): ArcObject;
+export function number(): ArcNumber;
+export function id(name: any): ArcId;
+export function event(name: any, payload: any): ArcEvent;
+export function date(): ArcDate;
+export function customId(name: any, createFn: any): ArcCustomId;
+export function createSQLiteAdapterFactory(db: any): (context3: any) => Promise<SQLiteAdapter>;
+export function context(elementsPromise: any): Promise<ArcContext>;
+export function command(name: any): ArcCommand;
+export function collection(name: any, id3: any, schema: any, options?: {}): ArcCollection;
+export function boolean(): ArcBoolean;
+export function array(element: any): ArcArray;
+export class StoreState {
+    constructor(storeName: any, dataStorage: any, deserialize: any);
+    storeName: any;
+    dataStorage: any;
+    deserialize: any;
+    listeners: Map<any, any>;
+    fork(): ForkedStoreState;
+    set(item: any): Promise<void>;
+    remove(id3: any): Promise<void>;
+    modify(id3: any, data: any): Promise<{
+        from: any;
+        to: any;
+    }>;
+    mutate(id3: any, editCallback: any): Promise<{
+        from: any;
+        to: any;
+    }>;
+    applySerializedChanges(changes: any): Promise<any[]>;
+    unsubscribe(listener: any): void;
+    notifyListeners(events: any): void;
+}
+export class SQLiteAdapter {
+    constructor(db: any, context3: any);
+    db: any;
+    context: any;
+    tables: Map<any, any>;
+    initialize(): Promise<void>;
+    createTableIfNotExists(table: any): Promise<void>;
+    readWriteTransaction(stores: any): SQLiteReadWriteTransaction;
+    readTransaction(stores: any): SQLiteReadTransaction;
+}
+export class RemoteModelClient extends ModelBase {
+    constructor(context3: any, apiBaseUrl: any, client: any, catchErrorCallback: any);
+    context: any;
+    apiBaseUrl: any;
+    client: any;
+    catchErrorCallback: any;
+    query(queryBuilderFn: any): Promise<any>;
+    subscribe(queryBuilderFn: any, callback: any): {
+        unsubscribe: () => void;
+        result: Promise<any>;
+    };
+    commands(): {};
+}
+export class ModelBase {
+}
+export class Model extends ModelBase {
+    constructor(context3: any, dataStorage: any, client: any, catchErrorCallback: any);
+    context: any;
+    dataStorage: any;
+    client: any;
+    catchErrorCallback: any;
+    queryCache: QueryCache;
+    query(queryBuilderFn: any): Promise<any>;
+    subscribe(queryBuilderFn: any, callback: any): {
+        unsubscribe: () => void;
+        result: any;
+    };
+    commands(): any;
+    fork(): ForkedModel;
+    get $debug(): {};
+}
+export class MasterStoreState extends StoreState {
+    applyChangeAndReturnEvent(transaction: any, change: any): Promise<{
+        from: null;
+        to: any;
+        event: {
+            type: string;
+            item: any;
+            id: any;
+        };
+    }>;
+    applyChange(change: any): Promise<{
+        from: null;
+        to: any;
+    }>;
+    applyChanges(changes: any): Promise<void>;
+    find(options: any, listener: any): Promise<any>;
+}
+export class MasterDataStorage extends DataStorage {
+    constructor(dbAdapter: any, rtcAdapterFactory: any, arcContext: any);
+    dbAdapter: any;
+    arcContext: any;
+    stores: Map<any, any>;
+    rtcAdapter: any;
+    getReadTransaction(): Promise<any>;
+    getReadWriteTransaction(): Promise<any>;
+    getStore(storeName: any): any;
+    applyChanges(changes: any): Promise<any[]>;
+    applySerializedChanges(changes: any): Promise<any[]>;
+    fork(): ForkedDataStorage;
+    sync(progressCallback: any): Promise<void>;
+}
+export class ForkedStoreState extends StoreState {
+    master: any;
+    changedItems: Map<any, any>;
+    changes: any[];
+    applyChangeAndReturnEvent(change: any): Promise<{
+        from: any;
+        to: any;
+        event: {
+            type: string;
+            item: any;
+            id: any;
+        };
+    }>;
+    applyChange(change: any): Promise<{
+        from: any;
+        to: any;
+    }>;
+    applyChanges(changes: any): Promise<void>;
+    find(options: any, listener: any): Promise<any[]>;
+}
+export class ForkedModel extends Model {
+    merge(): void;
+}
+export class ForkedDataStorage extends DataStorage {
+    constructor(master: any);
+    master: any;
+    stores: Map<any, any>;
+    getReadTransaction(): any;
+    getReadWriteTransaction(): any;
+    getStore(storeName: any): any;
+    fork(): ForkedDataStorage;
+    merge(): Promise<void>;
+}
+export class DataStorage {
+    commitChanges(changes: any): Promise<void>;
+}
+export class ArcView extends ArcContextElementWithStore {
+    constructor(name: any, id3: any, schema: any);
+    id: any;
+    schema: any;
+    _description: any;
+    _elements: any;
+    _handler: any;
+    storeSchema: () => {
+        tables: {
+            name: any;
+            columns: any;
+            primaryKey: string;
+        }[];
+    };
+    use(elements: any): ArcView;
+    description(description: any): ArcView;
+    handle(handler: any): ArcView;
+    queryBuilder: (context3: any) => {
+        find: (options: any) => never;
+    };
+    commandContext: (dataStorage: any, publishEvent: any) => {
+        find: (options: any) => Promise<any>;
+        findOne: (where: any) => Promise<any>;
+    };
+    observer: () => {};
+    clone(): ArcView;
+}
+export class ArcStringEnum extends ArcAbstract {
+    constructor(values: any);
+    values: any;
+    parse(value: any): any;
+    serialize(value: any): any;
+    deserialize(value: any): any;
+    getEnumerators(): any;
+}
+export class ArcString extends ArcPrimitive {
+    constructor();
+    minLength(min: any): any;
+    maxLength(max: any): any;
+    length(number: any): any;
+    includes(str: any): any;
+    startsWith(str: any): any;
+    endsWith(str: any): any;
+    regex(regex: any): any;
+    email(): any;
+    url(): any;
+    ip(): any;
+    validation(name: any, validator: any): any;
+}
+export class ArcState extends ArcContextElement {
+    constructor(name: any, schema: any);
+    schema: any;
+    serialize(data: any): any;
+    deserialize(data: any): any;
+    queryBuilder(context3: any): ArcStateQueryBuilder;
+    commandContext(dataStorage: any, publishEvent: any): {
+        get: () => Promise<any>;
+        modify: (data: any) => Promise<void>;
+        edit: (editCallback: any) => Promise<void>;
+    };
+}
+export class ArcRecord extends ArcAbstract {
+    constructor(key: any, element: any);
+    key: any;
+    element: any;
+    parse(value: any): {};
+    serialize(value: any): {};
+    deserialize(value: any): {};
+}
+export class ArcQueryBuilder {
+    constructor(queryContext: any);
+    queryContext: any;
+    run(): any;
+}
+export class ArcQuery {
+    lastResult: any;
+    listeners: Set<any>;
+    subscribe(listener: any): void;
+    unsubscribe(listener: any): void;
+    nextResult(result: any): void;
+}
+export class ArcOptional {
+    constructor(parent: any);
+    parent: any;
+    parse(value: any): any;
+    serialize(value: any): any;
+    deserialize(value: any): any;
+    validate(value: any): any;
+}
+export class ArcObject extends ArcAbstract {
+    constructor(rawShape: any);
+    rawShape: any;
+    parse(value: any): {};
+    serialize(value: any): {};
+    deserialize(value: any): {
+        [k: string]: any;
+    };
+    deserializePath(path: any, value: any): any;
+    parsePartial(value: any): {};
+    deserializePartial(value: any): {};
+    serializePartial(value: any): {};
+    pick(...keys: any[]): ArcObject;
+    omit(...keys: any[]): ArcObject;
+    entries(): [string, any][];
+}
+export class ArcNumber extends ArcPrimitive {
+    constructor();
+    min(min: any): any;
+    max(max: any): any;
+    validation(name: any, validator: any): any;
+}
+export class ArcId extends ArcBranded {
+    constructor(name: any);
+    generate(): string;
+}
+export class ArcEvent extends ArcContextElementWithStore {
+    constructor(name: any, payload: any);
+    payload: any;
+    storeSchema: () => {
+        tables: {
+            name: string;
+            columns: {
+                name: string;
+                type: string;
+            }[];
+        }[];
+    };
+    commandContext: (dataStorage: any, publishEvent: any) => {
+        emit: (payload: any) => Promise<void>;
+    };
+}
+export class ArcDate extends ArcAbstract {
+    constructor();
+    parse(value: any): Date;
+    serialize(value: any): any;
+    deserialize(value: any): Date;
+    after(after: any): any;
+    before(before: any): any;
+    validation(name: any, validator: any): any;
+}
+export class ArcCustomId extends ArcBranded {
+    createFn: any;
+    get(...args: any[]): any;
+}
+export class ArcContext {
+    constructor(elements: any);
+    elements: any;
+    eventListeners: Map<any, any>;
+    pipe(newElements: any): ArcContext;
+    queryBuilder(queryContext: any): {};
+    commandContext(client: any, dataStorage: any): {};
+    commandsClient(client: any, queryContext: any, dataStorage: any, catchErrorCallback: any): {};
+}
+export class ArcCommand extends ArcContextElement {
+    constructor(name: any);
+    _description: any;
+    _params: any;
+    _result: any;
+    _elements: any;
+    _handler: any;
+    use(elements: any): ArcCommand;
+    description(description: any): ArcCommand;
+    withParams(schema: any): ArcCommand;
+    withResult(schema: any): ArcCommand;
+    handle(handler: any): ArcCommand;
+    commandClient: (ctx: any) => ((params: any) => Promise<any>) & {
+        params: any;
+    };
+    clone(): ArcCommand;
+}
+export class ArcCollectionQuery extends ArcSerializableQuery {
+    constructor(collection: any, params: any);
+    collection: any;
+    bindedChangeHandler: (changes: any) => void;
+    store: any;
+    run(dataStorage: any): Promise<any>;
+    changeHandler(changes: any): void;
+}
+export class ArcCollection extends ArcContextElementWithStore {
+    constructor(name: any, id3: any, schema: any, options: any);
+    id: any;
+    schema: any;
+    options: any;
+    storeSchema(): {
+        tables: {
+            name: any;
+            columns: any;
+            primaryKey: string;
+        }[];
+    };
+    serialize(data: any): any;
+    deserialize(data: any): any;
+    queryBuilder(context: any): {
+        find: (options: any) => ArcFindQueryBuilder;
+    };
+    commandContext: (dataStorage: any, publishEvent: any) => {
+        add: (data: any) => Promise<{
+            id: any;
+        }>;
+        remove: (id3: any) => Promise<{
+            success: boolean;
+        }>;
+        set: (id3: any, data: any) => Promise<{
+            success: boolean;
+        }>;
+        find: (options: any) => Promise<any>;
+        findOne: (where: any) => Promise<any>;
+        modify: (id3: any, data: any) => Promise<void>;
+        edit: (id3: any, editCallback: any) => Promise<void>;
+    };
+}
+export class ArcBranded {
+    constructor(parent: any, brand: any);
+    parent: any;
+    brand: any;
+    serialize(value: any): any;
+    deserialize(value: any): any;
+    parse(value: any): any;
+    optional(): ArcOptional;
+    validate(value: any): any;
+}
+export class ArcBoolean extends ArcPrimitive {
+}
+export class ArcArray extends ArcAbstract {
+    constructor(parent: any);
+    parent: any;
+    minLength(min: any): any;
+    maxLength(max: any): any;
+    length(number: any): any;
+    nonEmpty(): any;
+    parse(value: any): any;
+    serialize(value: any): any;
+    deserialize(value: any): any[];
+    deserializePath(path: any, value: any): any;
+    validation(name: any, validator: any): any;
+}
+declare class RTCClient {
+    constructor(storage: any, token: any);
+    storage: any;
+    token: any;
+    _socket: any;
+    openSocket: any;
+    reconnectAttempts: number;
+    maxReconnectAttempts: number;
+    syncProgressCallback: any;
+    syncPromise: null;
+    sync(progressCallback: any): Promise<null>;
+    performSync(): Promise<void>;
+    connectWebSocket(): Promise<void>;
+    reconnect(): void;
+    commitChanges(changes: any): Promise<void>;
+    onMessage(message: any): void;
+    sendMessage(message: any): Promise<void>;
+}
+declare class ReactiveQueryBuilder {
+    constructor(queryBuilder: any, fn: any);
+    queryBuilder: any;
+    fn: any;
+    toQuery(context2: any): ReactiveQuery;
+}
+declare class SQLiteReadWriteTransaction extends SQLiteReadTransaction {
+    remove(store: any, id3: any): Promise<void>;
+    set(store: any, item: any): Promise<void>;
+    commit(): Promise<void>;
+    serializeValue(value: any): any;
+}
+declare class SQLiteReadTransaction {
+    constructor(db: any, tables: any);
+    db: any;
+    tables: any;
+    getId(store: any, id3: any): any;
+    buildWhereClause(where: any): {
+        sql: string;
+        params: any[];
+    };
+    getOperatorSymbol(operator: any): any;
+    buildOrderByClause(orderBy: any): string;
+    find(store: any, options: any): Promise<any>;
+}
+declare class QueryCache {
+    cache: Map<any, any>;
+    getIndexHash(value: any): any;
+    set(index: any, query2: any): void;
+    get(index: any): any;
+    debug(): Map<any, any>;
+}
+declare class ArcContextElementWithStore extends ArcContextElement {
+}
+declare class ArcAbstract {
+    constructor(validations?: any[]);
+    validations: any[];
+    default(defaultValueOrCallback: any): ArcDefault;
+    optional(): ArcOptional;
+    branded(name: any): ArcBranded;
+    clone(): any;
+    validate(value: any): any;
+    pipeValidation(name: any, validator: any): any;
+    getValidations(): any[];
+}
+declare class ArcPrimitive extends ArcAbstract {
+    serialize(value: any): any;
+    parse(value: any): any;
+    deserialize(value: any): any;
+}
+declare class ArcContextElement {
+    $event: any;
+    name: any;
+    commandContext: any;
+    commandClient: any;
+    observer: any;
+}
+declare class ArcStateQueryBuilder extends ArcQueryBuilder {
+    constructor(state: any, context3: any);
+    state: any;
+    toQuery(): ArcStateQuery;
+}
+declare class ArcSerializableQuery extends ArcQuery {
+    static key: any;
+    constructor(params: any);
+    params: any;
+    serialize(): {
+        key: any;
+        params: any;
+    };
+}
+declare class ArcFindQueryBuilder {
+    constructor(collection: any, queryContext: any, options: any);
+    collection: any;
+    queryContext: any;
+    options: any;
+    toQuery(): any;
+    run(): any;
+}
+declare class ReactiveQuery extends ArcQuery {
+    constructor(queryContext: any, queryBuilder: any, fn: any);
+    queryContext: any;
+    queryBuilder: any;
+    fn: any;
+    queries: any[];
+    run(): Promise<any>;
+    onChangeHandler: () => Promise<void>;
+    onChange(): Promise<void>;
+    runQuery(): Promise<any>;
+}
+declare class ArcDefault {
+    constructor(parent: any, defaultValueOrCallback: any);
+    parent: any;
+    defaultValueOrCallback: any;
+    validate(value: any): void;
+    parse(value: any): any;
+    serialize(value: any): any;
+    deserialize(value: any): any;
+}
+declare class ArcStateQuery extends ArcQuery {
+    constructor(state: any);
+    state: any;
+    bindedChangeHandler: (changes: any) => void;
+    store: any;
+    run(dataStorage: any): Promise<any>;
+    onChange(change: any): any;
+    changeHandler(changes: any): void;
+    unsubscribe(): void;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,5 @@
 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;
     deserialize(value: T): T;

package/dist/elements/abstract.d.ts

@@ -11,6 +11,7 @@ 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;
+    constructor(validations?: V);
     abstract serialize(value: any): any;
     abstract deserialize(value: any): any;
     abstract parse(value: any): any;
@@ -18,7 +19,7 @@ export declare abstract class ArcAbstract<V extends Validators> implements ArcEl
     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"]>; };
+    validate(value: any): false | { [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;

package/dist/elements/array.d.ts

@@ -1,14 +1,72 @@
 import { type util } from "../utils";
-import { ArcAbstract } from "./abstract";
+import { ArcAbstract, type CheckFn, type GetValidator, type Validators } from "./abstract";
 import type { ArcElement } from "./element";
-export declare class ArcArray<E extends ArcElement> extends ArcAbstract<[]> {
+declare const arrayValidator: {
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "array";
+    };
+};
+export declare class ArcArray<E extends ArcElement, V extends Validators = [
+    typeof arrayValidator,
+    {
+        name: "schema";
+        validator: (values: any[]) => {
+            [index: number]: ReturnType<E["validate"]>;
+        } | false;
+    }
+]> extends ArcAbstract<V> {
     private parent;
     constructor(parent: E);
+    minLength(min: number): ArcArray<E, [...V, {
+        name: "minLength";
+        validator: (value: any[]) => {
+            currentLength: number;
+            minLength: number;
+        } | undefined;
+    }]>;
+    maxLength(max: number): ArcArray<E, [...V, {
+        name: "maxLength";
+        validator: (value: any[]) => {
+            currentLength: number;
+            maxLength: number;
+        } | undefined;
+    }]>;
+    length(number: number): ArcArray<E, [...V, {
+        name: "length";
+        validator: (value: any[]) => {
+            currentLength: number;
+            length: number;
+        } | undefined;
+    }]>;
+    nonEmpty(): ArcArray<E, [...V, {
+        name: "nonEmpty";
+        validator: (value: any[]) => {
+            readonly msg: "array is empty";
+        } | undefined;
+    }]>;
     parse(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["parse"]>[];
     serialize(value: util.FirstArgument<E["serialize"]>[]): ReturnType<E["serialize"]>[];
     deserialize(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["deserialize"]>[];
     deserializePath(path: string[], value: any): any;
+    validation<Name extends string, Fn extends CheckFn<any>>(name: Name, validator: Fn): ArcArray<E, GetValidator<ArcAbstract<[...V, {
+        name: Name;
+        validator: Fn;
+    }]>>>;
 }
 export type ArcArrayAny = ArcArray<any>;
-export declare function array<E extends ArcElement>(element: E): ArcArray<E>;
+export declare function array<E extends ArcElement>(element: E): ArcArray<E, [{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "array";
+    };
+}, {
+    name: "schema";
+    validator: (values: any[]) => false | {
+        [index: number]: ReturnType<E["validate"]>;
+    };
+}]>;
+export {};
 //# sourceMappingURL=array.d.ts.map

package/dist/elements/class.d.ts

@@ -1,25 +1,2 @@
-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>;
+export {};
 //# sourceMappingURL=class.d.ts.map