querier-ts 0.0.0 → 1.0.0

package/lib/__tests__/query.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/query.spec.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../core/errors");
+const query_1 = require("../query");
+class User {
+    constructor(id, name, permissions, isActive, createdAt, updatedAt) {
+        this.id = id;
+        this.name = name;
+        this.permissions = permissions;
+        this.isActive = isActive;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+    isAdmin() {
+        return this.id === 1;
+    }
+}
+const users = [
+    new User(1, 'John', { useCookies: true, sendNotifications: true }, true, new Date('2023-01-01'), new Date('2023-01-10')),
+    new User(2, 'Mary', { useCookies: false, sendNotifications: true }, false, new Date('2023-02-01'), new Date('2023-02-10')),
+    new User(3, 'Bob', { useCookies: true, sendNotifications: false }, true, new Date('2023-03-01'), new Date('2023-03-10')),
+];
+describe('Query', () => {
+    describe('creation', () => {
+        it('should create a query from array', () => {
+            const query = query_1.Query.from(users);
+            expect(query.all().length).toBe(3);
+        });
+    });
+    describe('where()', () => {
+        it('should filter using object conditions', () => {
+            const result = query_1.Query.from(users).where({ isActive: true }).all();
+            expect(result).toHaveLength(2);
+            expect(result.every((u) => u.isActive)).toBe(true);
+        });
+        it('should filter using function condition', () => {
+            const result = query_1.Query.from(users)
+                .where((user) => user.isAdmin())
+                .all();
+            expect(result).toHaveLength(1);
+            expect(result[0].id).toBe(1);
+        });
+        it('should combine multiple where calls', () => {
+            const result = query_1.Query.from(users)
+                .where({ isActive: true })
+                .where((user) => user.permissions.useCookies)
+                .all();
+            expect(result).toHaveLength(2);
+        });
+    });
+    describe('nested where()', () => {
+        it('should filter using inner object conditions', () => {
+            const result = query_1.Query.from(users)
+                .where({
+                permissions: {
+                    sendNotifications: true,
+                },
+            })
+                .all();
+            expect(result).toHaveLength(2);
+        });
+    });
+    describe('filterWhere()', () => {
+        it('should ignore null and undefined conditions', () => {
+            const isActive = undefined;
+            const result = query_1.Query.from(users)
+                .filterWhere({
+                isActive,
+                id: 1,
+            })
+                .all();
+            expect(result).toHaveLength(1);
+            expect(result[0].id).toBe(1);
+        });
+    });
+    describe('select()', () => {
+        it('should select a single column', () => {
+            const result = query_1.Query.from(users).select('name').column();
+            expect(result).toEqual(['John', 'Mary', 'Bob']);
+        });
+        it('should select multiple columns', () => {
+            const result = query_1.Query.from(users).select(['id', 'name']).values();
+            expect(result).toEqual([
+                [1, 'John'],
+                [2, 'Mary'],
+                [3, 'Bob'],
+            ]);
+        });
+    });
+    describe('ordering', () => {
+        it('should order by ascending property', () => {
+            const result = query_1.Query.from(users).select('name').orderBy('name').column();
+            expect(result).toEqual(['Bob', 'John', 'Mary']);
+        });
+        it('should order by descending property', () => {
+            const result = query_1.Query.from(users).select('id').orderBy('-id').column();
+            expect(result).toEqual([3, 2, 1]);
+        });
+        it('should order by multiple properties', () => {
+            const result = query_1.Query.from(users)
+                .orderBy('isActive', '-id')
+                .select('id')
+                .column();
+            expect(result).toEqual([2, 3, 1]);
+        });
+    });
+    describe('pagination', () => {
+        it('should skip rows', () => {
+            const result = query_1.Query.from(users).select('id').skip(1).column();
+            expect(result).toEqual([2, 3]);
+        });
+        it('should limit rows', () => {
+            const result = query_1.Query.from(users).select('id').limit(2).column();
+            expect(result).toEqual([1, 2]);
+        });
+        it('should combine skip and limit', () => {
+            const result = query_1.Query.from(users).select('id').skip(1).limit(1).column();
+            expect(result).toEqual([2]);
+        });
+        it('should throw if skip is negative', () => {
+            expect(() => query_1.Query.from(users).skip(-1)).toThrow(errors_1.InvalidArgumentError);
+        });
+        it('should throw if limit is not an integer', () => {
+            expect(() => query_1.Query.from(users).limit(1.5)).toThrow(errors_1.InvalidArgumentError);
+        });
+    });
+    describe('result helpers', () => {
+        it('count()', () => {
+            expect(query_1.Query.from(users).count()).toBe(3);
+        });
+        it('exists()', () => {
+            expect(query_1.Query.from(users).where({ id: 99 }).exists()).toBe(false);
+        });
+        it('first()', () => {
+            expect(query_1.Query.from(users).first()?.id).toBe(1);
+        });
+        it('last()', () => {
+            expect(query_1.Query.from(users).last()?.id).toBe(3);
+        });
+        it('scalar()', () => {
+            const id = query_1.Query.from(users).select('id').scalar();
+            expect(id).toBe(1);
+        });
+        it('scalar() should return false if no results', () => {
+            const result = query_1.Query.from(users).where({ id: 99 }).scalar();
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/core/errors/__tests__/invalid-argument-error.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/core/errors/__tests__/invalid-argument-error.spec.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const invalid_argument_error_1 = require("../invalid-argument-error");
+describe('InvalidArgumentError', () => {
+    it('should be an instance of Error', () => {
+        const error = new invalid_argument_error_1.InvalidArgumentError({
+            method: 'testMethod',
+            param: 'value',
+            argument: 123,
+            expected: 'a string',
+        });
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have the correct name', () => {
+        const error = new invalid_argument_error_1.InvalidArgumentError({
+            method: 'testMethod',
+            param: 'value',
+            argument: 123,
+            expected: 'a string',
+        });
+        expect(error.name).toBe('InvalidArgumentError');
+    });
+    it('should generate the correct error message', () => {
+        const error = new invalid_argument_error_1.InvalidArgumentError({
+            method: 'doSomething',
+            param: 0,
+            argument: false,
+            expected: 'a boolean',
+        });
+        expect(error.message).toBe('false is not a valid argument to param 0 on doSomething(). It should be a boolean.');
+    });
+    it('should expose configuration properties', () => {
+        const config = {
+            method: 'save',
+            param: 'id',
+            argument: null,
+            expected: 'a non-null value',
+        };
+        const error = new invalid_argument_error_1.InvalidArgumentError(config);
+        expect(error.method).toBe(config.method);
+        expect(error.param).toBe(config.param);
+        expect(error.argument).toBe(config.argument);
+        expect(error.expected).toBe(config.expected);
+    });
+    it('should preserve prototype chain', () => {
+        const error = new invalid_argument_error_1.InvalidArgumentError({
+            method: 'run',
+            param: 'options',
+            argument: {},
+            expected: 'a valid options object',
+        });
+        expect(error instanceof invalid_argument_error_1.InvalidArgumentError).toBe(true);
+    });
+});

package/lib/core/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './invalid-argument-error';

package/lib/core/errors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./invalid-argument-error"), exports);

package/lib/core/errors/invalid-argument-error.d.ts

@@ -0,0 +1,14 @@
+interface InvalidArgumentErrorConfig {
+    method: string;
+    param: string | number;
+    argument: unknown;
+    expected: string;
+}
+export declare class InvalidArgumentError extends Error {
+    readonly method: string;
+    readonly param: string | number;
+    readonly argument: unknown;
+    readonly expected: string;
+    constructor({ method, param, argument, expected, }: InvalidArgumentErrorConfig);
+}
+export {};

package/lib/core/errors/invalid-argument-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidArgumentError = void 0;
+class InvalidArgumentError extends Error {
+    constructor({ method, param, argument, expected, }) {
+        super(`${String(argument)} is not a valid argument to param ${param} on ${method}(). ` +
+            `It should be ${expected}.`);
+        this.name = 'InvalidArgumentError';
+        this.method = method;
+        this.param = param;
+        this.argument = argument;
+        this.expected = expected;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.InvalidArgumentError = InvalidArgumentError;

package/lib/core/types/attribute-validation-function.d.ts

@@ -0,0 +1 @@
+export type AttributeValidationFunction<T extends object, P extends keyof T = keyof T> = (value: T[P]) => boolean;

package/lib/core/types/attribute-validation-function.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/types/column-condition.d.ts

@@ -0,0 +1,6 @@
+import { AttributeValidationFunction } from './attribute-validation-function';
+import { QueryConditionsGroupNullable } from './query-conditions-group-nullable';
+/**
+ * Condition to apply to a row column.
+ */
+export type ColumnCondition<T extends object, P extends keyof T> = T[P] extends object ? QueryConditionsGroupNullable<T[P]> | undefined : T[P] | AttributeValidationFunction<T, P> | null | undefined;

package/lib/core/types/column-condition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './attribute-validation-function';
+export * from './query-conditions-group';
+export * from './query-conditions-group-nullable';
+export * from './query-row-validator-initializer';

package/lib/core/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./attribute-validation-function"), exports);
+__exportStar(require("./query-conditions-group"), exports);
+__exportStar(require("./query-conditions-group-nullable"), exports);
+__exportStar(require("./query-row-validator-initializer"), exports);

package/lib/core/types/query-conditions-group-nullable.d.ts

@@ -0,0 +1,4 @@
+import { PropertyOnly } from '../../utils/types';
+export type QueryConditionsGroupNullable<T extends object> = {
+    [P in keyof PropertyOnly<T>]?: T[P] extends object ? QueryConditionsGroupNullable<T[P]> : T[P] | ((value: T[P]) => boolean) | null;
+};

package/lib/core/types/query-conditions-group-nullable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/types/query-conditions-group.d.ts

@@ -0,0 +1,4 @@
+import { PropertyOnly } from '../../utils/types';
+export type QueryConditionsGroup<T extends object> = {
+    [P in keyof PropertyOnly<T>]?: T[P] extends object ? QueryConditionsGroup<T[P]> : T[P] | ((value: T[P]) => boolean);
+};

package/lib/core/types/query-conditions-group.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/types/query-row-validator-initializer.d.ts

@@ -0,0 +1,8 @@
+import { QueryConditionsGroupNullable } from './query-conditions-group-nullable';
+/**
+ * Validator configuration.
+ */
+export interface QueryRowValidatorInitializer<T extends object> {
+    conditionsObject: QueryConditionsGroupNullable<T>;
+    ignoreNullValues: boolean;
+}

package/lib/core/types/query-row-validator-initializer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/core/validation/__tests__/query-row-validator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/core/validation/__tests__/query-row-validator.spec.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const query_row_validator_1 = require("../query-row-validator");
+describe('QueryRowValidator', () => {
+    describe('primitive comparisons', () => {
+        it('should validate equality for primitive values', () => {
+            const row = { id: 1, name: 'Alice' };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    id: 1,
+                    name: 'Alice',
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return false when primitive values differ', () => {
+            const row = { id: 1 };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    id: 2,
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+    });
+    describe('function conditions', () => {
+        it('should validate using a function condition', () => {
+            const row = { age: 30 };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    age: (value) => value > 18,
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return false when function condition fails', () => {
+            const row = { age: 15 };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    age: (value) => value > 18,
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+    });
+    describe('array conditions', () => {
+        it('should validate arrays using strict comparison', () => {
+            const row = { tags: ['a', 'b'] };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    tags: ['a', 'b'],
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return false for arrays with different values', () => {
+            const row = { tags: ['a', 'b'] };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    tags: ['a', 'c'],
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+        it('should return false if condition is array but value is not', () => {
+            const row = { tags: 'a,b' };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    tags: ['a', 'b'],
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+    });
+    describe('object conditions (nested validation)', () => {
+        it('should validate nested objects recursively', () => {
+            const row = {
+                user: {
+                    name: 'John',
+                    age: 25,
+                },
+            };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    user: {
+                        name: 'John',
+                        age: (value) => value >= 18,
+                    },
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return false when nested validation fails', () => {
+            const row = {
+                user: {
+                    name: 'John',
+                    age: 15,
+                },
+            };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    user: {
+                        age: (value) => value >= 18,
+                    },
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+        it('should return false if condition is object but value is not', () => {
+            const row = {
+                user: 'John',
+            };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    user: { name: 'John' },
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+    });
+    describe('ignoreNullValues behavior', () => {
+        it('should ignore null conditions when ignoreNullValues is true', () => {
+            const row = { name: 'Alice' };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    name: null,
+                },
+                ignoreNullValues: true,
+            });
+            expect(result).toBe(true);
+        });
+        it('should ignore undefined conditions when ignoreNullValues is true', () => {
+            const row = { name: 'Alice' };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    name: undefined,
+                },
+                ignoreNullValues: true,
+            });
+            expect(result).toBe(true);
+        });
+        it('should NOT ignore null when ignoreNullValues is false', () => {
+            const row = { name: 'Alice' };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    name: null,
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+    });
+    describe('multiple conditions', () => {
+        it('should return true only if all conditions pass', () => {
+            const row = {
+                id: 1,
+                active: true,
+                roles: ['admin'],
+            };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    id: 1,
+                    active: true,
+                    roles: ['admin'],
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return false if at least one condition fails', () => {
+            const row = {
+                id: 1,
+                active: false,
+            };
+            const result = query_row_validator_1.QueryRowValidator.validate(row, {
+                conditionsObject: {
+                    id: 1,
+                    active: true,
+                },
+                ignoreNullValues: false,
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/core/validation/decorators/__tests__/number-validation.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/lib/core/validation/decorators/__tests__/number-validation.spec.js

@@ -0,0 +1,114 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const errors_1 = require("../../../errors");
+const number_validaton_1 = require("../number-validaton");
+class TestService {
+    sum(a, b, c) {
+        return a + b + c;
+    }
+    onlyInteger(value) {
+        return value;
+    }
+    ranged(value) {
+        return value;
+    }
+}
+__decorate([
+    number_validaton_1.validateNumbers,
+    __param(0, (0, number_validaton_1.min)(0)),
+    __param(1, (0, number_validaton_1.max)(10)),
+    __param(2, number_validaton_1.integer)
+], TestService.prototype, "sum", null);
+__decorate([
+    number_validaton_1.validateNumbers,
+    __param(0, number_validaton_1.integer)
+], TestService.prototype, "onlyInteger", null);
+__decorate([
+    number_validaton_1.validateNumbers,
+    __param(0, (0, number_validaton_1.min)(5)),
+    __param(0, (0, number_validaton_1.max)(10))
+], TestService.prototype, "ranged", null);
+describe('number decorators', () => {
+    let service;
+    beforeEach(() => {
+        service = new TestService();
+    });
+    describe('valid scenarios', () => {
+        it('should allow valid arguments', () => {
+            expect(service.sum(1, 5, 3)).toBe(9);
+        });
+        it('should allow integer values', () => {
+            expect(service.onlyInteger(10)).toBe(10);
+        });
+        it('should allow values within min/max range', () => {
+            expect(service.ranged(5)).toBe(5);
+            expect(service.ranged(10)).toBe(10);
+        });
+    });
+    describe('min decorator', () => {
+        it('should throw if value is less than min', () => {
+            expect(() => service.sum(-1, 5, 3)).toThrow(errors_1.InvalidArgumentError);
+        });
+        it('should throw with correct error message', () => {
+            try {
+                service.sum(-1, 5, 3);
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(errors_1.InvalidArgumentError);
+                expect(e.message).toContain('equal or greater than 0');
+            }
+        });
+    });
+    describe('max decorator', () => {
+        it('should throw if value is greater than max', () => {
+            expect(() => service.sum(1, 20, 3)).toThrow(errors_1.InvalidArgumentError);
+        });
+        it('should throw with correct error message', () => {
+            try {
+                service.sum(1, 20, 3);
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(errors_1.InvalidArgumentError);
+                expect(e.message).toContain('equal or less than 10');
+            }
+        });
+    });
+    describe('integer decorator', () => {
+        it('should throw if value is not an integer', () => {
+            expect(() => service.onlyInteger(1.5)).toThrow(errors_1.InvalidArgumentError);
+        });
+        it('should accept safe integers', () => {
+            expect(service.onlyInteger(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
+        });
+        it('should throw if value is NaN', () => {
+            expect(() => service.onlyInteger(NaN)).toThrow(errors_1.InvalidArgumentError);
+        });
+    });
+    describe('combined decorators', () => {
+        it('should validate min and max together', () => {
+            expect(() => service.ranged(4)).toThrow(errors_1.InvalidArgumentError);
+            expect(() => service.ranged(11)).toThrow(errors_1.InvalidArgumentError);
+        });
+        it('should pass when all constraints are satisfied', () => {
+            expect(service.ranged(7)).toBe(7);
+        });
+    });
+    describe('type validation', () => {
+        it('should throw if value is not a number for min', () => {
+            expect(() => service.sum('1', 5, 3)).toThrow(errors_1.InvalidArgumentError);
+        });
+        it('should throw if value is not a number for max', () => {
+            expect(() => service.sum(1, '5', 3)).toThrow(errors_1.InvalidArgumentError);
+        });
+    });
+});

package/lib/core/validation/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './number-validaton';