@medyll/idae-idbql 0.0.1

package/README.md

@@ -0,0 +1,58 @@
+# create-svelte
+
+Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+
+Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npm create svelte@latest
+
+# create a new project in my-app
+npm create svelte@latest my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/collection/collection.d.ts

@@ -0,0 +1,34 @@
+import { type Where, type ResultsetOptions, type ResultSet } from "@medyll/idae-query";
+export declare class CollectionCore<T = any> {
+    protected _store: string;
+    private version?;
+    private dbName;
+    private dBOpenRequest;
+    private keyPath;
+    constructor(store: string, keyPath: string, args: {
+        dbName: string;
+        version?: number;
+    });
+    get name(): string;
+    private getDatabase;
+    /** get the collection */
+    private getCollection;
+    /**
+     * Retrieves the data from the collection based on the provided query.
+     * @param qy - The query object specifying the conditions for filtering the data.
+     * @param options - The options object specifying additional operations to be applied on the result set.
+     * @returns A promise that resolves to the filtered result set.
+     * @throws If an error occurs while retrieving the data.
+     */
+    where(qy: Where<T>, options?: ResultsetOptions): Promise<ResultSet<T>>;
+    get(value: any): Promise<T>;
+    getAll(): Promise<T[]>;
+    update(keyPathValue: string | number, data: Partial<T>): Promise<unknown>;
+    updateWhere(where: Where<T>, data: Partial<T>): Promise<unknown>;
+    put(value: Partial<T>): Promise<unknown>;
+    /** ok add data to the store */
+    add(data: T): Promise<T | boolean>;
+    delete(keyPathValue: string | number): Promise<boolean>;
+    deleteWhere(where: Where<T>): Promise<boolean>;
+}
+export declare const Collection: CollectionCore;

package/dist/collection/collection.js

@@ -0,0 +1,206 @@
+/* path:  src\lib\scripts\collection\collection.ts */
+import { Query, getResultset } from "@medyll/idae-query";
+import {} from "@medyll/idae-query";
+import { idbqlEvent } from "../state/idbqlEvent.svelte.js";
+export class CollectionCore {
+    _store;
+    version;
+    dbName;
+    dBOpenRequest;
+    keyPath;
+    constructor(store, keyPath, args) {
+        this._store = store;
+        this.version = args.version;
+        this.dbName = args.dbName;
+        this.keyPath = keyPath.split(",")[0].replace(/[\s+]/g, "").replace(/&/, "");
+    }
+    get name() {
+        return this._store;
+    }
+    async getDatabase() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, this.version);
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /** get the collection */
+    async getCollection() {
+        const db = await this.getDatabase();
+        if (!db.objectStoreNames.contains(this._store)) {
+            throw new Error(`Collection ${this._store} not found`);
+        }
+        return db.transaction(this._store, "readwrite").objectStore(this._store);
+    }
+    /**
+     * Retrieves the data from the collection based on the provided query.
+     * @param qy - The query object specifying the conditions for filtering the data.
+     * @param options - The options object specifying additional operations to be applied on the result set.
+     * @returns A promise that resolves to the filtered result set.
+     * @throws If an error occurs while retrieving the data.
+     */
+    async where(qy, options) {
+        const data = await this.getAll();
+        const query = new Query(data);
+        const resultSet = getResultset(query.where(qy));
+        if (options) {
+            resultSet.setOptions(options);
+        }
+        return resultSet;
+    }
+    get(value) {
+        return new Promise(async (resolve, reject) => {
+            const storeObj = await this.getCollection();
+            const get = storeObj.get(value);
+            get.onsuccess = () => resolve(get.result);
+            get.onerror = () => reject("not found");
+        });
+    }
+    getAll() {
+        return new Promise(async (resolve, reject) => {
+            const storeObj = await this.getCollection();
+            const getAll = storeObj.getAll();
+            getAll.onsuccess = function () {
+                resolve(getAll.result);
+            };
+            getAll.onerror = function () {
+                reject("not found");
+            };
+        });
+    }
+    async update(keyPathValue, data) {
+        const dta = await this.get(keyPathValue);
+        return this.put({
+            [this.keyPath]: keyPathValue,
+            ...dta,
+            ...data,
+        });
+    }
+    async updateWhere(where, data) {
+        return this.where(where).then((rs) => {
+            return new Promise(async (resolve, reject) => {
+                Promise.all(rs.map((dta) => {
+                    if (this.keyPath && dta[this.keyPath]) {
+                        const newData = {
+                            [this.keyPath]: dta[this.keyPath],
+                            ...dta,
+                            ...data,
+                        };
+                        return this.put(newData);
+                    }
+                }))
+                    .then(() => {
+                    resolve(true);
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        });
+    }
+    // put data to indexedDB, replace collection content if present
+    async put(value) {
+        return new Promise(async (resolve, reject) => {
+            const storeObj = await this.getCollection();
+            const put = storeObj.put(value);
+            put.onsuccess = async (event) => {
+                const updatedData = await this.get(event.target.result);
+                resolve(updatedData);
+            };
+            put.onerror = function () {
+                reject("data not put");
+            };
+        });
+    }
+    /** ok add data to the store */
+    async add(data) {
+        return new Promise(async (resolve, reject) => {
+            const storeObj = await this.getCollection();
+            const add = storeObj.add(data);
+            add.onsuccess = async (event) => {
+                const updatedData = await this.get(event.target.result);
+                resolve(updatedData);
+            };
+            add.onerror = function (e) {
+                console.log(e);
+                reject(e);
+            };
+        });
+    }
+    async delete(keyPathValue) {
+        return new Promise(async (resolve, reject) => {
+            const storeObj = await this.getCollection();
+            let objectStoreRequest = storeObj.delete(keyPathValue);
+            objectStoreRequest.onsuccess = () => {
+                idbqlEvent.registerEvent("delete", {
+                    collection: this._store,
+                    data: keyPathValue,
+                    keyPath: this.keyPath,
+                });
+                resolve(true);
+            };
+            objectStoreRequest.onerror = function () {
+                reject(false);
+            };
+        });
+    }
+    async deleteWhere(where) {
+        return this.where(where).then((data) => {
+            return new Promise(async (resolve, reject) => {
+                Promise.all(data.map((data) => {
+                    if (this.keyPath && data[this.keyPath]) {
+                        return this.delete(data[this.keyPath]);
+                    }
+                }))
+                    .then(() => {
+                    resolve(true);
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        });
+    }
+}
+export const Collection = createIDBStoreProxy(CollectionCore);
+function createIDBStoreProxy(store) {
+    return new Proxy(store, {
+        construct(target, args) {
+            const instance = new target(...args);
+            return new Proxy(instance, {
+                get(target, prop, receiver) {
+                    const origMethod = target[prop];
+                    if (typeof origMethod === "function" &&
+                        [
+                            "update",
+                            "updateWhere",
+                            "put",
+                            "add",
+                            "delete",
+                            "deleteWhere",
+                        ].includes(String(prop))) {
+                        return function (...args) {
+                            return new Promise(async (resolve, reject) => {
+                                origMethod
+                                    .apply(instance, args)
+                                    .then((res) => {
+                                    idbqlEvent.registerEvent(prop, {
+                                        collection: instance._store,
+                                        data: res,
+                                        keyPath: instance.keyPath,
+                                    });
+                                    resolve(res);
+                                })
+                                    .catch((e) => {
+                                    reject(e);
+                                });
+                            }).finally(() => { });
+                            // return origMethod.apply(this, args);
+                        };
+                    }
+                    return Reflect.get(target, prop, receiver);
+                },
+            });
+        },
+    });
+}

package/dist/idbqlCore/idbqlCore.d.ts

@@ -0,0 +1,126 @@
+import { CollectionCore } from "../collection/collection.js";
+import { type StateCollectionDyn } from "../state/idbstate.svelte.js";
+export declare enum enumPrimitive {
+    id = "id",
+    any = "any",
+    date = "date",
+    text = "text",
+    number = "number",// IdbqModelCollectionTemplate
+    boolean = "boolean",
+    datetime = "datetime",
+    url = "url",
+    email = "email",
+    phone = "phone",
+    time = "time",
+    password = "password"
+}
+export declare enum TplProperties {
+    private = "private",
+    readonly = "readonly",
+    required = "required"
+}
+type CombineElements<T extends string, U extends string = T> = T extends any ? T | `${T} ${CombineElements<Exclude<U, T>>}` : never;
+type CombinedArgs = CombineElements<TplProperties>;
+type IdbObjectify<T extends string> = `array-of-${T}` | `object-${T}`;
+export type TplCollectionFields = Record<string, string>;
+export type TplFieldPrimitive<T = {}> = keyof typeof enumPrimitive | `text-${"tiny" | "short" | "medium" | "long" | "area"}` | `${string}.${string}` | `fk-${string}.${string}`;
+export type TplObjectFieldPrimitive = IdbObjectify<TplFieldPrimitive>;
+export type TplFieldFk = `fk-${string}.${string}`;
+export type TplFkObject = IdbObjectify<TplFieldFk>;
+export type TplTypes = TplFieldPrimitive | TplObjectFieldPrimitive | TplFieldFk | TplFkObject;
+export type TplFieldArgs = `${TplTypes} (${CombinedArgs})`;
+/** rules */
+export type TplFieldRules = TplFieldArgs | TplTypes;
+export type TplFieldType = TplFieldArgs | TplTypes;
+export type IDbForge = {
+    collection?: TplCollectionName;
+    fieldName?: keyof TplFields;
+    fieldType?: TplFieldType;
+    fieldRule?: TplFieldRules;
+    fieldArgs?: [keyof typeof TplProperties] | undefined;
+    is: any;
+};
+export type IdbqModel<T = Record<string, Record<string, any>>> = {
+    readonly [K in keyof T]: CollectionModel<T[K]>;
+};
+export type TplCollectionName<T = TplCollectionFields> = keyof IdbqModel<T>;
+export type Tpl<T = TplCollectionFields> = CollectionModel<T>["template"];
+export type TplFields<T = TplCollectionFields> = CollectionModel<T>["template"]["fields"];
+export type CollectionModel<T = TplCollectionFields> = {
+    keyPath: string | any;
+    /** @deprecated use ts instead */
+    model: any;
+    ts: any;
+    template: {
+        index: string;
+        presentation: CombineElements<keyof CollectionModel<T>["ts"]>;
+        fields: {
+            [K in keyof T]: TplFieldRules;
+        };
+        fks: {
+            [K in TplCollectionName]?: {
+                code: K;
+                multiple: boolean;
+                rules: CombinedArgs;
+            };
+        };
+    };
+};
+type ReadonlyCollections<T extends IdbqModel> = {
+    [K in keyof T]: CollectionCore<T[K]["ts"]>;
+};
+type StateCollections<T extends IdbqModel> = {
+    [K in keyof T]: StateCollectionDyn<T[K]["ts"]>;
+};
+/**
+ * Represents the IndexedDB wrapper for managing database operations.
+ * @template T - The type of data stored in the IndexedDB.
+ */
+export declare class IdbqlIndexedCore<T = any> {
+    #private;
+    private databaseName;
+    dbVersion: number;
+    idbDatabase: IDBDatabase;
+    /**
+     * Creates an instance of Idbq.
+     * @param {string} databaseName - The name of the database.
+     */
+    constructor(databaseName: string, idbqModel: IdbqModel, version: number);
+    get schema(): Record<string, any>;
+    get idbqModel(): IdbqModel<Record<string, Record<string, any>>>;
+    /**
+     * Sets the version of the database.
+     * @param {number} version - The version number of the database.
+     * @returns {object} - An object with a `stores` method to define the object stores.
+     */
+    stores(args: Record<string, string>): Promise<unknown>;
+    transaction<R>(storeNames: string | string[], mode: IDBTransactionMode, callback: (tx: IDBTransaction) => Promise<R>): Promise<R>;
+    private createCollections;
+}
+/**
+ * Creates an IndexedDB database store schema for the given model and version.
+ *
+ * @param model - The IdbqModel representing the structure of the store.
+ * @param version - The version number of the store.
+ * @returns A function that creates a readonly collection for the given name.
+ * The returned function returns an instance of ReadonlyCollections<T> & typeof idb_.
+ *
+ * @typeparam T - The type of data stored in the collections.
+ */
+export declare const createIdbqDb: <T extends IdbqModel>(model: T, version: number) => {
+    create: (name: string) => {
+        idbDatabase: IdbqlIndexedCore<T>;
+        idbql: ReadonlyCollections<T>;
+        idbqlState: StateCollections<T>;
+        idbqModel: T;
+    };
+};
+export declare const idbqBase: <T extends IdbqModel>(model: T, version: number) => {
+    create: (name: string) => {
+        idbDatabase: IdbqlIndexedCore<T>;
+        idbql: ReadonlyCollections<T>;
+        idbqlState: StateCollections<T>;
+        idbqModel: T;
+    };
+};
+export {};

package/dist/idbqlCore/idbqlCore.js

@@ -0,0 +1,156 @@
+/* src\lib\scripts\idbqlCore\idbqlCore.ts */
+import { Collection, CollectionCore } from "../collection/collection.js";
+import { createIdbqlState, } from "../state/idbstate.svelte.js";
+import { Schema } from "./idbqlSchema.js";
+export var enumPrimitive;
+(function (enumPrimitive) {
+    enumPrimitive["id"] = "id";
+    enumPrimitive["any"] = "any";
+    enumPrimitive["date"] = "date";
+    enumPrimitive["text"] = "text";
+    enumPrimitive["number"] = "number";
+    enumPrimitive["boolean"] = "boolean";
+    enumPrimitive["datetime"] = "datetime";
+    enumPrimitive["url"] = "url";
+    enumPrimitive["email"] = "email";
+    enumPrimitive["phone"] = "phone";
+    enumPrimitive["time"] = "time";
+    enumPrimitive["password"] = "password";
+})(enumPrimitive || (enumPrimitive = {}));
+export var TplProperties;
+(function (TplProperties) {
+    TplProperties["private"] = "private";
+    TplProperties["readonly"] = "readonly";
+    TplProperties["required"] = "required";
+})(TplProperties || (TplProperties = {}));
+const a = "object-any (readonly private)";
+/**
+ * Represents the IndexedDB wrapper for managing database operations.
+ * @template T - The type of data stored in the IndexedDB.
+ */
+export class IdbqlIndexedCore {
+    databaseName;
+    dbVersion;
+    idbDatabase;
+    #schema = {};
+    #idbqModel = {};
+    /**
+     * Creates an instance of Idbq.
+     * @param {string} databaseName - The name of the database.
+     */
+    constructor(databaseName, idbqModel, version) {
+        this.databaseName = databaseName;
+        this.#idbqModel = idbqModel;
+        this.dbVersion = version;
+        const stores = {};
+        Object.keys(idbqModel).forEach((modelName) => {
+            const modelInfo = idbqModel[modelName];
+            stores[modelName] = modelInfo.keyPath || "";
+            Object.defineProperty(this, modelName, {
+                // @ts-ignore
+                value: undefined,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        });
+        this.stores(stores);
+    }
+    get schema() {
+        return this.#schema;
+    }
+    get idbqModel() {
+        return this.#idbqModel;
+    }
+    /**
+     * Sets the version of the database.
+     * @param {number} version - The version number of the database.
+     * @returns {object} - An object with a `stores` method to define the object stores.
+     */
+    async stores(args) {
+        if (typeof indexedDB !== "undefined") {
+            return new Promise((resolve, reject) => {
+                this.#schema = args;
+                const dbConnection = indexedDB.open(this.databaseName, this.dbVersion);
+                if (dbConnection != undefined) {
+                    this.createCollections(args, this.dbVersion);
+                    dbConnection.onsuccess = (event) => {
+                        const db = event.target.result;
+                        this.idbDatabase = db;
+                    };
+                    dbConnection.onupgradeneeded = async (event) => {
+                        const db = event.target.result;
+                        if (db) {
+                            const m = new Schema();
+                            m.createSchema(db, args);
+                        }
+                        else {
+                            reject(true);
+                        }
+                    };
+                    resolve(true);
+                }
+                else {
+                    reject(true);
+                }
+            });
+        }
+    }
+    async transaction(storeNames, mode, callback) {
+        if (!this.idbDatabase) {
+            throw new Error("Database not initialized");
+        }
+        return new Promise((resolve, reject) => {
+            const tx = this.idbDatabase.transaction(storeNames, mode);
+            tx.onerror = () => reject(tx.error);
+            tx.oncomplete = () => resolve(result);
+            let result;
+            Promise.resolve(callback(tx)).then((value) => {
+                result = value;
+            }, (error) => {
+                tx.abort();
+                reject(error);
+            });
+        });
+    }
+    // @ts-ignore
+    createCollections(args, version) {
+        Object.keys(this.#schema).map(async (storeName) => {
+            Object.defineProperty(this, storeName, {
+                // @ts-ignore
+                value: new Collection(storeName, this.#schema[storeName], {
+                    dbName: this.databaseName,
+                    version, // @ts-ignore
+                }),
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        });
+    }
+}
+/**
+ * Creates an IndexedDB database store schema for the given model and version.
+ *
+ * @param model - The IdbqModel representing the structure of the store.
+ * @param version - The version number of the store.
+ * @returns A function that creates a readonly collection for the given name.
+ * The returned function returns an instance of ReadonlyCollections<T> & typeof idb_.
+ *
+ * @typeparam T - The type of data stored in the collections.
+ */
+export const createIdbqDb = (model, version) => {
+    return {
+        create: (name) => {
+            const idb_ = new IdbqlIndexedCore(name, model, version);
+            return {
+                idbDatabase: idb_,
+                idbql: idb_,
+                idbqlState: createIdbqlState(idb_).state,
+                idbqModel: model,
+            };
+        },
+    };
+};
+// main export is here ?
+export const idbqBase = createIdbqDb;

package/dist/idbqlCore/idbqlSchema.d.ts

@@ -0,0 +1,41 @@
+/**
+  src\lib\scripts\idbqlCore\idbqlSchema.ts
+ * Represents a schema for IndexedDB.
+ */
+/**
+ * Represents a schema for IndexedDB.
+ */
+export declare class Schema {
+    /**
+     * Creates an object store in the database.
+     * @param db - The IDBDatabase instance.
+     * @param storeName - The name of the object store.
+     * @param keyPath - The key path for the object store.
+     * @param autoIncrement - Indicates whether the object store should have auto-incrementing keys. Default is false.
+     * @returns The created object store or null if creation fails.
+     */
+    createStore(db: IDBDatabase, storeName: string, keyPath: string, autoIncrement?: boolean): IDBObjectStore | null;
+    /**
+     * Creates the schema in the database.
+     * @param db - The IDBDatabase instance.
+     * @param storeListFields - An object containing the store names and their field configurations.
+     * @returns A promise that resolves to an array of store names and their key paths.
+     */
+    createSchema(db: IDBDatabase, storeListFields: Record<string, string>): Promise<Array<{
+        storeName: string;
+        keyPath: string;
+    }>>;
+    /**
+     * Cleans the index name by removing special characters.
+     * @param indexName - The index name to clean.
+     * @returns The cleaned index name.
+     */
+    private cleanIndexName;
+    /**
+     * Creates an index in the object store.
+     * @param store - The IDBObjectStore instance.
+     * @param indexName - The name of the index.
+     * @param keyPath - The key path for the index.
+     */
+    private createIndexes;
+}

package/dist/idbqlCore/idbqlSchema.js

@@ -0,0 +1,78 @@
+/**
+  src\lib\scripts\idbqlCore\idbqlSchema.ts
+ * Represents a schema for IndexedDB.
+ */
+/**
+ * Represents a schema for IndexedDB.
+ */
+export class Schema {
+    /**
+     * Creates an object store in the database.
+     * @param db - The IDBDatabase instance.
+     * @param storeName - The name of the object store.
+     * @param keyPath - The key path for the object store.
+     * @param autoIncrement - Indicates whether the object store should have auto-incrementing keys. Default is false.
+     * @returns The created object store or null if creation fails.
+     */
+    createStore(db, storeName, keyPath, autoIncrement = false) {
+        try {
+            return db.createObjectStore(storeName, { keyPath, autoIncrement });
+        }
+        catch (error) {
+            console.error(`Failed to create store ${storeName}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Creates the schema in the database.
+     * @param db - The IDBDatabase instance.
+     * @param storeListFields - An object containing the store names and their field configurations.
+     * @returns A promise that resolves to an array of store names and their key paths.
+     */
+    async createSchema(db, storeListFields) {
+        const results = [];
+        for (const [storeName, storeConfig] of Object.entries(storeListFields)) {
+            const fields = storeConfig.split(",").map((field) => field.trim());
+            const incrementField = fields
+                .find((field) => field.startsWith("++"))
+                ?.replace("++", "");
+            const declaredIndex = fields
+                .find((field) => field.startsWith("&"))
+                ?.replace("&", "");
+            const keyPath = incrementField || declaredIndex || fields[0];
+            const increment = Boolean(incrementField);
+            const store = this.createStore(db, storeName, keyPath, increment);
+            if (store) {
+                for (const field of fields) {
+                    await this.createIndexes(store, field, field);
+                }
+                results.push({ storeName, keyPath });
+            }
+        }
+        return results;
+    }
+    /**
+     * Cleans the index name by removing special characters.
+     * @param indexName - The index name to clean.
+     * @returns The cleaned index name.
+     */
+    cleanIndexName(indexName) {
+        return indexName.replace(/[&+]/g, "").trim();
+    }
+    /**
+     * Creates an index in the object store.
+     * @param store - The IDBObjectStore instance.
+     * @param indexName - The name of the index.
+     * @param keyPath - The key path for the index.
+     */
+    async createIndexes(store, indexName, keyPath) {
+        try {
+            const cleanedIndexName = this.cleanIndexName(indexName);
+            const cleanedKeyPath = this.cleanIndexName(keyPath);
+            store.createIndex(cleanedIndexName, cleanedKeyPath);
+        }
+        catch (error) {
+            console.error(`Failed to create index ${indexName} for store ${store.name}:`, error);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './collection/collection.js';
+export * from './idbqlCore/idbqlCore.js';
+export * from './idbqlCore/idbqlSchema.js';
+export * from './path/pathResolver.js';
+export * from './scripts/types.js';
+export * from './state/idbqlEvent.svelte.js';
+export * from './state/idbstate.svelte.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+// Reexport of entry components
+export * from './collection/collection.js';
+export * from './idbqlCore/idbqlCore.js';
+export * from './idbqlCore/idbqlSchema.js';
+export * from './path/pathResolver.js';
+export * from './scripts/types.js';
+export * from './state/idbqlEvent.svelte.js';
+export * from './state/idbstate.svelte.js';

package/dist/path/pathResolver.d.ts

@@ -0,0 +1,14 @@
+export type DotPath<T> = T extends object ? {
+    [K in keyof T]: T[K] extends null | undefined ? K & string : `${K & string}${"" extends DotPath<T[K]> ? "" : "."}${DotPath<T[K]>}`;
+}[keyof T] : "";
+/**
+ * Resolves a dot path on an object and returns the value at that path.
+ * If the path does not exist, it returns the defaultValue.
+ *
+ * @template T - The type of the value to be returned.
+ * @param object - The object to resolve the path on.
+ * @param path - The dot path to resolve.
+ * @param defaultValue - The default value to return if the path does not exist. (optional)
+ * @returns The value at the specified path, or the defaultValue if the path does not exist.
+ */
+export declare function dotPath<T = unknown>(object: Record<string, any>, path: string, defaultValue?: any): T;

package/dist/path/pathResolver.js

@@ -0,0 +1,14 @@
+/**
+ * Resolves a dot path on an object and returns the value at that path.
+ * If the path does not exist, it returns the defaultValue.
+ *
+ * @template T - The type of the value to be returned.
+ * @param object - The object to resolve the path on.
+ * @param path - The dot path to resolve.
+ * @param defaultValue - The default value to return if the path does not exist. (optional)
+ * @returns The value at the specified path, or the defaultValue if the path does not exist.
+ */
+export function dotPath(object, path, defaultValue) {
+    return (path.split(".").reduce((r, s) => (r ? r[s] : defaultValue), object) ??
+        defaultValue);
+}

package/dist/scripts/types.d.ts

@@ -0,0 +1,22 @@
+export type Operator = keyof OperatorType;
+export type OperatorType<T = any> = {
+    eq?: T;
+    gt?: T extends number | Date ? T : never;
+    gte?: T extends number | Date ? T : never;
+    lt?: T extends number | Date ? T : never;
+    lte?: T extends number | Date ? T : never;
+    ne?: T;
+    in?: T[];
+    nin?: T[];
+    contains?: T extends string ? string : never;
+    startsWith?: T extends string ? string : never;
+    endsWith?: T extends string ? string : never;
+    btw?: T extends number ? [T, T] : never;
+};
+type WhereCondition<T> = {
+    [K in keyof T]?: T[K] | Partial<OperatorType<T[K]>>;
+};
+export type Where<T = Record<string, any>> = WhereCondition<T> | {
+    [K in keyof OperatorType]?: Partial<T>;
+};
+export {};

package/dist/scripts/types.js

@@ -0,0 +1,2 @@
+/* path: D:\boulot\app-node\idbql\src\lib\scripts\types.ts */
+export {};

package/dist/state/idbqlEvent.svelte.d.ts

@@ -0,0 +1,13 @@
+type EventType = "add" | "put" | "update" | "updateWhere" | "delete" | "deleteWhere" | "set";
+interface EventData<T = any> {
+    collection: string;
+    data: T;
+    keyPath: string;
+}
+declare class IdbqlStateEvent {
+    #private;
+    get dataState(): Record<string, any[]>;
+    registerEvent(event: EventType, eventData: EventData): void;
+}
+export declare const idbqlEvent: IdbqlStateEvent;
+export {};

package/dist/state/idbqlEvent.svelte.js

@@ -0,0 +1,63 @@
+class IdbqlStateEvent {
+    #dataState = $state({});
+    get dataState() {
+        return this.#dataState;
+    }
+    registerEvent(event, eventData) {
+        const { collection, data, keyPath } = eventData;
+        if (!collection) {
+            console.error(`Collection is mandatory`);
+            return;
+        }
+        if (!this.#dataState[collection]) {
+            this.#dataState[collection] = [];
+        }
+        switch (event) {
+            case "set":
+                if (data) {
+                    this.#dataState[collection] = Array.isArray(data) ? data : [data];
+                }
+                break;
+            case "add":
+                if (data) {
+                    this.#dataState[collection].push(data);
+                }
+                break;
+            case "put":
+            case "update":
+                if (data && keyPath) {
+                    const index = this.#dataState[collection].findIndex((item) => item[keyPath] === data[keyPath]);
+                    if (index !== -1) {
+                        this.#dataState[collection][index] = {
+                            ...this.#dataState[collection][index],
+                            ...data,
+                        };
+                    }
+                    else {
+                        this.#dataState[collection].push(data);
+                    }
+                }
+                break;
+            case "updateWhere":
+                if (data && typeof data === "object") {
+                    this.#dataState[collection] = this.#dataState[collection].map((item) => Object.entries(data).every(([key, value]) => item[key] === value)
+                        ? { ...item, ...data }
+                        : item);
+                }
+                break;
+            case "delete":
+                if (data && keyPath) {
+                    this.#dataState[collection] = this.#dataState[collection].filter((item) => item[keyPath] !== data[keyPath]);
+                }
+                break;
+            case "deleteWhere":
+                if (data && typeof data === "object") {
+                    this.#dataState[collection] = this.#dataState[collection].filter((item) => !Object.entries(data).every(([key, value]) => item[key] === value));
+                }
+                break;
+            default:
+                console.error(`Unhandled event type: ${event}`);
+        }
+    }
+}
+export const idbqlEvent = new IdbqlStateEvent();

package/dist/state/idbstate.svelte.d.ts

@@ -0,0 +1,41 @@
+import type { IdbqlIndexedCore } from "../idbqlCore/idbqlCore.js";
+import { type Where, type ResultSet, type ResultsetOptions } from "@medyll/idae-query";
+/**
+ * Main entry point.
+ * Creates a state object with indexedDB synchronization.
+ * @param {IdbqlIndexedCore} [idbBase] - The IdbqlCore instance.
+ * @returns {object} - The state object.
+ */
+export declare const createIdbqlState: (idbBase: IdbqlIndexedCore) => {
+    readonly state: Record<string, any>;
+    onCollection: <T>(collectionName: string) => StateCollectionDyn<T>;
+    addCollection: <T>(collectionName: string) => StateCollectionDyn<T>;
+};
+/**
+ * Adds a collection to the svelte 5 state and synchronize with indexedDB if it exists.
+ * @template T - The type of data in the collection.
+ * @param {string} collectionName - The name of the collection.
+ * @param {string} [keyPath="id"] - The key path for the collection.
+ * @returns {Proxy} - A proxy object with methods to interact with the collection.
+ */
+export declare class StateCollectionDyn<T> {
+    private collectionName;
+    private state;
+    private idbBase;
+    constructor(collectionName: string, idbBase: IdbqlIndexedCore);
+    get collectionState(): any;
+    private testIdbql;
+    private feed;
+    where(qy: Where<T>, options?: ResultsetOptions): ResultSet<T>;
+    update(keyPathValue: string | number, data: Partial<T>): void;
+    get(value: any, pathKey?: string): T[];
+    getOne(value: any, pathKey?: string): T;
+    getAll(): ResultSet<T>;
+    updateWhere(where: Where<T>, data: Partial<T>): void;
+    put(value: Partial<T>): void;
+    add(data: T): void;
+    delete(keyPathValue: string | number): boolean | undefined;
+    /** @deprecated */
+    del(keyPathValue: string | number): boolean | undefined;
+    deleteWhere(where: Where<T>): boolean | undefined;
+}

package/dist/state/idbstate.svelte.js

@@ -0,0 +1,124 @@
+import { idbqlEvent } from "./idbqlEvent.svelte.js";
+//
+import { Operators, getResultset, } from "@medyll/idae-query";
+//
+/**
+ * Main entry point.
+ * Creates a state object with indexedDB synchronization.
+ * @param {IdbqlIndexedCore} [idbBase] - The IdbqlCore instance.
+ * @returns {object} - The state object.
+ */
+export const createIdbqlState = (idbBase) => {
+    let collections = {};
+    if (idbBase.schema) {
+        addCollections(idbBase.schema);
+    }
+    /**
+     * Adds a collection to the svelte 5 state and synchronize with indexedDB if it exists.
+     * @template T - The type of data in the collection.
+     * @param {string} collectionName - The name of the collection.
+     * @param {string} [keyPath="id"] - The key path for the collection.
+     * @returns {Proxy} - A proxy object with methods to interact with the collection.
+     */
+    function addCollection(collectionName) {
+        return new StateCollectionDyn(collectionName, idbBase);
+    }
+    function addCollections(args) {
+        Object.keys(args).map((collection) => {
+            const t = args[collection];
+            collections[collection] = addCollection(collection);
+        });
+    }
+    return {
+        get state() {
+            return collections;
+        },
+        onCollection: addCollection,
+        addCollection: addCollection,
+    };
+};
+/**
+ * Adds a collection to the svelte 5 state and synchronize with indexedDB if it exists.
+ * @template T - The type of data in the collection.
+ * @param {string} collectionName - The name of the collection.
+ * @param {string} [keyPath="id"] - The key path for the collection.
+ * @returns {Proxy} - A proxy object with methods to interact with the collection.
+ */
+export class StateCollectionDyn {
+    collectionName;
+    state = idbqlEvent.dataState; // svelte state ;)
+    idbBase;
+    constructor(collectionName, idbBase) {
+        if (!this.state?.[collectionName])
+            this.state[collectionName] = [];
+        this.collectionName = collectionName;
+        this.idbBase = idbBase;
+        this.feed();
+        return this;
+    }
+    get collectionState() {
+        return this.state[this.collectionName];
+    }
+    testIdbql(collection) {
+        return this.idbBase && Boolean(this.idbBase?.[collection]);
+    }
+    feed() {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            this.idbBase[this.collectionName].getAll().then((data) => {
+                this.state[this.collectionName] = data;
+            });
+        }
+    }
+    where(qy, options) {
+        let c = Operators.parse(this.collectionState ?? [], qy);
+        const r = getResultset(c);
+        if (options)
+            r.setOptions(options);
+        return r;
+    }
+    update(keyPathValue, data) {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            this.idbBase[this.collectionName].update(keyPathValue, data);
+        }
+    }
+    get(value, pathKey = "id") {
+        return this.collectionState.filter((d) => d[pathKey] === value);
+    }
+    getOne(value, pathKey = "id") {
+        return this.collectionState.filter((d) => d[pathKey] === value)?.[0];
+    }
+    getAll() {
+        return getResultset(this.collectionState);
+    }
+    updateWhere(where, data) {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            this.idbBase[this.collectionName].updateWhere(where, data);
+        }
+    }
+    put(value) {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            this.idbBase[this.collectionName].put(value);
+        }
+    }
+    add(data) {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            this.idbBase[this.collectionName].add(data);
+        }
+    }
+    delete(keyPathValue) {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            return this.idbBase[this.collectionName].delete(keyPathValue);
+        }
+    }
+    /** @deprecated */
+    del(keyPathValue) {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            return this.idbBase[this.collectionName].delete(keyPathValue);
+        }
+    }
+    deleteWhere(where) {
+        if (this.idbBase && this.testIdbql(this.collectionName)) {
+            return this.idbBase[this.collectionName].deleteWhere(where);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "@medyll/idae-idbql",
+	"scope": "@medyll",
+	"version": "0.0.1",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run package",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"prepublishOnly": "npm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"peerDependencies": {
+		"svelte": "^5.0.0-next.0"
+	},
+	"devDependencies": {
+		"@sveltejs/adapter-auto": "^3.0.0",
+		"@sveltejs/kit": "^2.0.0",
+		"@sveltejs/package": "^2.0.0",
+		"@sveltejs/vite-plugin-svelte": "^3.0.0",
+		"publint": "^0.1.9",
+		"svelte": "^5.0.0-next.181",
+		"svelte-check": "^3.6.0",
+		"tslib": "^2.4.1",
+		"typescript": "^5.0.0",
+		"vite": "^5.0.11"
+	},
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"dependencies": {
+		"@medyll/idae-query": "^0.0.1"
+	}
+}