@algochad/prisma-core/dist/collections/linq/grouping.js

A comprehensive NestJS library that provides EF-Core-like operations using Prisma and GraphQL. Features LINQ-style query builders, advanced data manipulation, GraphQL integration with genql, and a unified API for both Prisma and GraphQL operations. Includ

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Grouping = void 0;
class Grouping {
    key;
    _enumerable;
    elements;
    constructor(key, elements) {
        this.key = key;
        this.elements = [...elements];
        const { Enumerable } = require('./enumerable');
        this._enumerable = new Enumerable(elements);
    }
    get Key() {
        return this.key;
    }
    [Symbol.iterator]() {
        return this.elements[Symbol.iterator]();
    }
    ToArray() {
        return this._enumerable.ToArray();
    }
    ToList() {
        return this._enumerable.ToList();
    }
    Count(predicate) {
        return this._enumerable.Count(predicate);
    }
    First(predicate) {
        return this._enumerable.First(predicate);
    }
    FirstOrDefault(predicateOrDefaultValue, defaultValue) {
        if (typeof predicateOrDefaultValue === 'function') {
            return this._enumerable.FirstOrDefault(predicateOrDefaultValue, defaultValue);
        }
        else {
            return this._enumerable.FirstOrDefault(predicateOrDefaultValue);
        }
    }
    Last(predicate) {
        return this._enumerable.Last(predicate);
    }
    LastOrDefault(predicateOrDefaultValue, defaultValue) {
        if (typeof predicateOrDefaultValue === 'function') {
            return this._enumerable.LastOrDefault(predicateOrDefaultValue, defaultValue);
        }
        else {
            return this._enumerable.LastOrDefault(predicateOrDefaultValue);
        }
    }
    Single(predicate) {
        return this._enumerable.Single(predicate);
    }
    SingleOrDefault(defaultValue) {
        return this._enumerable.SingleOrDefault(defaultValue);
    }
    ElementAt(index) {
        return this._enumerable.ElementAt(index);
    }
    ElementAtOrDefault(index) {
        return this._enumerable.ElementAtOrDefault(index);
    }
    Where(predicate) {
        return this._enumerable.Where(predicate);
    }
    Select(selector) {
        return this._enumerable.Select(selector);
    }
    SelectMany(selector) {
        return this._enumerable.SelectMany(selector);
    }
    OrderBy(keySelector, comparer) {
        return this._enumerable.OrderBy(keySelector, comparer);
    }
    OrderByDescending(keySelector, comparer) {
        return this._enumerable.OrderByDescending(keySelector, comparer);
    }
    Distinct() {
        return this._enumerable.Distinct();
    }
    DistinctBy(keySelector) {
        return this._enumerable.DistinctBy(keySelector);
    }
    Union(list) {
        return this._enumerable.Union(list);
    }
    Intersect(source) {
        return this._enumerable.Intersect(source);
    }
    Except(source) {
        return this._enumerable.Except(source);
    }
    Take(amount) {
        return this._enumerable.Take(amount);
    }
    Skip(amount) {
        return this._enumerable.Skip(amount);
    }
    TakeWhile(predicate) {
        return this._enumerable.TakeWhile(predicate);
    }
    SkipWhile(predicate) {
        return this._enumerable.SkipWhile(predicate);
    }
    Aggregate(accumulator, initialValue) {
        return this._enumerable.Aggregate(accumulator, initialValue);
    }
    Sum(transform) {
        return this._enumerable.Sum(transform);
    }
    Average(transform) {
        return this._enumerable.Average(transform);
    }
    Min(selector) {
        return this._enumerable.Min(selector);
    }
    Max(selector) {
        return this._enumerable.Max(selector);
    }
    Any(predicate) {
        return this._enumerable.Any(predicate);
    }
    All(predicate) {
        return this._enumerable.All(predicate);
    }
    Contains(element) {
        return this._enumerable.Contains(element);
    }
    Join(list, key1, key2, result) {
        return this._enumerable.Join(list, key1, key2, result);
    }
    GroupJoin(list, key1, key2, result) {
        return this._enumerable.GroupJoin(list, key1, key2, result);
    }
    GroupBy(grouper, mapper) {
        return this._enumerable.GroupBy(grouper, mapper);
    }
    ToAsyncEnumerable() {
        return this._enumerable.ToAsyncEnumerable();
    }
    ForEach(action) {
        this._enumerable.ForEach(action);
    }
    Reverse() {
        return this._enumerable.Reverse();
    }
    Concat(list) {
        return this._enumerable.Concat(list);
    }
}
exports.Grouping = Grouping;
//# sourceMappingURL=grouping.js.map