@algochad/prisma-core
Version:
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
210 lines • 7.21 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Enumerable = void 0;
const linqts_1 = require("linqts");
const list_1 = require("./list");
const grouping_1 = require("./grouping");
class Enumerable {
_linqEnumerable;
constructor(items) {
this._linqEnumerable = new linqts_1.List(Array.from(items));
}
static from(items) {
return new Enumerable(items);
}
static empty() {
return new Enumerable([]);
}
static range(start, count) {
const items = Array.from({ length: count }, (_, i) => start + i);
return new Enumerable(items);
}
static repeat(element, count) {
const items = Array.from({ length: count }, () => element);
return new Enumerable(items);
}
[Symbol.iterator]() {
return this._linqEnumerable[Symbol.iterator]();
}
ToArray() {
return this._linqEnumerable.ToArray();
}
ToList() {
return new list_1.List(this._linqEnumerable.ToArray());
}
Count(predicate) {
return this._linqEnumerable.Count(predicate);
}
First(predicate) {
return this._linqEnumerable.First(predicate);
}
FirstOrDefault(predicateOrDefaultValue, defaultValue) {
const result = predicateOrDefaultValue
? this._linqEnumerable
.Where(predicateOrDefaultValue)
.FirstOrDefault(defaultValue)
: this._linqEnumerable.FirstOrDefault(defaultValue);
return result === null ? defaultValue : result;
}
Last(predicate) {
return this._linqEnumerable.Last(predicate);
}
LastOrDefault(predicateOrDefaultValue, defaultValue) {
if (typeof predicateOrDefaultValue === 'function') {
const filtered = this._linqEnumerable.Where(predicateOrDefaultValue);
const result = filtered.LastOrDefault(defaultValue);
return result === null ? defaultValue : result;
}
else {
const result = this._linqEnumerable.LastOrDefault(predicateOrDefaultValue);
return result === null ? predicateOrDefaultValue : result;
}
}
Single(predicate) {
return this._linqEnumerable.Single(predicate);
}
SingleOrDefault(defaultValue) {
const result = this._linqEnumerable.SingleOrDefault(defaultValue);
return result === null ? defaultValue : result;
}
ElementAt(index) {
return this._linqEnumerable.ElementAt(index);
}
ElementAtOrDefault(index) {
const result = this._linqEnumerable.ElementAtOrDefault(index);
return result === null ? undefined : result;
}
Where(predicate) {
this._linqEnumerable = this._linqEnumerable.Where(predicate);
return this;
}
Select(selector) {
return new Enumerable(this._linqEnumerable.Select(selector));
}
SelectMany(selector) {
const flattened = [];
this._linqEnumerable.ForEach((item, index) => {
const selected = selector(item, index);
flattened.push(...selected.ToArray());
});
return new Enumerable(flattened);
}
OrderBy(keySelector, comparer) {
const sorted = this._linqEnumerable
.OrderBy(keySelector, comparer)
.ToArray();
const { OrderedEnumerable } = require('./ordered-enumerable');
return new OrderedEnumerable(sorted, [(item) => keySelector(item)], [false]);
}
OrderByDescending(keySelector, comparer) {
const sorted = this._linqEnumerable
.OrderByDescending(keySelector, comparer)
.ToArray();
const { OrderedEnumerable } = require('./ordered-enumerable');
return new OrderedEnumerable(sorted, [(item) => keySelector(item)], [true]);
}
Distinct() {
return new Enumerable(this._linqEnumerable.Distinct().ToArray());
}
DistinctBy(keySelector) {
this._linqEnumerable = this._linqEnumerable.DistinctBy(keySelector);
return this;
}
Union(list) {
return new Enumerable(this._linqEnumerable
.Union(new linqts_1.List(list.ToArray()))
.ToArray());
}
Intersect(source) {
return new Enumerable(this._linqEnumerable
.Intersect(new linqts_1.List(source.ToArray()))
.ToArray());
}
Except(source) {
return new Enumerable(this._linqEnumerable
.Except(new linqts_1.List(source.ToArray()))
.ToArray());
}
Take(amount) {
this._linqEnumerable = this._linqEnumerable.Take(amount);
return this;
}
Skip(amount) {
this._linqEnumerable = this._linqEnumerable.Skip(amount);
return this;
}
TakeWhile(predicate) {
this._linqEnumerable = this._linqEnumerable.TakeWhile(predicate);
return this;
}
SkipWhile(predicate) {
this._linqEnumerable = this._linqEnumerable.SkipWhile(predicate);
return this;
}
Aggregate(accumulator, initialValue) {
return this._linqEnumerable.Aggregate(accumulator, initialValue);
}
Sum(transform) {
return this._linqEnumerable.Sum(transform);
}
Average(transform) {
return this._linqEnumerable.Average(transform);
}
Min(selector) {
return this._linqEnumerable.Min(selector);
}
Max(selector) {
return this._linqEnumerable.Max(selector);
}
Any(predicate) {
return this._linqEnumerable.Any(predicate);
}
All(predicate) {
return this._linqEnumerable.All(predicate);
}
Contains(element) {
return this._linqEnumerable.Contains(element);
}
Join(list, key1, key2, result) {
return new Enumerable(this._linqEnumerable
.Join(new linqts_1.List(list.ToArray()), key1, key2, result)
.ToArray());
}
GroupJoin(list, key1, key2, result) {
return new Enumerable(this._linqEnumerable
.GroupJoin(new linqts_1.List(list.ToArray()), key1, key2, (first, second) => result(first, new Enumerable(second.ToArray())))
.ToArray());
}
GroupBy(grouper, mapper) {
const grouped = this._linqEnumerable.GroupBy(grouper, mapper);
const result = [];
Object.keys(grouped).forEach((key) => {
return result.push(new grouping_1.Grouping(key, grouped[key]));
});
return new Enumerable(result);
}
ToAsyncEnumerable() {
const asyncIterable = {
async *[Symbol.asyncIterator]() {
for (const item of this.linqEnumerable.ToArray()) {
yield item;
}
},
};
const { AsyncEnumerable } = require('./async-enumerable');
return new AsyncEnumerable(asyncIterable);
}
ForEach(action) {
this._linqEnumerable.ForEach(action);
}
Reverse() {
this._linqEnumerable = this._linqEnumerable.Reverse();
return this;
}
Concat(list) {
this._linqEnumerable = this._linqEnumerable.Concat(new linqts_1.List(list.ToArray()));
return this;
}
}
exports.Enumerable = Enumerable;
//# sourceMappingURL=enumerable.js.map