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

package/src/codegen/handlers/serialize/SerializeValueHandler.ts

@@ -1,33 +0,0 @@
-import { CodeBuilder, ObjectBuilder, SlotBlock } from '../../blocks';
-import { SlotPath } from '../../SlotPath';
-import { PropertyInfoHandler } from "../types";
-import { PropertyInfo, SchemaTypes } from "../../../schema";
-
-export class SerializeValueHandler extends PropertyInfoHandler {
-
-    override handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null {
-
-        if (property.type != SchemaTypes.Object && property.type != SchemaTypes.Date) {
-            let objectBuilder = builder.getOrDefault<ObjectBuilder>("result.variable.object");
-            const entitySelectorPath = property.getAssignmentPath({ parent: "entity" });
-
-            if (objectBuilder == null) {
-                objectBuilder = builder.get<SlotBlock>("result")
-                    .assign("const result", { name: "variable" })
-                    .object({ name: "object" });
-            }
-
-            if (property.parent == null) {
-                objectBuilder.property(`${property.name}: ${entitySelectorPath}`);
-                return builder;
-            }
-
-            const slotPath = new SlotPath(...property.getParentPathArray());
-            objectBuilder = objectBuilder.get<ObjectBuilder>(slotPath.get());
-            objectBuilder.property(`${property.name}: ${entitySelectorPath}`);
-            return builder;
-        }
-
-        return super.handle(property, builder);
-    }
-}

package/src/codegen/handlers/strip/StripIdentityHandler.ts

@@ -1,15 +0,0 @@
-import { CodeBuilder } from '../../blocks';
-import { PropertyInfoHandler } from "../types";
-import { PropertyInfo } from "../../../schema";
-
-export class StripIdentityHandler extends PropertyInfoHandler {
-
-    override handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null {
-
-        if (property.isIdentity === true) {
-            return builder;
-        }
-
-        return super.handle(property, builder);
-    }
-}

package/src/codegen/handlers/strip/StripKeyHandler.ts

@@ -1,15 +0,0 @@
-import { CodeBuilder } from '../../blocks';
-import { PropertyInfoHandler } from "../types";
-import { PropertyInfo } from "../../../schema";
-
-export class StripKeyHandler extends PropertyInfoHandler {
-
-    override handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null {
-
-        if (property.isKey === true) {
-            return builder;
-        }
-
-        return super.handle(property, builder);
-    }
-}

package/src/codegen/handlers/strip/StripObjectHandler.ts

@@ -1,35 +0,0 @@
-import { CodeBuilder, ObjectBuilder, SlotBlock } from '../../blocks';
-import { SlotPath } from '../../SlotPath';
-import { PropertyInfoHandler } from "../types";
-import { PropertyInfo, SchemaTypes } from "../../../schema";
-
-export class StripObjectHandler extends PropertyInfoHandler {
-
-    override handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null {
-
-        if (property.type === SchemaTypes.Object) {
-            const slotPath = new SlotPath("result.variable.object");
-            let objectBuilder = builder.getOrDefault<ObjectBuilder>(slotPath.get());
-
-            if (objectBuilder == null) {
-                objectBuilder = builder.get<SlotBlock>("result")
-                    .assign("const result", { name: "variable" })
-                    .object({ name: "object" });
-            }
-
-            if (property.parent == null) {
-                objectBuilder.nested(property.name, property.name)
-
-                return builder;
-            }
-
-            slotPath.push(...property.getParentPathArray());
-            const nestedObjectBuilder = builder.get<ObjectBuilder>(slotPath.get());
-            nestedObjectBuilder.nested(property.name, property.name)
-
-            return builder;
-        }
-
-        return super.handle(property, builder);
-    }
-}

package/src/codegen/handlers/strip/StripValueHandler.ts

@@ -1,36 +0,0 @@
-import { PropertyInfo, SchemaTypes } from "../../../schema";
-import { PropertyInfoHandler } from "../types";
-import { CodeBuilder, ObjectBuilder, SlotBlock } from '../../blocks';
-import { SlotPath } from '../../SlotPath';
-
-export class StripValueHandler extends PropertyInfoHandler {
-
-    override handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null {
-
-        if (property.type != SchemaTypes.Object) {
-            let objectBuilder = builder.getOrDefault<ObjectBuilder>("result.variable.object");
-            const entitySelectorPath = property.getAssignmentPath({ parent: "entity" });
-
-            // There is a chance this is the first property we handle,
-            // if that is the case, the main result variable will not be
-            // constructed yet
-            if (objectBuilder == null) {
-                objectBuilder = builder.get<SlotBlock>("result")
-                    .assign("const result", { name: "variable" })
-                    .object({ name: "object" });
-            }
-
-            if (property.parent == null) {
-                objectBuilder.property(`${property.name}: ${entitySelectorPath}`);
-                return builder;
-            }
-
-            const slotPath = new SlotPath(...property.getParentPathArray());
-            objectBuilder = objectBuilder.get<ObjectBuilder>(slotPath.get());
-            objectBuilder.property(`${property.name}: ${entitySelectorPath}`);
-            return builder;
-        }
-
-        return super.handle(property, builder);
-    }
-}

package/src/codegen/handlers/types.ts

@@ -1,119 +0,0 @@
-import { AssignmentBuilder, CodeBuilder, ContainerBlock, ObjectBuilder, SlotBlock } from '..';
-import { PropertyInfo } from '../../schema/PropertyInfo';
-import { SlotPath } from '../SlotPath';
-import { SchemaError } from '../../errors/SchemaError';
-import { uuid } from '../../utilities/uuid';
-import { countWordOccurance } from '../utils';
-
-export interface IHandler {
-    setNext(handler: IHandler): IHandler;
-
-    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
-}
-
-export abstract class PropertyInfoHandler implements IHandler {
-
-    private _next: IHandler | null;
-
-    setNext(handler: IHandler): IHandler {
-        this._next = handler;
-
-        return handler;
-    }
-
-    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null {
-        try {
-            if (this._next) {
-                return this._next.handle(property, builder);
-            }
-
-            return null;
-        } catch (e: any) {
-            throw new SchemaError(e, `Error handling property: ${property.name}`);
-        }
-    }
-
-    protected buildSlotPath(property: PropertyInfo<any>, path: SlotPath) {
-
-        const result = new SlotPath(...path.path);
-        const items: string[] = []
-        let p = property;
-
-        while (p.parent != null) {
-            items.unshift(p.name);
-            p = p.parent;
-        }
-
-        items.unshift(p.name);
-
-        result.push(...items);
-
-        return result
-    }
-
-    protected setEnrichedProperty(property: PropertyInfo<any>, root: CodeBuilder) {
-        const useFromPropertyName = property.from != null;
-        const entitySelectorPath = property.getAssignmentPath({ parent: "entity", useFromPropertyName });
-
-        if (property.parent != null) {
-            const slotPath = new SlotPath("factory", "function", "assignment");
-            const path = property.parent.getAssignmentPath({ parent: "enriched" });
-            slotPath.push(`[${path}]`)
-            const builder = root.get<AssignmentBuilder>(slotPath.get());
-            const objectBuilder = builder.getValue as ObjectBuilder;
-
-            const childEntityPathSelector = property.getSelectrorPath({ parent: "entity", useFromPropertyName });
-            objectBuilder.property(`${property.name}: ${childEntityPathSelector}`);
-            return;
-        }
-
-        const slotPath = new SlotPath("factory", "function", "enriched", "object", "enriched");
-        let enriched = root.getOrDefault<ObjectBuilder>(slotPath.get());
-
-        if (enriched == null) {
-            const enrichedSlot = root.get<SlotBlock>("factory.function.enriched");
-            enriched = enrichedSlot.variable("enriched", { name: "object" }).object({ name: "enriched" });
-        }
-
-        enriched.property(`${property.name}: ${entitySelectorPath}`);
-    }
-
-    protected toNamedFunction(stringifiedFunction: string, parent: ContainerBlock) {
-        const name = `_${uuid()}`;
-
-        const builder = parent.function(name);
-        const occurences = countWordOccurance(stringifiedFunction, "=>")
-
-        if (occurences > 0) {
-
-            const split = stringifiedFunction.split("=>").map(w => w.trim());
-            const parameters = split[0].replace(/\(|\)/g, "").split(",");
-            let body = split[1];
-
-            if (occurences > 1) {
-                // we have a function that returns a function
-                const index = stringifiedFunction.indexOf("=>");
-                body = stringifiedFunction.slice(index + 2, stringifiedFunction.length)
-            }
-
-            if (body.startsWith("{") === true && body.endsWith("}")) {
-
-                // Remove brackets, wrapping function will have them
-                builder.appendBody(body.slice(1, body.length - 1));
-
-                return {
-                    builder,
-                    parameters
-                };
-            }
-
-            builder.appendBody(`return ${body};`);
-            return {
-                builder,
-                parameters
-            }
-        }
-
-        throw new Error("Only arrow functions are allowed in the schema definition:  function () {}  --->  () => {}");
-    }
-}

package/src/codegen/types.ts

@@ -1,2 +0,0 @@
-export type Insert = { index: number, type: "before" | "after", unshift: boolean };
-export type CreateBlockOptions = { name?: string, unshift?: boolean };

package/src/codegen/utils.ts

@@ -1,74 +0,0 @@
-/**
- * Counts non-overlapping occurrences of a term in text.
- *
- * Behavior:
- * - Case-sensitive matching
- * - If the search term is composed entirely of word characters (A–Z, a–z, 0–9, _),
- *   enforce whole-word boundaries so "red" does not match inside "redder".
- * - If the search term contains any non-word character (e.g. "=>", "()", "::"),
- *   match anywhere without boundary checks (useful for symbols).
- * - Non-overlapping matches (after a hit, advances by term length)
- * - Optimized single-character fast path; otherwise uses indexOf loop
- *
- * Examples:
- * - countWordOccurance("red redder red", "red") => 2
- * - countWordOccurance("()=>{}", "=>") => 1
- * - countWordOccurance("aaaa", "aa") => 2 (non-overlapping)
- *
- * @param text The source text to scan
- * @param word The term to match (must be non-empty)
- * @returns The number of occurrences found
- */
-export const countWordOccurance = (text: string, word: string) => {
-    const wl = word.length;
-    const tl = text.length;
-
-    if (wl === 0 || wl > tl) return 0;
-
-    // Fast path for single-character words
-    if (wl === 1) {
-        let c = 0;
-        const code = word.charCodeAt(0);
-        for (let i = 0; i < tl; i++) if (text.charCodeAt(i) === code) c++;
-        return c;
-    }
-
-    let count = 0;
-    let i = 0;
-
-    function isWordCharCode(c: number): boolean {
-        return (c >= 48 && c <= 57)      // 0-9
-            || (c >= 65 && c <= 90)      // A-Z
-            || (c >= 97 && c <= 122)     // a-z
-            || c === 95;                 // _
-    }
-
-    // Decide whether to enforce word boundaries based on the search term
-    let enforceWordBoundaries = true;
-    for (let k = 0; k < wl; k++) {
-        const cc = word.charCodeAt(k);
-        if (!isWordCharCode(cc)) {
-            enforceWordBoundaries = false;
-            break;
-        }
-    }
-
-    while (true) {
-        i = text.indexOf(word, i);
-        if (i === -1) break;
-
-        if (enforceWordBoundaries) {
-            const left = i - 1;
-            const right = i + wl;
-            const leftOk = left < 0 || !isWordCharCode(text.charCodeAt(left));
-            const rightOk = right >= tl || !isWordCharCode(text.charCodeAt(right));
-            if (leftOk && rightOk) count++;
-        } else {
-            // No boundary enforcement for symbol-containing terms
-            count++;
-        }
-        i += wl; // non-overlapping word matches
-    }
-
-    return count;
-}

package/src/collections/Changes.test.ts

@@ -1,337 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BulkPersistResult, BulkPersistChanges, SchemaPersistChanges, SchemaPersistResult } from './Changes';
-import { TagCollection } from './TagCollection';
-
-describe('SchemaPersistChanges', () => {
-    let changes: SchemaPersistChanges;
-
-    beforeEach(() => {
-        changes = new SchemaPersistChanges();
-    });
-
-    describe('initialization', () => {
-        it('should initialize with empty arrays and new TagCollection', () => {
-            expect(changes.adds).toEqual([]);
-            expect(changes.updates).toEqual([]);
-            expect(changes.removes).toEqual([]);
-            expect(changes.tags).toBeInstanceOf(TagCollection);
-        });
-    });
-
-    describe('hasItems', () => {
-        it('should return false when all arrays are empty', () => {
-            expect(changes.hasItems).toBe(false);
-        });
-
-        it('should return true when adds has items', () => {
-            changes.adds.push({ id: '1', name: 'Test' } as any);
-            expect(changes.hasItems).toBe(true);
-        });
-
-        it('should return true when updates has items', () => {
-            changes.updates.push({ entity: { id: '1' }, changeType: 'propertiesChanged', delta: {} } as any);
-            expect(changes.hasItems).toBe(true);
-        });
-
-        it('should return true when removes has items', () => {
-            changes.removes.push({ id: '1', name: 'Test' } as any);
-            expect(changes.hasItems).toBe(true);
-        });
-    });
-
-    describe('total', () => {
-        it('should return 0 for empty changes', () => {
-            expect(changes.total).toBe(0);
-        });
-
-        it('should return correct total with mixed items', () => {
-            changes.adds.push({ id: '1' } as any);
-            changes.adds.push({ id: '2' } as any);
-            changes.updates.push({ entity: { id: '3' }, changeType: 'propertiesChanged', delta: {} } as any);
-            changes.removes.push({ id: '4' } as any);
-
-            expect(changes.total).toBe(4);
-        });
-
-        it('should handle large numbers correctly', () => {
-            for (let i = 0; i < 1000; i++) {
-                changes.adds.push({ id: i.toString() } as any);
-            }
-            expect(changes.total).toBe(1000);
-        });
-    });
-});
-
-describe('SchemaPersistResult', () => {
-    let result: SchemaPersistResult;
-
-    beforeEach(() => {
-        result = new SchemaPersistResult();
-    });
-
-    describe('initialization', () => {
-        it('should initialize with empty arrays', () => {
-            expect(result.adds).toEqual([]);
-            expect(result.updates).toEqual([]);
-            expect(result.removes).toEqual([]);
-        });
-    });
-
-    describe('hasItems', () => {
-        it('should return false when all arrays are empty', () => {
-            expect(result.hasItems).toBe(false);
-        });
-
-        it('should return true when adds has items', () => {
-            result.adds.push({ id: '1', name: 'Test' } as any);
-            expect(result.hasItems).toBe(true);
-        });
-
-        it('should return true when updates has items', () => {
-            result.updates.push({ id: '1', name: 'Test' } as any);
-            expect(result.hasItems).toBe(true);
-        });
-
-        it('should return true when removes has items', () => {
-            result.removes.push({ id: '1', name: 'Test' } as any);
-            expect(result.hasItems).toBe(true);
-        });
-    });
-
-    describe('total', () => {
-        it('should return 0 for empty result', () => {
-            expect(result.total).toBe(0);
-        });
-
-        it('should return correct total with mixed items', () => {
-            result.adds.push({ id: '1' } as any);
-            result.adds.push({ id: '2' } as any);
-            result.updates.push({ id: '3' } as any);
-            result.removes.push({ id: '4' } as any);
-
-            expect(result.total).toBe(4);
-        });
-    });
-});
-
-describe('BulkPersistResult', () => {
-    let result: BulkPersistResult;
-
-    beforeEach(() => {
-        result = new BulkPersistResult();
-    });
-
-    describe('resolve', () => {
-        it('should return existing result if schemaId exists', () => {
-            const existingResult = new SchemaPersistResult();
-            result.set(1, existingResult);
-
-            const resolved = result.resolve(1);
-            expect(resolved).toBe(existingResult);
-        });
-
-        it('should create and return new result if schemaId does not exist', () => {
-            const resolved = result.resolve(1);
-            expect(resolved).toBeInstanceOf(SchemaPersistResult);
-            expect(result.has(1)).toBe(true);
-        });
-
-        it('should return the same instance when called multiple times', () => {
-            const first = result.resolve(1);
-            const second = result.resolve(1);
-            expect(first).toBe(second);
-        });
-    });
-
-    describe('get with generic type', () => {
-        it('should return typed result', () => {
-            const typedResult = result.get<{ id: string; name: string }>(1);
-            expect(typedResult).toBeInstanceOf(SchemaPersistResult);
-        });
-    });
-
-    describe('aggregate properties', () => {
-        beforeEach(() => {
-            // Setup test data
-            const result1 = new SchemaPersistResult();
-            result1.adds.push({ id: '1' } as any);
-            result1.adds.push({ id: '2' } as any);
-            result1.updates.push({ id: '3' } as any);
-            result1.removes.push({ id: '4' } as any);
-
-            const result2 = new SchemaPersistResult();
-            result2.adds.push({ id: '5' } as any);
-            result2.updates.push({ id: '6' } as any);
-
-            result.set(1, result1);
-            result.set(2, result2);
-        });
-
-        it('should calculate aggregate size correctly', () => {
-            expect(result.aggregate.size).toBe(6); // 2+1+1+1+0+1
-        });
-
-        it('should calculate aggregate adds correctly', () => {
-            expect(result.aggregate.adds).toBe(3); // 2+1
-        });
-
-        it('should calculate aggregate updates correctly', () => {
-            expect(result.aggregate.updates).toBe(2); // 1+1
-        });
-
-        it('should calculate aggregate removes correctly', () => {
-            expect(result.aggregate.removes).toBe(1); // 1+0
-        });
-    });
-
-    describe('aggregate with empty results', () => {
-        it('should return 0 for all aggregates when empty', () => {
-            expect(result.aggregate.size).toBe(0);
-            expect(result.aggregate.adds).toBe(0);
-            expect(result.aggregate.updates).toBe(0);
-            expect(result.aggregate.removes).toBe(0);
-        });
-    });
-});
-
-describe('BulkPersistChanges', () => {
-    let changes: BulkPersistChanges;
-
-    beforeEach(() => {
-        changes = new BulkPersistChanges();
-    });
-
-    describe('resolve', () => {
-        it('should return existing changes if schemaId exists', () => {
-            const existingChanges = new SchemaPersistChanges();
-            changes.set(1, existingChanges);
-
-            const resolved = changes.resolve(1);
-            expect(resolved).toBe(existingChanges);
-        });
-
-        it('should create and return new changes if schemaId does not exist', () => {
-            const resolved = changes.resolve(1);
-            expect(resolved).toBeInstanceOf(SchemaPersistChanges);
-            expect(changes.has(1)).toBe(true);
-        });
-
-        it('should return the same instance when called multiple times', () => {
-            const first = changes.resolve(1);
-            const second = changes.resolve(1);
-            expect(first).toBe(second);
-        });
-    });
-
-    describe('get with generic type', () => {
-        it('should return typed changes', () => {
-            const typedChanges = changes.get<{ id: string; name: string }>(1);
-            expect(typedChanges).toBeInstanceOf(SchemaPersistChanges);
-        });
-    });
-
-    describe('aggregate properties', () => {
-        beforeEach(() => {
-            // Setup test data
-            const changes1 = new SchemaPersistChanges();
-            changes1.adds.push({ id: '1' } as any);
-            changes1.adds.push({ id: '2' } as any);
-            changes1.updates.push({ entity: { id: '3' }, changeType: 'propertiesChanged', delta: {} } as any);
-            changes1.removes.push({ id: '4' } as any);
-
-            const changes2 = new SchemaPersistChanges();
-            changes2.adds.push({ id: '5' } as any);
-            changes2.updates.push({ entity: { id: '6' }, changeType: 'propertiesChanged', delta: {} } as any);
-
-            changes.set(1, changes1);
-            changes.set(2, changes2);
-        });
-
-        it('should calculate aggregate size correctly', () => {
-            expect(changes.aggregate.size).toBe(6); // 2+1+1+1+0+1
-        });
-
-        it('should calculate aggregate adds correctly', () => {
-            expect(changes.aggregate.adds).toBe(3); // 2+1
-        });
-
-        it('should calculate aggregate updates correctly', () => {
-            expect(changes.aggregate.updates).toBe(2); // 1+1
-        });
-
-        it('should calculate aggregate removes correctly', () => {
-            expect(changes.aggregate.removes).toBe(1); // 1+0
-        });
-    });
-
-    describe('toResult', () => {
-        it('should create result with same schema IDs', () => {
-            changes.set(1, new SchemaPersistChanges());
-            changes.set(2, new SchemaPersistChanges());
-
-            const result = changes.toResult();
-
-            expect(result.has(1)).toBe(true);
-            expect(result.has(2)).toBe(true);
-            expect(result.size).toBe(2);
-        });
-
-        it('should create empty SchemaPersistResult instances', () => {
-            changes.set(1, new SchemaPersistChanges());
-            const result = changes.toResult();
-
-            const schemaResult = result.get(1);
-            expect(schemaResult).toBeInstanceOf(SchemaPersistResult);
-            expect(schemaResult.adds).toEqual([]);
-            expect(schemaResult.updates).toEqual([]);
-            expect(schemaResult.removes).toEqual([]);
-        });
-
-        it('should handle empty changes map', () => {
-            const result = changes.toResult();
-            expect(result.size).toBe(0);
-        });
-    });
-
-    describe('aggregate with empty changes', () => {
-        it('should return 0 for all aggregates when empty', () => {
-            expect(changes.aggregate.size).toBe(0);
-            expect(changes.aggregate.adds).toBe(0);
-            expect(changes.aggregate.updates).toBe(0);
-            expect(changes.aggregate.removes).toBe(0);
-        });
-    });
-});
-
-describe('Edge cases and error scenarios', () => {
-    it('should handle very large numbers correctly', () => {
-        const changes = new SchemaPersistChanges();
-        for (let i = 0; i < 10000; i++) {
-            changes.adds.push({ id: i.toString() } as any);
-        }
-        expect(changes.total).toBe(10000);
-        expect(changes.hasItems).toBe(true);
-    });
-
-    it('should handle mixed data types in arrays', () => {
-        const changes = new SchemaPersistChanges();
-        changes.adds.push({ id: '1', name: 'Test' } as any);
-        changes.adds.push({ id: 2, count: 42 } as any);
-        changes.adds.push({ id: '3', active: true } as any);
-
-        expect(changes.total).toBe(3);
-        expect(changes.hasItems).toBe(true);
-    });
-
-    it('should handle concurrent modifications', () => {
-        const bulkChanges = new BulkPersistChanges();
-        const changes1 = bulkChanges.resolve(1);
-        const changes2 = bulkChanges.resolve(2);
-
-        changes1.adds.push({ id: '1' } as any);
-        changes2.adds.push({ id: '2' } as any);
-
-        expect(bulkChanges.aggregate.adds).toBe(2);
-        expect(bulkChanges.aggregate.size).toBe(2);
-    });
-});