@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
290 lines • 9.15 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.List = void 0;
const linqts_1 = require("linqts");
const grouping_1 = require("./grouping");
class List {
_linqList;
constructor(items = []) {
this._linqList = new linqts_1.List(Array.from(items));
}
static from(items) {
return new List(items);
}
static empty() {
return new List([]);
}
static range(start, count) {
const items = Array.from({ length: count }, (_, i) => start + i);
return new List(items);
}
static repeat(element, count) {
const items = Array.from({ length: count }, () => element);
return new List(items);
}
[Symbol.iterator]() {
return this._linqList.ToArray()[Symbol.iterator]();
}
ToArray() {
return this._linqList.ToArray();
}
ToList() {
return new List(this._linqList.ToArray());
}
Add(item) {
this._linqList = new linqts_1.List([
...this._linqList.ToArray(),
item,
]);
}
AddRange(items) {
this._linqList = new linqts_1.List([
...this._linqList.ToArray(),
...Array.from(items),
]);
}
Insert(index, item) {
const array = this._linqList.ToArray();
array.splice(index, 0, item);
this._linqList = new linqts_1.List(array);
}
Remove(item) {
const array = this._linqList.ToArray();
const index = array.indexOf(item);
if (index !== -1) {
array.splice(index, 1);
this._linqList = new linqts_1.List(array);
return true;
}
return false;
}
RemoveAt(index) {
const array = this._linqList.ToArray();
array.splice(index, 1);
this._linqList = new linqts_1.List(array);
}
RemoveAll(predicate) {
const array = this._linqList.ToArray();
const filtered = array.filter((item, index) => !predicate(item, index, array));
this._linqList = new linqts_1.List(filtered);
return new List(filtered);
}
Clear() {
this._linqList = new linqts_1.List([]);
}
IndexOf(item) {
return this._linqList.ToArray().indexOf(item);
}
LastIndexOf(item) {
return this._linqList.ToArray().lastIndexOf(item);
}
Count(predicate) {
return predicate
? this._linqList.Where(predicate).Count()
: this._linqList.Count();
}
First(predicate) {
return predicate
? this._linqList.Where(predicate).First()
: this._linqList.First();
}
FirstOrDefault(predicate, defaultValue) {
if (typeof predicate === 'function') {
return (this._linqList
.Where(predicate)
.FirstOrDefault(defaultValue) ?? defaultValue);
}
else {
return (this._linqList.FirstOrDefault(defaultValue) ?? predicate);
}
}
Last(predicate) {
return predicate
? this._linqList.Where(predicate).Last()
: this._linqList.Last();
}
LastOrDefault(predicate, defaultValue) {
if (typeof predicate === 'function') {
return (this._linqList
.Where(predicate)
.LastOrDefault(defaultValue) ?? defaultValue);
}
else {
return this._linqList.LastOrDefault(defaultValue) ?? predicate;
}
}
Single(predicate) {
return predicate
? this._linqList.Where(predicate).Single()
: this._linqList.Single();
}
SingleOrDefault(defaultValue) {
return (this._linqList.SingleOrDefault(defaultValue) ?? defaultValue);
}
get length() {
return this._linqList.Count();
}
get(index) {
return this._linqList.ElementAt(index);
}
set(index, value) {
const array = this._linqList.ToArray();
array[index] = value;
this._linqList = new linqts_1.List(array);
}
ElementAt(index) {
return this._linqList.ElementAt(index);
}
ElementAtOrDefault(index) {
const result = this._linqList.ElementAtOrDefault(index);
return result === null ? undefined : result;
}
Where(predicate) {
this._linqList = this._linqList.Where(predicate);
return this;
}
Select(selector) {
const selectedEnumerable = this._linqList.Select(selector);
return new List(selectedEnumerable.ToArray());
}
SelectMany(selector) {
const result = [];
this._linqList.ToArray().forEach((item, index) => {
const selected = selector(item, index);
result.push(...selected.ToArray());
});
return new List(result);
}
OrderBy(keySelector, comparer) {
const sorted = this._linqList.OrderBy(keySelector, comparer).ToArray();
const { OrderedEnumerable } = require('./ordered-enumerable');
return new OrderedEnumerable(sorted, [keySelector], [false]);
}
OrderByDescending(keySelector, comparer) {
const sorted = this._linqList
.OrderByDescending(keySelector, comparer)
.ToArray();
const { OrderedEnumerable } = require('./ordered-enumerable');
return new OrderedEnumerable(sorted, [keySelector], [true]);
}
Distinct() {
return new List(this._linqList.Distinct().ToArray());
}
DistinctBy(keySelector) {
const seen = new Set();
const distinct = this._linqList.ToArray().filter((item) => {
const key = keySelector(item);
if (seen.has(key)) {
return false;
}
seen.add(key);
return true;
});
return new List(distinct);
}
Union(list) {
return new List(this._linqList.Union(new linqts_1.List(list.ToArray())).ToArray());
}
Intersect(source) {
return new List(this._linqList
.Intersect(new linqts_1.List(source.ToArray()))
.ToArray());
}
Except(source) {
return new List(this._linqList
.Except(new linqts_1.List(source.ToArray()))
.ToArray());
}
Take(amount) {
this._linqList = this._linqList.Take(amount);
return this;
}
Skip(amount) {
this._linqList = this._linqList.Skip(amount);
return this;
}
TakeWhile(predicate) {
this._linqList = this._linqList.TakeWhile(predicate);
return this;
}
SkipWhile(predicate) {
this._linqList = this._linqList.SkipWhile(predicate);
return this;
}
Reverse() {
return new List(this._linqList.Reverse().ToArray());
}
Sort(comparer) {
const sorted = [...this._linqList.ToArray()];
if (comparer) {
sorted.sort(comparer);
}
else {
sorted.sort();
}
return new List(sorted);
}
Aggregate(accumulator, initialValue) {
return this._linqList.Aggregate(accumulator, initialValue);
}
Sum(transform) {
return transform ? this._linqList.Sum(transform) : this._linqList.Sum();
}
Average(transform) {
return transform
? this._linqList.Average(transform)
: this._linqList.Average();
}
Min(selector) {
return selector ? this._linqList.Min(selector) : this._linqList.Min();
}
Max(selector) {
return selector ? this._linqList.Max(selector) : this._linqList.Max();
}
Any(predicate) {
return predicate ? this._linqList.Any(predicate) : this._linqList.Any();
}
All(predicate) {
return this._linqList.All(predicate);
}
Contains(element) {
return this._linqList.Contains(element);
}
Join(list, key1, key2, result) {
return new List(this._linqList
.Join(new linqts_1.List(list.ToArray()), key1, key2, result)
.ToArray());
}
GroupJoin(list, key1, key2, result) {
return new List(this._linqList
.GroupJoin(new linqts_1.List(list.ToArray()), key1, key2, (first, second) => result(first, new List(second.ToArray())))
.ToArray());
}
GroupBy(grouper, mapper) {
const grouped = this._linqList.GroupBy(grouper, mapper);
const result = [];
Object.keys(grouped).forEach((key) => {
return result.push(new grouping_1.Grouping(key, grouped[key]));
});
return new List(result);
}
ToAsyncEnumerable() {
const asyncIterable = {
async *[Symbol.asyncIterator]() {
for (const item of this._linqList.ToArray()) {
yield item;
}
},
};
const { AsyncEnumerable } = require('./async-enumerable');
return new AsyncEnumerable(asyncIterable);
}
ForEach(action) {
this._linqList.ForEach(action);
}
Concat(list) {
return new List(this._linqList.Concat(new linqts_1.List(list.ToArray())).ToArray());
}
}
exports.List = List;
//# sourceMappingURL=list.js.map