@archlast/server 0.0.1

package/dist/repository/provider.js

@@ -0,0 +1,674 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryProvider = void 0;
+exports.createStaticQueryable = createStaticQueryable;
+const queryable_1 = require("./queryable");
+function isWhereClause(input) {
+    return typeof input === "object" && input !== null;
+}
+function isOrderByClause(input) {
+    return typeof input === "object" && input !== null;
+}
+// Fast hash function for primitive values and simple objects
+function fastHash(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    const type = typeof value;
+    if (type === "string")
+        return `s:${value}`;
+    if (type === "number")
+        return `n:${value}`;
+    if (type === "boolean")
+        return `b:${value}`;
+    if (type === "bigint")
+        return `i:${value}`;
+    // For objects and arrays, fall back to JSON.stringify
+    // Consider using a faster serialization library for production
+    return `o:${JSON.stringify(value)}`;
+}
+// Check if a Select expression is simple (field mapping only)
+function isSimpleSelect(selector) {
+    // This is a heuristic - we can't perfectly detect all cases
+    // In practice, users should use SelectClause for simple projections
+    return false; // Conservative: assume complex unless proven otherwise
+}
+// Extract field names from a simple selector function (best effort)
+function extractSelectFields(selector) {
+    const funcStr = selector.toString();
+    // Match patterns like: x => x.field or x => ({ field1: x.field1, field2: x.field2 })
+    // This is heuristic and won't catch all cases
+    const simpleFieldMatch = funcStr.match(/=>\s*\w+\.(\w+)/);
+    if (simpleFieldMatch) {
+        return [simpleFieldMatch[1]];
+    }
+    // Match object literal pattern
+    const objectMatch = funcStr.match(/=>\s*\(\s*{([^}]+)}\s*\)/);
+    if (objectMatch) {
+        const fields = objectMatch[1]
+            .split(",")
+            .map((part) => {
+            const colonSplit = part.split(":");
+            if (colonSplit.length === 2) {
+                const value = colonSplit[1].trim();
+                const fieldMatch = value.match(/\w+\.(\w+)/);
+                if (fieldMatch)
+                    return fieldMatch[1];
+            }
+            return null;
+        })
+            .filter(Boolean);
+        if (fields.length > 0)
+            return fields;
+    }
+    return null; // Can't extract, will execute in-memory
+}
+async function applyPredicate(item, predicate) {
+    if (!predicate)
+        return true;
+    const result = predicate(item);
+    return result instanceof Promise ? await result : result;
+}
+function matchesWhereClause(item, clause) {
+    if ("and" in clause && Array.isArray(clause.and)) {
+        return clause.and.every((c) => matchesWhereClause(item, c));
+    }
+    if ("or" in clause && Array.isArray(clause.or)) {
+        return clause.or.some((c) => matchesWhereClause(item, c));
+    }
+    if ("not" in clause) {
+        return !matchesWhereClause(item, clause.not);
+    }
+    return Object.entries(clause).every(([key, value]) => {
+        const fieldValue = item[key];
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            const op = value;
+            if ("eq" in op)
+                return fieldValue === op.eq;
+            if ("ne" in op)
+                return fieldValue !== op.ne;
+            if ("gt" in op && typeof fieldValue === "number")
+                return fieldValue > op.gt;
+            if ("gte" in op && typeof fieldValue === "number")
+                return fieldValue >= op.gte;
+            if ("lt" in op && typeof fieldValue === "number")
+                return fieldValue < op.lt;
+            if ("lte" in op && typeof fieldValue === "number")
+                return fieldValue <= op.lte;
+            if ("in" in op && Array.isArray(op.in))
+                return op.in.includes(fieldValue);
+            if ("notIn" in op && Array.isArray(op.notIn))
+                return !op.notIn.includes(fieldValue);
+            if ("contains" in op && typeof fieldValue === "string")
+                return fieldValue.includes(op.contains);
+            if ("startsWith" in op && typeof fieldValue === "string")
+                return fieldValue.startsWith(op.startsWith);
+            if ("endsWith" in op && typeof fieldValue === "string")
+                return fieldValue.endsWith(op.endsWith);
+            if ("isNull" in op)
+                return op.isNull ? fieldValue === null : fieldValue !== null;
+            if ("isNotNull" in op)
+                return op.isNotNull ? fieldValue !== null : fieldValue === null;
+        }
+        return fieldValue === value;
+    });
+}
+function compareOrder(a, b, order) {
+    if (typeof order === "function") {
+        const aKey = order(a);
+        const bKey = order(b);
+        if (aKey < bKey)
+            return -1;
+        if (aKey > bKey)
+            return 1;
+        return 0;
+    }
+    const clause = order;
+    for (const [key, dir] of Object.entries(clause)) {
+        const aVal = a[key];
+        const bVal = b[key];
+        if (aVal < bVal)
+            return -1;
+        if (aVal > bVal)
+            return 1;
+    }
+    return 0;
+}
+// Composite comparator that applies multiple sort criteria in order
+function compositeCompare(a, b, sorts) {
+    for (const spec of sorts) {
+        // Always get ascending comparison from compareOrder, then invert if needed
+        const ascendingResult = compareOrder(a, b, spec.orderBy);
+        if (ascendingResult !== 0) {
+            return spec.descending ? -ascendingResult : ascendingResult;
+        }
+    }
+    return 0;
+}
+class QueryProvider {
+    db;
+    collection;
+    staticSource;
+    constructor(db, collection, staticSource) {
+        this.db = db;
+        this.collection = collection;
+        this.staticSource = staticSource;
+    }
+    CreateQuery(expression) {
+        const isMutable = expression.mutable ?? false;
+        if (expression.kind === "OrderBy" ||
+            expression.kind === "OrderByDescending" ||
+            expression.kind === "ThenBy" ||
+            expression.kind === "ThenByDescending") {
+            if (isMutable) {
+                return new queryable_1.MutableOrderedQueryable(this, expression, this.db, this.collection, this.staticSource);
+            }
+            return new queryable_1.OrderedQueryable(this, expression);
+        }
+        if (isMutable) {
+            return new queryable_1.MutableQueryable(this, expression, this.db, this.collection, this.staticSource);
+        }
+        return new queryable_1.Queryable(this, expression);
+    }
+    async Execute(expression) {
+        if (this.staticSource) {
+            return this.executeInMemory(expression, this.staticSource);
+        }
+        return this.executeAgainstDb(expression);
+    }
+    collectChain(expr) {
+        const chain = [];
+        let current = expr;
+        while (current) {
+            chain.unshift(current);
+            const next = current.target;
+            if (!next)
+                break;
+            current = next;
+        }
+        return chain;
+    }
+    async executeAgainstDb(terminal) {
+        const chain = this.collectChain(terminal.target);
+        // ========== OPTIMIZATION: Direct Count/Any queries ==========
+        // If terminal is Count/LongCount/Any with no deferred operations, use db.count()
+        const canOptimizeCount = (terminal.kind === "Count" ||
+            terminal.kind === "LongCount" ||
+            terminal.kind === "Any") &&
+            !terminal.predicate &&
+            chain.every((part) => part.kind === "Where" ||
+                part.kind === "OrderBy" ||
+                part.kind === "OrderByDescending" ||
+                part.kind === "ThenBy" ||
+                part.kind === "ThenByDescending" ||
+                part.kind === "Take" ||
+                part.kind === "Skip");
+        if (canOptimizeCount) {
+            // Build where conditions
+            const whereConditions = [];
+            let take;
+            for (const part of chain) {
+                if (part.kind === "Where" &&
+                    isWhereClause(part.predicate)) {
+                    whereConditions.push(part.predicate);
+                }
+                if (part.kind === "Take") {
+                    take = part.count;
+                }
+            }
+            // Execute optimized count
+            let count;
+            if (whereConditions.length > 0) {
+                // Merge where conditions with 'and'
+                const mergedWhere = whereConditions.length === 1 ? whereConditions[0] : { and: whereConditions };
+                count = await this.db.count(this.collection, mergedWhere);
+            }
+            else {
+                count = await this.db.count(this.collection);
+            }
+            // Apply take limit if present
+            if (take !== undefined && count > take) {
+                count = take;
+            }
+            // Return appropriate result based on terminal kind
+            if (terminal.kind === "Any") {
+                return (count > 0);
+            }
+            return count;
+        }
+        // ========== Build query with pushed operations ==========
+        const builderBase = this.db.query(this.collection);
+        const deferred = [];
+        let selectClause = null;
+        let builder = builderBase;
+        for (const part of chain) {
+            switch (part.kind) {
+                case "Where":
+                    if (isWhereClause(part.predicate)) {
+                        builder = builder.where(part.predicate);
+                    }
+                    else {
+                        deferred.push(part);
+                    }
+                    break;
+                case "OrderBy":
+                    if (isOrderByClause(part.orderBy)) {
+                        builder = builder.orderBy(part.orderBy);
+                    }
+                    else {
+                        deferred.push(part);
+                    }
+                    break;
+                case "OrderByDescending":
+                    if (isOrderByClause(part.orderBy)) {
+                        const orderBy = part.orderBy;
+                        // OrderByDescending always sorts descending - ignore clause direction
+                        const descOrderBy = {};
+                        for (const key of Object.keys(orderBy)) {
+                            descOrderBy[key] = "desc";
+                        }
+                        builder = builder.orderBy(descOrderBy);
+                    }
+                    else {
+                        deferred.push(part);
+                    }
+                    break;
+                case "ThenBy":
+                    if (isOrderByClause(part.orderBy)) {
+                        builder = builder.orderBy(part.orderBy);
+                    }
+                    else {
+                        deferred.push(part);
+                    }
+                    break;
+                case "ThenByDescending":
+                    if (isOrderByClause(part.orderBy)) {
+                        const orderBy = part.orderBy;
+                        // ThenByDescending always sorts descending - ignore clause direction
+                        const descOrderBy = {};
+                        for (const key of Object.keys(orderBy)) {
+                            descOrderBy[key] = "desc";
+                        }
+                        builder = builder.orderBy(descOrderBy);
+                    }
+                    else {
+                        deferred.push(part);
+                    }
+                    break;
+                case "Take":
+                    builder = builder.take(part.count);
+                    break;
+                case "Skip":
+                    builder = builder.skip(part.count);
+                    break;
+                case "Select": {
+                    // Try to extract fields for push-down
+                    const selector = part.selector;
+                    const fields = extractSelectFields(selector);
+                    if (fields && fields.length > 0) {
+                        // Build SelectClause
+                        const clause = {};
+                        for (const field of fields) {
+                            clause[field] = true;
+                        }
+                        selectClause = clause;
+                        // Don't add to deferred - we'll push this to DB
+                    }
+                    else {
+                        // Complex selector - defer to in-memory
+                        deferred.push(part);
+                    }
+                    break;
+                }
+                default:
+                    deferred.push(part);
+                    break;
+            }
+        }
+        // Apply select if available
+        if (selectClause) {
+            builder = builder.select(selectClause);
+        }
+        const baseItems = (await builder.findMany());
+        return this.executeInMemory(terminal, baseItems, deferred);
+    }
+    async applyInclude(items, include) {
+        if (this.staticSource)
+            return items; // skip relationship loading for static sources
+        if (!items.length || !include)
+            return items;
+        let enriched = items;
+        for (const [relationName, spec] of Object.entries(include)) {
+            if (!spec)
+                continue;
+            const map = await this.db.loadRelations(this.collection, items, relationName);
+            enriched = enriched.map((item) => {
+                const related = map.get(item._id) ?? map.get(item.id) ?? null;
+                return { ...item, [relationName]: related };
+            });
+        }
+        return enriched;
+    }
+    async executeInMemory(terminal, seed, prechain) {
+        const chain = prechain ?? this.collectChain(terminal.target);
+        let items = [...seed];
+        // Process chain with sort coalescing
+        let i = 0;
+        while (i < chain.length) {
+            const part = chain[i];
+            const kind = part.kind;
+            // Coalesce adjacent sort operations into a single composite sort
+            if (kind === "OrderBy" ||
+                kind === "OrderByDescending" ||
+                kind === "ThenBy" ||
+                kind === "ThenByDescending") {
+                // Collect all adjacent sort operations
+                const sorts = [];
+                let j = i;
+                while (j < chain.length) {
+                    const sortKind = chain[j].kind;
+                    if (sortKind === "OrderBy") {
+                        const orderBy = chain[j].orderBy;
+                        // For OrderBy, check if clause specifies descending direction
+                        let descending = false;
+                        if (isOrderByClause(orderBy)) {
+                            for (const dir of Object.values(orderBy)) {
+                                if (dir === "desc") {
+                                    descending = true;
+                                    break;
+                                }
+                            }
+                        }
+                        sorts.push({ orderBy, descending });
+                        j++;
+                    }
+                    else if (sortKind === "OrderByDescending") {
+                        // OrderByDescending always sorts descending
+                        sorts.push({
+                            orderBy: chain[j].orderBy,
+                            descending: true,
+                        });
+                        j++;
+                    }
+                    else if (sortKind === "ThenBy") {
+                        const orderBy = chain[j].orderBy;
+                        // For ThenBy, check if clause specifies descending direction
+                        let descending = false;
+                        if (isOrderByClause(orderBy)) {
+                            for (const dir of Object.values(orderBy)) {
+                                if (dir === "desc") {
+                                    descending = true;
+                                    break;
+                                }
+                            }
+                        }
+                        sorts.push({ orderBy, descending });
+                        j++;
+                    }
+                    else if (sortKind === "ThenByDescending") {
+                        // ThenByDescending always sorts descending
+                        sorts.push({
+                            orderBy: chain[j].orderBy,
+                            descending: true,
+                        });
+                        j++;
+                    }
+                    else {
+                        break; // Not a sort operation, stop collecting
+                    }
+                }
+                // Apply single composite sort with all criteria
+                if (sorts.length > 0) {
+                    items.sort((a, b) => compositeCompare(a, b, sorts));
+                }
+                i = j;
+                continue;
+            }
+            // Non-sort operations continue with normal processing
+            switch (kind) {
+                case "Where": {
+                    const pred = part.predicate;
+                    if (isWhereClause(pred)) {
+                        items = items.filter((i) => matchesWhereClause(i, pred));
+                    }
+                    else {
+                        const fn = pred;
+                        const filtered = [];
+                        for (const i of items) {
+                            if (await applyPredicate(i, fn))
+                                filtered.push(i);
+                        }
+                        items = filtered;
+                    }
+                    break;
+                }
+                case "Take":
+                    items = items.slice(0, part.count);
+                    break;
+                case "Skip":
+                    items = items.slice(part.count);
+                    break;
+                case "Select":
+                    items = items.map((i) => part.selector(i));
+                    break;
+                case "SelectMany": {
+                    const selector = part.selector;
+                    const flat = [];
+                    for (const i of items) {
+                        const r = selector(i);
+                        if (r && typeof r.ExecuteAsync === "function") {
+                            flat.push(...(await r.ExecuteAsync()));
+                        }
+                        else if (r && Symbol.iterator in Object(r)) {
+                            for (const v of r)
+                                flat.push(v);
+                        }
+                        else if (r && Symbol.asyncIterator in Object(r)) {
+                            for await (const v of r)
+                                flat.push(v);
+                        }
+                    }
+                    items = flat;
+                    break;
+                }
+                case "Distinct": {
+                    const keySelector = part.keySelector ?? ((x) => x);
+                    const seen = new Set();
+                    const unique = [];
+                    for (const i of items) {
+                        const key = keySelector(i);
+                        const hash = fastHash(key);
+                        if (!seen.has(hash)) {
+                            seen.add(hash);
+                            unique.push(i);
+                        }
+                    }
+                    items = unique;
+                    break;
+                }
+                case "Union": {
+                    const other = await part.other.ExecuteAsync();
+                    const seen = new Set(items.map((x) => fastHash(x)));
+                    for (const o of other) {
+                        const h = fastHash(o);
+                        if (!seen.has(h)) {
+                            seen.add(h);
+                            items.push(o);
+                        }
+                    }
+                    break;
+                }
+                case "Intersect": {
+                    const other = await part.other.ExecuteAsync();
+                    const set = new Set(other.map((x) => fastHash(x)));
+                    items = items.filter((x) => set.has(fastHash(x)));
+                    break;
+                }
+                case "Except": {
+                    const other = await part.other.ExecuteAsync();
+                    const set = new Set(other.map((x) => fastHash(x)));
+                    items = items.filter((x) => !set.has(fastHash(x)));
+                    break;
+                }
+                case "GroupBy": {
+                    const { keySelector, elementSelector, resultSelector } = part;
+                    const groups = new Map();
+                    for (const i of items) {
+                        const k = keySelector(i);
+                        const h = fastHash(k);
+                        const entry = groups.get(h) ?? { key: k, values: [] };
+                        entry.values.push(elementSelector ? elementSelector(i) : i);
+                        groups.set(h, entry);
+                    }
+                    if (resultSelector) {
+                        items = Array.from(groups.values()).map((g) => resultSelector(g.key, createStaticQueryable(g.values)));
+                    }
+                    else {
+                        items = Array.from(groups.values()).map((g) => ({
+                            Key: g.key,
+                            Elements: createStaticQueryable(g.values),
+                        }));
+                    }
+                    break;
+                }
+                case "Join": {
+                    const { inner, outerKeySelector, innerKeySelector, resultSelector } = part;
+                    const innerItems = await inner.ExecuteAsync();
+                    const map = new Map();
+                    for (const it of innerItems) {
+                        const key = innerKeySelector(it);
+                        const h = fastHash(key);
+                        const arr = map.get(h) ?? [];
+                        arr.push(it);
+                        map.set(h, arr);
+                    }
+                    const joined = [];
+                    for (const o of items) {
+                        const key = outerKeySelector(o);
+                        const h = fastHash(key);
+                        const matches = map.get(h) ?? [];
+                        for (const m of matches)
+                            joined.push(resultSelector(o, m));
+                    }
+                    items = joined;
+                    break;
+                }
+                case "Include": {
+                    const include = part
+                        .include;
+                    items = await this.applyInclude(items, include);
+                    break;
+                }
+                default:
+                    break;
+            }
+            i++;
+        }
+        switch (terminal.kind) {
+            case "Execute":
+                return items;
+            case "First":
+            case "FirstOrDefault": {
+                for (const i of items) {
+                    if (await applyPredicate(i, terminal.predicate))
+                        return i;
+                }
+                if (terminal.kind === "First")
+                    throw new Error("Sequence contains no elements");
+                return undefined;
+            }
+            case "Single":
+            case "SingleOrDefault": {
+                let found;
+                let count = 0;
+                for (const i of items) {
+                    if (await applyPredicate(i, terminal.predicate)) {
+                        found = i;
+                        count += 1;
+                        if (count > 1)
+                            throw new Error("Sequence contains more than one element");
+                    }
+                }
+                if (count === 0 && terminal.kind === "Single")
+                    throw new Error("Sequence contains no elements");
+                return found;
+            }
+            case "Last":
+            case "LastOrDefault": {
+                let found;
+                for (const i of items) {
+                    if (await applyPredicate(i, terminal.predicate)) {
+                        found = i;
+                    }
+                }
+                if (found === undefined && terminal.kind === "Last")
+                    throw new Error("Sequence contains no elements");
+                return found;
+            }
+            case "Any": {
+                for (const i of items) {
+                    if (await applyPredicate(i, terminal.predicate))
+                        return true;
+                }
+                return false;
+            }
+            case "All": {
+                for (const i of items) {
+                    if (!(await applyPredicate(i, terminal.predicate)))
+                        return false;
+                }
+                return true;
+            }
+            case "Count":
+            case "LongCount": {
+                if (terminal.predicate) {
+                    let c = 0;
+                    for (const i of items) {
+                        if (await applyPredicate(i, terminal.predicate))
+                            c += 1;
+                    }
+                    return c;
+                }
+                return items.length;
+            }
+            case "Sum":
+            case "Average":
+            case "Min":
+            case "Max": {
+                const selector = terminal.selector ?? ((x) => x);
+                const values = items
+                    .map((x) => selector(x))
+                    .filter((v) => v !== undefined && v !== null);
+                if (values.length === 0)
+                    return (terminal.kind === "Average" ? 0 : 0);
+                if (terminal.kind === "Sum")
+                    return values.reduce((a, b) => a + b, 0);
+                if (terminal.kind === "Average")
+                    return (values.reduce((a, b) => a + b, 0) / values.length);
+                if (terminal.kind === "Min")
+                    return values.reduce((a, b) => (a < b ? a : b));
+                return values.reduce((a, b) => (a > b ? a : b));
+            }
+            case "Aggregate": {
+                const { seed, func } = terminal;
+                let acc = seed;
+                for (const i of items) {
+                    const next = func(acc, i);
+                    acc = next instanceof Promise ? await next : next;
+                }
+                return acc;
+            }
+            case "Contains": {
+                const { value } = terminal;
+                return items.some((x) => x === value);
+            }
+        }
+    }
+}
+exports.QueryProvider = QueryProvider;
+function createStaticQueryable(items) {
+    const provider = new QueryProvider({}, "", items);
+    return new queryable_1.Queryable(provider, { kind: "Source" });
+}
+//# sourceMappingURL=provider.js.map