@algochad/prisma-core/dist/collections/linq/async-enumerable.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.AsyncEnumerable = void 0;
const enumerable_1 = require("./enumerable");
const list_1 = require("./list");
const linqts_1 = require("linqts");
class AsyncEnumerable {
    _linqAsyncEnumerable;
    constructor(items) {
        this._linqAsyncEnumerable = new linqts_1.List(Array.from(items));
    }
    static fromArray(items) {
        return new AsyncEnumerable(items);
    }
    static from(generator) {
        return {
            async *[Symbol.asyncIterator]() {
                for await (const item of generator()) {
                    yield item;
                }
            },
            async ToArrayAsync() {
                const result = [];
                for await (const item of generator()) {
                    result.push(item);
                }
                return result;
            },
        };
    }
    async *[Symbol.asyncIterator]() {
        for (const item of this._linqAsyncEnumerable) {
            yield item;
        }
    }
    async ToArrayAsync() {
        return Promise.resolve(this._linqAsyncEnumerable.ToArray());
    }
    ToArray() {
        return this._linqAsyncEnumerable.ToArray();
    }
    async ToListAsync() {
        return new list_1.List(await this.ToArrayAsync());
    }
    async CountAsync(predicate) {
        const result = predicate
            ? this._linqAsyncEnumerable.Count(predicate)
            : this._linqAsyncEnumerable.Count();
        return Promise.resolve(result);
    }
    async FirstAsync(predicate) {
        const result = predicate
            ? this._linqAsyncEnumerable.First(predicate)
            : this._linqAsyncEnumerable.First();
        return Promise.resolve(result);
    }
    async FirstOrDefaultAsync(predicate, defaultValue) {
        const result = predicate
            ? this._linqAsyncEnumerable
                .Where(predicate)
                .FirstOrDefault(defaultValue)
            : this._linqAsyncEnumerable.FirstOrDefault(defaultValue);
        return Promise.resolve(result);
    }
    async LastAsync(predicate) {
        const result = predicate
            ? this._linqAsyncEnumerable.Last(predicate)
            : this._linqAsyncEnumerable.Last();
        return Promise.resolve(result);
    }
    async LastOrDefaultAsync(predicate, defaultValue) {
        const result = predicate
            ? this._linqAsyncEnumerable
                .Where(predicate)
                .LastOrDefault(defaultValue)
            : this._linqAsyncEnumerable.LastOrDefault(defaultValue);
        return Promise.resolve(result);
    }
    async SingleAsync(predicate) {
        const result = predicate
            ? this._linqAsyncEnumerable.Single(predicate)
            : this._linqAsyncEnumerable.Single();
        return Promise.resolve(result);
    }
    async SingleOrDefaultAsync(predicate, defaultValue) {
        const result = predicate
            ? this._linqAsyncEnumerable
                .Where(predicate)
                .SingleOrDefault(defaultValue)
            : this._linqAsyncEnumerable.SingleOrDefault(defaultValue);
        return Promise.resolve(result);
    }
    Where(predicate) {
        this._linqAsyncEnumerable = this._linqAsyncEnumerable.Where(predicate);
        return this;
    }
    Select(selector) {
        return new AsyncEnumerable(this._linqAsyncEnumerable.Select(selector));
    }
    SelectMany(selector) {
        const resultArray = this._linqAsyncEnumerable
            .SelectMany((item) => {
            const selected = selector(item);
            return new linqts_1.List(Array.from(selected));
        })
            .ToArray();
        return AsyncEnumerable.fromArray(resultArray);
    }
    OrderBy(keySelector) {
        const OrderedAsyncEnumerable = require('./ordered-async-enumerable').OrderedAsyncEnumerable;
        return new OrderedAsyncEnumerable(this, [keySelector], [false]);
    }
    OrderByDescending(keySelector) {
        const OrderedAsyncEnumerable = require('./ordered-async-enumerable').OrderedAsyncEnumerable;
        return new OrderedAsyncEnumerable(this, [keySelector], [true]);
    }
    Distinct(keySelector) {
        const resultArray = keySelector
            ? this._linqAsyncEnumerable
                .Select((item) => ({
                key: keySelector(item),
                value: item,
            }))
                .DistinctBy((x) => String(x.key))
                .Select((x) => x.value)
                .ToArray()
            : this._linqAsyncEnumerable.Distinct().ToArray();
        return AsyncEnumerable.fromArray(resultArray);
    }
    Take(count) {
        this._linqAsyncEnumerable = this._linqAsyncEnumerable.Take(count);
        return this;
    }
    Skip(count) {
        this._linqAsyncEnumerable = this._linqAsyncEnumerable.Skip(count);
        return this;
    }
    TakeWhile(predicate) {
        const resultArray = this._linqAsyncEnumerable
            .TakeWhile(predicate)
            .ToArray();
        return AsyncEnumerable.fromArray(resultArray);
    }
    SkipWhile(predicate) {
        const resultArray = this._linqAsyncEnumerable
            .SkipWhile(predicate)
            .ToArray();
        return AsyncEnumerable.fromArray(resultArray);
    }
    async AggregateAsync(seed, func) {
        const result = this._linqAsyncEnumerable.Aggregate(func, seed);
        return Promise.resolve(result);
    }
    async SumAsync(selector) {
        const result = selector
            ? this._linqAsyncEnumerable.Sum(selector)
            : this._linqAsyncEnumerable.Sum();
        return Promise.resolve(result);
    }
    async AverageAsync(selector) {
        const result = selector
            ? this._linqAsyncEnumerable.Average(selector)
            : this._linqAsyncEnumerable.Average();
        return Promise.resolve(result);
    }
    async MinAsync(selector) {
        const result = selector
            ? this._linqAsyncEnumerable.Min(selector)
            : this._linqAsyncEnumerable.Min();
        return Promise.resolve(result);
    }
    async MaxAsync(selector) {
        const result = selector
            ? this._linqAsyncEnumerable.Max(selector)
            : this._linqAsyncEnumerable.Max();
        return Promise.resolve(result);
    }
    async AnyAsync(predicate) {
        const result = predicate
            ? this._linqAsyncEnumerable.Any(predicate)
            : this._linqAsyncEnumerable.Any();
        return Promise.resolve(result);
    }
    async AllAsync(predicate) {
        const result = this._linqAsyncEnumerable.All(predicate);
        return Promise.resolve(result);
    }
    async ContainsAsync(item) {
        const result = this._linqAsyncEnumerable.Contains(item);
        return Promise.resolve(result);
    }
    async ToEnumerable() {
        const array = await this.ToArrayAsync();
        return new enumerable_1.Enumerable(array);
    }
}
exports.AsyncEnumerable = AsyncEnumerable;
//# sourceMappingURL=async-enumerable.js.map