@routier/core 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/schema/property/types/SchemaObject.ts

@@ -1,44 +0,0 @@
-import { DefaultValue, SchemaModifiers, SchemaTypes } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "../modifiers/SchemaDefault";
-import { SchemaFrom } from "../modifiers/SchemaFrom";
-import { SchemaIdentity } from "../modifiers/SchemaIdentity";
-import { SchemaNullable } from "../modifiers/SchemaNullable";
-import { SchemaOptional } from "../modifiers/SchemaOptional";
-import { SchemaArray } from "./SchemaArray";
-
-export class SchemaObject<T extends {}, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    type = SchemaTypes.Object;
-    private _schemaObject = true;
-
-    constructor(schema: T) {
-        super();
-        this.instance = schema;
-    }
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    identity() {
-        return new SchemaIdentity<T, TModifiers | "identity" | "readonly">(this);
-    }
-
-    array() {
-        return new SchemaArray<typeof this, TModifiers>(this as any);
-    }
-}

package/src/schema/property/types/SchemaString.ts

@@ -1,69 +0,0 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
-import { SchemaBase } from "../base/SchemaBase";
-import { SchemaDefault } from "../modifiers/SchemaDefault";
-import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
-import { SchemaDistinct } from "../modifiers/SchemaDistinct";
-import { SchemaFrom } from "../modifiers/SchemaFrom";
-import { SchemaIdentity } from "../modifiers/SchemaIdentity";
-import { SchemaIndex } from "../modifiers/SchemaIndex";
-import { SchemaKey } from "../modifiers/SchemaKey";
-import { SchemaNullable } from "../modifiers/SchemaNullable";
-import { SchemaOptional } from "../modifiers/SchemaOptional";
-import { SchemaReadonly } from "../modifiers/SchemaReadonly";
-import { SchemaSerialize } from "../modifiers/SchemaSerialize";
-import { SchemaArray } from "./SchemaArray";
-
-export class SchemaString<T extends string, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
-
-    instance: T;
-    type = SchemaTypes.String;
-    private _schemaString = true;
-
-    from(propertyName: string) {
-        return new SchemaFrom<T, TModifiers>(propertyName, this);
-    }
-
-    optional() {
-        return new SchemaOptional<T, TModifiers | "optional">(this);
-    }
-
-    nullable() {
-        return new SchemaNullable<T, TModifiers | "nullable">(this);
-    }
-
-    key() {
-        return new SchemaKey<T, TModifiers | "key">(this);
-    }
-
-    default<I = never>(value: DefaultValue<T, I>, injected?: I) {
-        return new SchemaDefault<T, I, TModifiers | "default">(value, injected, this);
-    }
-
-    readonly() {
-        return new SchemaReadonly<T, TModifiers | "readonly">(this);
-    }
-
-    deserialize(deserializer: PropertyDeserializer<T>) {
-        return new SchemaDeserialize<T, TModifiers | "deserialize">(deserializer, this);
-    }
-
-    serialize(serializer: PropertySerializer<T>) {
-        return new SchemaSerialize<T, TModifiers | "serialize">(serializer, this);
-    }
-
-    identity() {
-        return new SchemaIdentity<T, TModifiers | "identity" | "readonly">(this);
-    }
-
-    array() {
-        return new SchemaArray<typeof this, TModifiers>(this as any);
-    }
-
-    index(...indexes: string[]) {
-        return new SchemaIndex<T, TModifiers>(this as any, ...indexes);
-    }
-
-    distinct() {
-        return new SchemaDistinct<T, TModifiers | "distinct">(this);
-    }
-}

package/src/schema/table/SchemaComputed.ts

@@ -1,20 +0,0 @@
-import { SchemaBase } from "../property/base/SchemaBase";
-import { SchemaTracked } from '../property/modifiers/SchemaTracked';
-import { SchemaModifiers, SchemaTypes } from "../types";
-
-export class SchemaComputed<T extends any, I, TModifiers extends SchemaModifiers = "computed"> extends SchemaBase<T, TModifiers> {
-    instance: T;
-    type = SchemaTypes.Computed;
-    private _schemaComputed = true;
-
-    constructor(fn: T, injected: I, current?: SchemaBase<T, TModifiers>) {
-        super(current);
-        this.injected = injected;
-        this.isUnmapped = true;
-        this.functionBody = fn as any;
-    }
-
-    tracked() {
-        return new SchemaTracked<T, TModifiers>(this);
-    }
-}

package/src/schema/table/SchemaFunction.ts

@@ -1,15 +0,0 @@
-import { SchemaBase } from "../property/base/SchemaBase";
-import { SchemaModifiers, SchemaTypes } from "../types";
-
-export class SchemaFunction<T extends any, I, TModifiers extends SchemaModifiers = "unmapped"> extends SchemaBase<() => T, TModifiers> {
-    instance: () => T;
-    type = SchemaTypes.Function;
-    private _schemaFunction = true;
-
-    constructor(fn: (injected: I) => T, injected: I, current?: SchemaBase<() => T, TModifiers>) {
-        super(current);
-        this.injected = injected;
-        this.isUnmapped = true;
-        this.functionBody = fn as any;
-    }
-}

package/src/utilities/arrays.test.ts

@@ -1,312 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toMap } from './arrays';
-
-interface TestUser {
-    id: number;
-    name: string;
-    email: string;
-    age: number;
-    isActive: boolean;
-}
-
-interface TestProduct {
-    sku: string;
-    name: string;
-    price: number;
-    category: string;
-}
-
-describe('toMap', () => {
-    describe('basic functionality', () => {
-        it('should convert array to map using string key', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false },
-                { id: 3, name: 'Charlie', email: 'charlie@example.com', age: 35, isActive: true }
-            ];
-
-            const result = toMap(users, (user) => user.name);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(3);
-            expect(result.get('Alice')).toEqual(users[0]);
-            expect(result.get('Bob')).toEqual(users[1]);
-            expect(result.get('Charlie')).toEqual(users[2]);
-        });
-
-        it('should convert array to map using number key', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false },
-                { id: 3, name: 'Charlie', email: 'charlie@example.com', age: 35, isActive: true }
-            ];
-
-            const result = toMap(users, (user) => user.id);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(3);
-            expect(result.get(1)).toEqual(users[0]);
-            expect(result.get(2)).toEqual(users[1]);
-            expect(result.get(3)).toEqual(users[2]);
-        });
-
-        it('should convert array to map using boolean key', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false },
-                { id: 3, name: 'Charlie', email: 'charlie@example.com', age: 35, isActive: true }
-            ];
-
-            const result = toMap(users, (user) => user.isActive);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(2); // Only 2 unique boolean values
-            expect(result.get(true)).toEqual(users[2]); // Last one wins for duplicate keys
-            expect(result.get(false)).toEqual(users[1]);
-        });
-    });
-
-    describe('edge cases', () => {
-        it('should handle empty array', () => {
-            const result = toMap([], (item: any) => item.id);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(0);
-        });
-
-        it('should handle single item array', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true }
-            ];
-
-            const result = toMap(users, (user) => user.name);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(1);
-            expect(result.get('Alice')).toEqual(users[0]);
-        });
-
-        it('should handle duplicate keys (last item wins)', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Alice', email: 'alice2@example.com', age: 30, isActive: false },
-                { id: 3, name: 'Bob', email: 'bob@example.com', age: 35, isActive: true }
-            ];
-
-            const result = toMap(users, (user) => user.name);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(2); // Only 2 unique names
-            expect(result.get('Alice')).toEqual(users[1]); // Last Alice wins
-            expect(result.get('Bob')).toEqual(users[2]);
-        });
-
-        it('should handle null and undefined values in key selector', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false }
-            ];
-
-            // Test with key selector that could return null/undefined
-            const result = toMap(users, (user) => user.age > 30 ? 'old' : 'young');
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(1); // Both users are 'young' (age <= 30)
-            expect(result.get('young')).toEqual(users[1]); // Last 'young' user wins
-        });
-    });
-
-    describe('complex key selectors', () => {
-        it('should handle computed keys', () => {
-            const products: TestProduct[] = [
-                { sku: 'ABC123', name: 'Laptop', price: 999, category: 'Electronics' },
-                { sku: 'DEF456', name: 'Mouse', price: 25, category: 'Electronics' },
-                { sku: 'GHI789', name: 'Book', price: 15, category: 'Books' }
-            ];
-
-            const result = toMap(products, (product) => `${product.category}-${product.sku}`);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(3);
-            expect(result.get('Electronics-ABC123')).toEqual(products[0]);
-            expect(result.get('Electronics-DEF456')).toEqual(products[1]);
-            expect(result.get('Books-GHI789')).toEqual(products[2]);
-        });
-
-        it('should handle conditional key selection', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false },
-                { id: 3, name: 'Charlie', email: 'charlie@example.com', age: 35, isActive: true }
-            ];
-
-            const result = toMap(users, (user) => user.isActive ? `active-${user.id}` : `inactive-${user.id}`);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(3);
-            expect(result.get('active-1')).toEqual(users[0]);
-            expect(result.get('inactive-2')).toEqual(users[1]);
-            expect(result.get('active-3')).toEqual(users[2]);
-        });
-
-        it('should handle nested property access', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false }
-            ];
-
-            // Simulate nested object access
-            const result = toMap(users, (user) => user.email.split('@')[0]);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(2);
-            expect(result.get('alice')).toEqual(users[0]);
-            expect(result.get('bob')).toEqual(users[1]);
-        });
-    });
-
-    describe('type safety', () => {
-        it('should maintain type safety with different key types', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true }
-            ];
-
-            // String key
-            const stringMap = toMap(users, (user) => user.name);
-            expect(stringMap.get('Alice')).toBeDefined();
-
-            // Number key
-            const numberMap = toMap(users, (user) => user.id);
-            expect(numberMap.get(1)).toBeDefined();
-
-            // Boolean key
-            const booleanMap = toMap(users, (user) => user.isActive);
-            expect(booleanMap.get(true)).toBeDefined();
-        });
-
-        it('should handle mixed key types in same function', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false }
-            ];
-
-            const result = toMap(users, (user) => user.isActive ? user.id : user.name);
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(2);
-            expect(result.get(1)).toEqual(users[0]);
-            expect(result.get('Bob')).toEqual(users[1]);
-        });
-    });
-
-    describe('performance characteristics', () => {
-        it('should handle large arrays efficiently', () => {
-            const largeArray = Array.from({ length: 10000 }, (_, i) => ({
-                id: i,
-                name: `User${i}`,
-                email: `user${i}@example.com`,
-                age: 20 + (i % 50),
-                isActive: i % 2 === 0
-            }));
-
-            const start = performance.now();
-            const result = toMap(largeArray, (user) => user.id);
-            const end = performance.now();
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBe(10000);
-            expect(result.get(0)).toEqual(largeArray[0]);
-            expect(result.get(9999)).toEqual(largeArray[9999]);
-            expect(end - start).toBeLessThan(100); // Should complete in under 100ms
-        });
-
-        it('should handle many duplicate keys efficiently', () => {
-            const arrayWithDuplicates = Array.from({ length: 1000 }, (_, i) => ({
-                id: i,
-                name: i % 10 === 0 ? 'Alice' : `User${i}`,
-                email: `user${i}@example.com`,
-                age: 20 + (i % 50),
-                isActive: i % 2 === 0
-            }));
-
-            const start = performance.now();
-            const result = toMap(arrayWithDuplicates, (user) => user.name);
-            const end = performance.now();
-
-            expect(result).toBeInstanceOf(Map);
-            expect(result.size).toBeLessThan(1000); // Fewer unique keys due to duplicates
-            expect(result.get('Alice')).toBeDefined(); // Last Alice should be in map
-            expect(end - start).toBeLessThan(50); // Should complete in under 50ms
-        });
-    });
-
-    describe('error handling', () => {
-        it('should handle key selector that throws error', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false }
-            ];
-
-            expect(() => {
-                toMap(users, (user) => {
-                    if (user.id === 1) {
-                        throw new Error('Test error');
-                    }
-                    return user.name;
-                });
-            }).toThrow('Test error');
-        });
-
-        it('should handle null/undefined in input array', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                null as any,
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false }
-            ];
-
-            expect(() => {
-                toMap(users, (user) => user.name);
-            }).toThrow(); // Should throw when trying to access .name on null
-        });
-    });
-
-    describe('real-world scenarios', () => {
-        it('should work with user management system', () => {
-            const users: TestUser[] = [
-                { id: 1, name: 'Alice', email: 'alice@example.com', age: 25, isActive: true },
-                { id: 2, name: 'Bob', email: 'bob@example.com', age: 30, isActive: false },
-                { id: 3, name: 'Charlie', email: 'charlie@example.com', age: 35, isActive: true }
-            ];
-
-            // Create maps for different lookup scenarios
-            const idMap = toMap(users, (user) => user.id);
-            const emailMap = toMap(users, (user) => user.email);
-            const activeStatusMap = toMap(users, (user) => user.isActive);
-
-            expect(idMap.get(1)?.name).toBe('Alice');
-            expect(emailMap.get('bob@example.com')?.id).toBe(2);
-            expect(activeStatusMap.get(true)?.name).toBe('Charlie'); // Last active user
-        });
-
-        it('should work with e-commerce product catalog', () => {
-            const products: TestProduct[] = [
-                { sku: 'LAPTOP001', name: 'Gaming Laptop', price: 1299, category: 'Electronics' },
-                { sku: 'MOUSE001', name: 'Wireless Mouse', price: 29, category: 'Electronics' },
-                { sku: 'BOOK001', name: 'Programming Guide', price: 45, category: 'Books' },
-                { sku: 'LAPTOP002', name: 'Business Laptop', price: 899, category: 'Electronics' }
-            ];
-
-            // Create maps for different lookup scenarios
-            const skuMap = toMap(products, (product) => product.sku);
-            const categoryMap = toMap(products, (product) => product.category);
-            const priceRangeMap = toMap(products, (product) =>
-                product.price > 1000 ? 'premium' : product.price > 100 ? 'mid-range' : 'budget'
-            );
-
-            expect(skuMap.get('LAPTOP001')?.name).toBe('Gaming Laptop');
-            expect(categoryMap.get('Electronics')?.name).toBe('Business Laptop'); // Last electronics product
-            expect(priceRangeMap.get('premium')?.sku).toBe('LAPTOP001');
-            expect(priceRangeMap.get('budget')?.sku).toBe('BOOK001'); // Last budget item wins
-        });
-    });
-}); 

package/src/utilities/arrays.ts

@@ -1,12 +0,0 @@
-export const toMap = <T extends {}>(data: T[], keySelector: (item: T) => T[keyof T] | string) => {
-
-    const result = new Map<T[keyof T] | string, T>();
-
-    for (let i = 0; i < data.length; i++) {
-        const item = data[i];
-        const key = keySelector(item);
-        result.set(key, item);
-    }
-
-    return result;
-}