@unchainedshop/utils 4.6.0 → 4.6.2

package/lib/repository/Repository.d.ts

@@ -0,0 +1,43 @@
+export interface Entity<TId = string> {
+    _id: TId;
+}
+export interface IRepository<T extends Entity<TId>, TId = string> {
+    findById(id: TId): Promise<T | null>;
+    save(aggregate: T): Promise<void>;
+    delete(id: TId): Promise<boolean>;
+    exists(id: TId): Promise<boolean>;
+}
+export interface IQueryableRepository<T extends Entity<TId>, TId = string, TQuery = Partial<T>> extends IRepository<T, TId> {
+    findAll(query?: TQuery): Promise<T[]>;
+    findOne(query: TQuery): Promise<T | null>;
+    count(query?: TQuery): Promise<number>;
+}
+export interface IPaginatedRepository<T extends Entity<TId>, TId = string, TQuery = Partial<T>> extends IQueryableRepository<T, TId, TQuery> {
+    findPaginated(query: TQuery, options: PaginationOptions): Promise<PaginatedResult<T>>;
+}
+export interface PaginationOptions {
+    offset?: number;
+    limit?: number;
+    sortBy?: string;
+    sortDirection?: 'asc' | 'desc';
+}
+export interface PaginatedResult<T> {
+    items: T[];
+    totalCount: number;
+    hasMore: boolean;
+    offset: number;
+    limit: number;
+}
+export interface IReadOnlyRepository<T extends Entity<TId>, TId = string, TQuery = Partial<T>> {
+    findById(id: TId): Promise<T | null>;
+    findAll(query?: TQuery): Promise<T[]>;
+    findOne(query: TQuery): Promise<T | null>;
+    count(query?: TQuery): Promise<number>;
+    exists(id: TId): Promise<boolean>;
+}
+export interface IUnitOfWork {
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    executeInTransaction<T>(fn: () => Promise<T>): Promise<T>;
+}

package/lib/repository/Repository.js

@@ -0,0 +1 @@
+export {};

package/lib/repository/index.d.ts

@@ -0,0 +1 @@
+export type { Entity, IRepository, IQueryableRepository, IPaginatedRepository, IReadOnlyRepository, IUnitOfWork, PaginationOptions, PaginatedResult, } from './Repository.ts';

package/lib/repository/index.js

@@ -0,0 +1 @@
+export {};

package/lib/specification/Specification.d.ts

@@ -0,0 +1,27 @@
+export type Specification<T> = (candidate: T) => boolean;
+export declare function and<T>(...specs: Specification<T>[]): Specification<T>;
+export declare function or<T>(...specs: Specification<T>[]): Specification<T>;
+export declare function not<T>(spec: Specification<T>): Specification<T>;
+export declare function alwaysTrue<T>(): Specification<T>;
+export declare function alwaysFalse<T>(): Specification<T>;
+export declare function propEquals<T, K extends keyof T = keyof T>(propertyName: K, expectedValue: T[K]): Specification<T>;
+export declare function propIn<T, K extends keyof T = keyof T>(propertyName: K, values: T[K][]): Specification<T>;
+export declare function dateRange<T>(propertyName: keyof T, range: {
+    start?: Date;
+    end?: Date;
+}): Specification<T>;
+export declare function numericRange<T>(propertyName: keyof T, range: {
+    min?: number;
+    max?: number;
+}): Specification<T>;
+export declare function propTruthy<T>(propertyName: keyof T): Specification<T>;
+export declare function propFalsy<T>(propertyName: keyof T): Specification<T>;
+export declare function propNullish<T>(propertyName: keyof T): Specification<T>;
+export declare function propNotNullish<T>(propertyName: keyof T): Specification<T>;
+export declare function propContains<T, V>(propertyName: keyof T, value: V): Specification<T>;
+export declare function spec<T>(predicate: (candidate: T) => boolean): Specification<T>;
+export declare function filterBy<T>(items: T[], specification: Specification<T>): T[];
+export declare function findBy<T>(items: T[], specification: Specification<T>): T | undefined;
+export declare function countBy<T>(items: T[], specification: Specification<T>): number;
+export declare function someBy<T>(items: T[], specification: Specification<T>): boolean;
+export declare function everyBy<T>(items: T[], specification: Specification<T>): boolean;

package/lib/specification/Specification.js

@@ -0,0 +1,88 @@
+export function and(...specs) {
+    return (candidate) => specs.every((spec) => spec(candidate));
+}
+export function or(...specs) {
+    return (candidate) => specs.some((spec) => spec(candidate));
+}
+export function not(spec) {
+    return (candidate) => !spec(candidate);
+}
+export function alwaysTrue() {
+    return () => true;
+}
+export function alwaysFalse() {
+    return () => false;
+}
+export function propEquals(propertyName, expectedValue) {
+    return (candidate) => candidate[propertyName] === expectedValue;
+}
+export function propIn(propertyName, values) {
+    const valueSet = new Set(values);
+    return (candidate) => valueSet.has(candidate[propertyName]);
+}
+export function dateRange(propertyName, range) {
+    return (candidate) => {
+        const value = candidate[propertyName];
+        if (!(value instanceof Date)) {
+            return false;
+        }
+        if (range.start && value < range.start) {
+            return false;
+        }
+        if (range.end && value > range.end) {
+            return false;
+        }
+        return true;
+    };
+}
+export function numericRange(propertyName, range) {
+    return (candidate) => {
+        const value = candidate[propertyName];
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (range.min !== undefined && value < range.min) {
+            return false;
+        }
+        if (range.max !== undefined && value > range.max) {
+            return false;
+        }
+        return true;
+    };
+}
+export function propTruthy(propertyName) {
+    return (candidate) => Boolean(candidate[propertyName]);
+}
+export function propFalsy(propertyName) {
+    return (candidate) => !candidate[propertyName];
+}
+export function propNullish(propertyName) {
+    return (candidate) => candidate[propertyName] == null;
+}
+export function propNotNullish(propertyName) {
+    return (candidate) => candidate[propertyName] != null;
+}
+export function propContains(propertyName, value) {
+    return (candidate) => {
+        const arr = candidate[propertyName];
+        return Array.isArray(arr) && arr.includes(value);
+    };
+}
+export function spec(predicate) {
+    return predicate;
+}
+export function filterBy(items, specification) {
+    return items.filter(specification);
+}
+export function findBy(items, specification) {
+    return items.find(specification);
+}
+export function countBy(items, specification) {
+    return items.filter(specification).length;
+}
+export function someBy(items, specification) {
+    return items.some(specification);
+}
+export function everyBy(items, specification) {
+    return items.every(specification);
+}

package/lib/specification/index.d.ts

@@ -0,0 +1 @@
+export { type Specification, and, or, not, alwaysTrue, alwaysFalse, propEquals, propIn, dateRange, numericRange, propTruthy, propFalsy, propNullish, propNotNullish, propContains, spec, filterBy, findBy, countBy, someBy, everyBy, } from './Specification.ts';

package/lib/specification/index.js

@@ -0,0 +1 @@
+export { and, or, not, alwaysTrue, alwaysFalse, propEquals, propIn, dateRange, numericRange, propTruthy, propFalsy, propNullish, propNotNullish, propContains, spec, filterBy, findBy, countBy, someBy, everyBy, } from "./Specification.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/utils",
   "description": "Common utility functions and base classes for the Unchained Engine",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "main": "lib/utils-index.js",
   "types": "lib/utils-index.d.ts",
   "type": "module",