@medyll/idae-query 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/index.d.ts

@@ -0,0 +1,5 @@
+export * from './operators/operators.js';
+export * from './path/pathResolver.js';
+export * from './query/query.js';
+export * from './resultset/resultset.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+// Reexport of entry components
+export * from './operators/operators.js';
+export * from './path/pathResolver.js';
+export * from './query/query.js';
+export * from './resultset/resultset.js';
+export * from './types.js';

package/dist/operators/operators.d.ts

@@ -0,0 +1,8 @@
+import { type Operator, type OperatorType, type Where } from '../types.js';
+export declare class Operators {
+    #private;
+    static operators: (keyof OperatorType)[];
+    static parse<T extends object>(data: T[], qy: Where<T>): T[];
+    static filters<F extends object>(fieldName: keyof F | Operator, operator: keyof OperatorType, value: OperatorType[typeof operator], data: F[]): F[];
+    static addCustomOperator(operatorName: string, operatorFunction: <T extends object>(fieldName: keyof T, value: any, data: T) => boolean): void;
+}

package/dist/operators/operators.js

@@ -0,0 +1,161 @@
+/* D:\boulot\app-node\idbql\src\lib\scripts\operators\operators.ts */
+import {} from '../types.js';
+export class Operators {
+    static operators = [
+        'eq',
+        'gt',
+        'gte',
+        'lt',
+        'lte',
+        'ne',
+        'in',
+        'nin',
+        'contains',
+        'startsWith',
+        'endsWith',
+        'btw'
+    ];
+    static #operatorsFunctions = {
+        eq: this.#equalityComparison,
+        gt: this.#greaterThanComparison,
+        gte: this.#greaterThanOrEqualComparison,
+        in: this.#inclusionComparison,
+        nin: this.#exclusionComparison,
+        lt: this.#lessThanComparison,
+        lte: this.#lessThanOrEqualComparison,
+        ne: this.#notEqualComparison,
+        contains: this.#containsComparison,
+        startsWith: this.#startsWithComparison,
+        endsWith: this.#endsWithComparison,
+        btw: this.#betweenComparison
+    };
+    static parse(data, qy) {
+        return data.filter((dt) => {
+            for (const fieldName in qy) {
+                const query = qy[fieldName];
+                if (typeof query === 'object' &&
+                    Operators.operators.includes(Object.keys(query)[0])) {
+                    for (const key in query) {
+                        if (Operators.operators.includes(key)) {
+                            const operator = key;
+                            let value = query[key];
+                            // Convertir en Set pour 'in' et 'nin'
+                            if (operator === 'in' || operator === 'nin') {
+                                value = new Set(value);
+                            }
+                            return this.#operatorsFunctions[operator](fieldName, value, dt);
+                        }
+                    }
+                }
+                else {
+                    return dt[fieldName] == query;
+                }
+            }
+        });
+    }
+    static filters(fieldName, operator, value, data) {
+        // Utilisation de Set pour 'in' et 'nin'
+        if (operator === 'in' || operator === 'nin') {
+            value = new Set(value);
+        }
+        // Gestion des cas où fieldName est un opérateur (pour les nouvelles formes de requête)
+        if (this.operators.includes(fieldName)) {
+            return data.filter((item) => this.#applyOperatorToObject(fieldName, value, item));
+        }
+        return data.filter((dta) => this.#operatorsFunctions[operator](fieldName, value, dta));
+    }
+    static #applyOperatorToObject(operator, conditions, item) {
+        for (const field in conditions) {
+            if (!this.#operatorsFunctions[operator](field, conditions[field], item)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static #equalityComparison(fieldName, value, data) {
+        if (!(fieldName in data)) {
+            console.warn(`Field "${String(fieldName)}" not found in data`);
+            return false;
+        }
+        const dataValue = data[fieldName];
+        if (typeof dataValue === 'string' && typeof value === 'string') {
+            const valueStr = value.toString();
+            const startsWith = valueStr.startsWith('*');
+            const endsWith = valueStr.endsWith('*');
+            if (startsWith && endsWith) {
+                return dataValue.includes(valueStr.slice(1, -1));
+            }
+            else if (startsWith) {
+                return dataValue.endsWith(valueStr.slice(1));
+            }
+            else if (endsWith) {
+                return dataValue.startsWith(valueStr.slice(0, -1));
+            }
+        }
+        return dataValue === value;
+    }
+    static addCustomOperator(operatorName, operatorFunction) {
+        if (this.operators.includes(operatorName)) {
+            console.warn(`Operator "${operatorName}" already exists. It will be overwritten.`);
+        }
+        this.operators.push(operatorName);
+        this.#operatorsFunctions[operatorName] = operatorFunction;
+    }
+    static #greaterThanComparison(fieldName, value, data) {
+        return value < data[fieldName];
+    }
+    static #greaterThanOrEqualComparison(fieldName, value, data) {
+        return value <= data[fieldName];
+    }
+    /**
+     * Checks if the field value is in the given set.
+     * @param fieldName - The name of the field to check
+     * @param value - A Set of values to check against
+     * @param data - The object containing the field
+     * @returns {boolean} - True if the field value is in the set, false otherwise
+     */
+    static #inclusionComparison(fieldName, value, data) {
+        return value.has(data[fieldName]);
+    }
+    /**
+     * Checks if the field value is not in the given set.
+     * @param fieldName - The name of the field to check
+     * @param value - A Set of values to check against
+     * @param data - The object containing the field
+     * @returns {boolean} - True if the field value is not in the set, false otherwise
+     */
+    static #exclusionComparison(fieldName, value, data) {
+        return !value.has(data[fieldName]);
+    }
+    static #lessThanComparison(fieldName, value, data) {
+        return value > data[fieldName];
+    }
+    static #lessThanOrEqualComparison(fieldName, value, data) {
+        return value >= data[fieldName];
+    }
+    static #notEqualComparison(fieldName, value, data) {
+        return value !== data[fieldName];
+    }
+    static #containsComparison(fieldName, value, data) {
+        return `${data[fieldName]}`.includes(value);
+    }
+    static #startsWithComparison(fieldName, value, data) {
+        return `${data[fieldName]}`.startsWith(value);
+    }
+    static #endsWithComparison(fieldName, value, data) {
+        return `${data[fieldName]}`.endsWith(value);
+    }
+    static #betweenComparison(fieldName, value, data) {
+        if (!(fieldName in data)) {
+            console.warn(`Field "${String(fieldName)}" not found in data`);
+            return false;
+        }
+        const fieldValue = data[fieldName];
+        if (typeof fieldValue !== 'number') {
+            console.warn(`Field "${String(fieldName)}" is not a number`);
+            return false;
+        }
+        const [min, max] = value;
+        return fieldValue >= min && fieldValue <= max;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { Where } from '../types.js';
+export declare class Query<T extends object> {
+    data: T[];
+    constructor(data: T[]);
+    where(qy: Where<T>): import("../resultset/resultset.js").ResultSet<T>;
+    private matchesQuery;
+    private matchesField;
+}

package/dist/query/query.js

@@ -0,0 +1,33 @@
+/* src\lib\scripts\query\query.ts */
+import { Operators } from '../operators/operators.js';
+import { getResultset } from '../resultset/resultset.js';
+export class Query {
+    data;
+    constructor(data) {
+        this.data = data;
+        getResultset(this.data ?? []);
+    }
+    where(qy) {
+        this.data = this.data.filter((item) => this.matchesQuery(item, qy));
+        return getResultset(this.data);
+    }
+    matchesQuery(item, query) {
+        if (typeof query !== 'object' || query === null) {
+            return false;
+        }
+        return Object.entries(query).every(([key, value]) => {
+            if (Operators.operators.includes(key)) {
+                return Operators.filters(key, 'eq', value, [item]).length > 0;
+            }
+            else {
+                return this.matchesField(item, key, value);
+            }
+        });
+    }
+    matchesField(item, field, condition) {
+        if (typeof condition === 'object' && condition !== null && !Array.isArray(condition)) {
+            return Object.entries(condition).every(([op, val]) => Operators.filters(field, op, val, [item]).length > 0);
+        }
+        return Operators.filters(field, 'eq', condition, [item]).length > 0;
+    }
+}

package/dist/resultset/Readme.md

@@ -0,0 +1,39 @@
+## ResultSet.ts
+
+This class `ResultSet` is used to manipulate and iterate over a set of data. The class is iterable, meaning it can be spread into an array or iterated over with a `for...of` loop.
+
+### Methods
+
+ 
+
+#### setOptions<T>(options: OptionsType)
+
+- Action: Sets the options for the result set in one pass.
+- Arguments: An `OptionsType` object which can contain `sort`, `page`, and `groupBy` properties.
+  - `sort`: An object where the keys represent the properties to sort by, and the values represent the sort order ("asc" for ascending, "desc" for descending).
+  - `page`: An object with `size` and `number` properties, representing the number of items per page and the page number to retrieve, respectively.
+  - `groupBy`: A string or an array of strings, representing the field names to group by.
+- Return: The updated result set.
+
+
+#### sortBy(args: Record<string, "asc" | "desc">)
+
+- Action: Sorts the data in the result set based on the provided sorting criteria.
+- Arguments: An object where the keys represent the properties to sort by, and the values represent the sort order ("asc" for ascending, "desc" for descending).
+- Return: The sorted result set.
+
+#### getPage(size: number, page: number)
+
+- Action: Retrieves a specific page of data from the result set.
+- Arguments: The `size` parameter specifies the number of items per page, and the `page` parameter specifies the page number to retrieve.
+- Return: A new result set containing the specified page of data.
+
+#### groupBy(fieldName: string | string[], transform?: (value: any) => void)
+
+- Action: Groups the result set by the specified field name(s).
+- Arguments: The `fieldName` parameter can be a string or an array of strings, representing the field names to group by. The `transform` parameter is an optional transformation function to apply to each grouped value.
+- Return: An object representing the grouped result set.
+
+### Iterability
+
+The `ResultSet` class is iterable, meaning it can be spread into an array or iterated over with a `for...of` loop. This is achieved by implementing the `[Symbol.iterator]` method.

package/dist/resultset/resultset.d.ts

@@ -0,0 +1,35 @@
+import { type DotPath } from "../path/pathResolver.js";
+/**
+ * Represents the options for a result set.
+ * @template T - The type of the result set.
+ */
+export type ResultsetOptions<T = any> = {
+    /** Can receive a dot path for sorting. */
+    sort?: Record<DotPath<T>, "asc" | "desc">;
+    /** Specifies the property to group the result set by. */
+    groupBy?: DotPath<T>;
+    /** Specifies the page size of the result set. */
+    pageSize?: number;
+};
+/**
+ * Represents a chainable and iterable result set of data.
+ * @template T The type of data in the result set.
+ */
+export type ResultSet<T> = T[] & {
+    setOptions: (options: ResultsetOptions) => ResultSet<T>;
+    /** Accepts a dot path */
+    sortBy: (args: Record<string, "asc" | "desc">) => ResultSet<T>;
+    /** Accepts a dot path as fieldName */
+    groupBy: (fieldName: string | string[], 
+    /** Transformer function to generate the grouped key */
+    transform?: (value: any) => void) => Record<string, T[]>;
+    getPage: (page: number, size: number) => ResultSet<T>;
+    toObject: (dotPath: DotPath<T>) => T[];
+};
+/**
+ * Generates a ResultSet based on the provided data array and defines additional properties like setOptions, sortBy, groupBy, and getPage for customization and manipulation.
+ *
+ * @param {T[]} data - The array of data to generate the ResultSet from.
+ * @return {ResultSet<T>} The generated ResultSet with additional properties for customization.
+ */
+export declare function getResultset<T = (typeof arguments)[0]>(data: T[]): ResultSet<T>;

package/dist/resultset/resultset.js

@@ -0,0 +1,76 @@
+import { dotPath } from "../path/pathResolver.js";
+/**
+ * Generates a ResultSet based on the provided data array and defines additional properties like setOptions, sortBy, groupBy, and getPage for customization and manipulation.
+ *
+ * @param {T[]} data - The array of data to generate the ResultSet from.
+ * @return {ResultSet<T>} The generated ResultSet with additional properties for customization.
+ */
+export function getResultset(data) {
+    // : ResultSet<T>
+    Object.defineProperties(data, {
+        setOptions: {
+            value: function (options = {}) {
+                if (options.sort) {
+                    this.sortBy(options.sort);
+                }
+                if (options.groupBy) {
+                    this.groupBy(options.groupBy);
+                }
+                return this;
+            },
+            enumerable: false,
+            configurable: true,
+        },
+        sortBy: {
+            value: function (args) {
+                const keys = Object.keys(args);
+                const values = Object.values(args);
+                this.sort((a, b) => {
+                    let i = 0;
+                    let result = 0;
+                    while (i < keys.length && result === 0) {
+                        let value = keys[i];
+                        result =
+                            values[i] === "asc"
+                                ? Number(dotPath(a, value)) - Number(dotPath(b, value))
+                                : Number(dotPath(b, value)) - Number(dotPath(a, value));
+                        i++;
+                    }
+                    return result;
+                });
+                // delete this?.sortBy;
+                return this;
+            },
+            enumerable: false,
+            configurable: true,
+        },
+        groupBy: {
+            value: function (fieldName, transform) {
+                const finalFieldName = typeof fieldName === "string" ? [fieldName] : fieldName;
+                return this.reduce((acc, curr) => {
+                    let key = "";
+                    for (let i = 0; i < finalFieldName.length; i++) {
+                        key += dotPath(curr, finalFieldName[i]);
+                    }
+                    if (!acc[key]) {
+                        acc[key] = [];
+                    }
+                    acc[key].push(curr);
+                    return acc;
+                }, {});
+            },
+            enumerable: false,
+            configurable: true,
+        },
+        getPage: {
+            value: function (page, size) {
+                const dta = this.slice((size - 1) * page, (size - 1) * page + page);
+                delete this?.getPage;
+                return dta;
+            },
+            enumerable: false,
+            configurable: true,
+        },
+    });
+    return data;
+}

package/dist/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/types.js

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

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@medyll/idae-query",
+	"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",
+		"test": "vitest",
+		"lint": "prettier --check . && eslint .",
+		"format": "prettier --write ."
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"peerDependencies": {
+		"svelte": "^4.0.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",
+		"@types/eslint": "^8.56.7",
+		"eslint": "^9.0.0",
+		"eslint-config-prettier": "^9.1.0",
+		"eslint-plugin-svelte": "^2.36.0",
+		"globals": "^15.0.0",
+		"prettier": "^3.1.1",
+		"prettier-plugin-svelte": "^3.1.2",
+		"publint": "^0.1.9",
+		"svelte": "^5.0.0-next.181",
+		"svelte-check": "^3.6.0",
+		"tslib": "^2.4.1",
+		"typescript": "^5.0.0",
+		"typescript-eslint": "^8.0.0-alpha.20",
+		"vite": "^5.0.11",
+		"vitest": "^1.2.0"
+	},
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module"
+}