@tstdl/base 0.92.124 → 0.92.126

package/database/query.d.ts

@@ -0,0 +1,121 @@
+import type { Flatten, Record } from '../types.js';
+import type { Geometry } from '../types/geo-json.js';
+export type QueryOptions<T = any> = {
+    sort?: Sort<T>[];
+    skip?: number;
+    limit?: number;
+};
+export type LogicalQuery<T = any> = LogicalAndQuery<T> | LogicalOrQuery<T> | LogicalNorQuery<T>;
+export type LogicalQueryTypes = keyof (LogicalAndQuery & LogicalOrQuery & LogicalNorQuery);
+export declare const allLogicalQueryTypes: LogicalQueryTypes[];
+export type ComparisonQueryBody<T = any> = {
+    [P in keyof T]?: ComparisonQueryOrValue<T[P]>;
+} & Record<ComparisonQueryOrValue>;
+export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | T | Flatten<T>;
+export type ComparisonQuery<T = any> = Partial<ComparisonNotQuery<T> & ComparisonEqualsQuery<T> & ComparisonNotEqualsQuery<T> & ComparisonExistsQuery & ComparisonItemQuery<T> & ComparisonInQuery<T> & ComparisonNotInQuery<T> & ComparisonAllQuery<T> & ComparisonGreaterThanQuery<T> & ComparisonGreaterThanOrEqualsQuery<T> & ComparisonLessThanQuery<T> & ComparisonLessThanOrEqualsQuery<T> & ComparisonRegexQuery & ComparisonTextQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
+export type ComparisonQueryTypes = keyof ComparisonQuery;
+export declare const allComparisonQueryTypes: ComparisonQueryTypes[];
+export type SpecialQuery<T = any> = Partial<TextSpanQuery<T>>;
+export type SpecialQueryTypes = keyof SpecialQuery;
+export declare const allSpecialQueryTypes: SpecialQueryTypes[];
+export type Query<T = any> = LogicalQuery<T> | (ComparisonQueryBody<T> & SpecialQuery<T>);
+export type QueryTypes = LogicalQueryTypes | ComparisonQueryTypes | SpecialQueryTypes;
+export declare const allQueryTypes: ("$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$text" | "$geoShape" | "$geoDistance" | "$textSpan")[];
+export type Order = 'asc' | 'desc';
+export declare const allOrders: Order[];
+export type Operator = 'and' | 'or';
+export declare const allOperators: Operator[];
+export type Sort<T = any> = {
+    field: Extract<keyof T, string> | '$score';
+    order?: Order;
+};
+export type LogicalAndQuery<T = any> = {
+    $and: Query<T>[];
+};
+export type LogicalOrQuery<T = any> = {
+    $or: Query<T>[];
+};
+export type LogicalNorQuery<T = any> = {
+    $nor: Query<T>[];
+};
+export type ComparisonValue<T> = T | Flatten<T>;
+export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends string[] ? ComparisonValue<(Flatten<T> | RegExp)[]> : (T | Flatten<T>);
+export type ComparisonNotQuery<T = any> = {
+    $not: ComparisonQuery<T>;
+};
+export type ComparisonEqualsQuery<T = any> = {
+    $eq: ComparisonValueWithRegex<T>;
+};
+export type ComparisonNotEqualsQuery<T = any> = {
+    $neq: ComparisonValueWithRegex<T>;
+};
+export type ComparisonExistsQuery = {
+    $exists: ComparisonValue<boolean>;
+};
+export type ComparisonItemQuery<T = any> = {
+    $item: T extends (infer U)[] ? U extends Record<any, any> ? Query<U> : ComparisonQuery<U> : never;
+};
+export type ComparisonInQuery<T = any> = {
+    $in: ComparisonValueWithRegex<T>[];
+};
+export type ComparisonNotInQuery<T = any> = {
+    $nin: ComparisonValueWithRegex<T>[];
+};
+export type ComparisonAllQuery<T = any> = {
+    $all: ComparisonValueWithRegex<T>[];
+};
+export type ComparisonGreaterThanQuery<T = any> = {
+    $gt: ComparisonValue<T>;
+};
+export type ComparisonGreaterThanOrEqualsQuery<T = any> = {
+    $gte: ComparisonValue<T>;
+};
+export type ComparisonLessThanQuery<T = any> = {
+    $lt: ComparisonValue<T>;
+};
+export type ComparisonLessThanOrEqualsQuery<T = any> = {
+    $lte: ComparisonValue<T>;
+};
+export type ComparisonRegexQuery = {
+    $regex: string | RegExp | {
+        pattern: string;
+        flags: string;
+    };
+};
+export type ComparisonTextQuery = {
+    $text: string | {
+        text: string;
+        operator?: Operator;
+    };
+};
+export type GeoShapeRelation = 'intersects' | 'within' | 'disjoint' | 'contains';
+export type ComparisonGeoShapeQuery = {
+    $geoShape: {
+        geometry: Geometry;
+        relation: GeoShapeRelation;
+    };
+};
+export type ComparisonGeoDistanceQuery = {
+    $geoDistance: {
+        longitude: number;
+        latitude: number;
+        /**
+         * Maximum distance in meters
+         */
+        maxDistance?: number;
+        /**
+         * Minimum distance in meters
+         */
+        minDistance?: number;
+    };
+};
+export type TextSpanQueryMode = 'best' | 'most' | 'cross';
+export declare const allTextSpanQueryModes: TextSpanQueryMode[];
+export type TextSpanQuery<T = any> = {
+    $textSpan: {
+        fields: (Extract<keyof T, string>)[];
+        text: string;
+        mode?: TextSpanQueryMode;
+        operator?: Operator;
+    };
+};

package/decorators/log.d.ts

@@ -0,0 +1,3 @@
+import type { WrapLogOptions } from '../function/log.js';
+import type { Decorator } from '../reflection/types.js';
+export declare function Log(options?: WrapLogOptions): Decorator<'class' | 'method'>;

package/disposable/async-disposer.d.ts

@@ -0,0 +1,35 @@
+import { type CancellationSignal, CancellationToken } from '../cancellation/token.js';
+import { type AsyncDisposable, type Disposable } from './disposable.js';
+declare const deferrerToken: unique symbol;
+export type AsyncDisposeTaskFunction = () => any;
+export type AsyncDisposeHandler = AsyncDisposeTaskFunction | Disposable | AsyncDisposable;
+export type AsyncDisposeTask = {
+    taskFunction: AsyncDisposeTaskFunction;
+};
+export type Deferrer = {
+    [deferrerToken]: CancellationToken;
+    yield(): void;
+};
+export declare class AsyncDisposer implements AsyncDisposable, AsyncDisposableStack {
+    #private;
+    get disposingSignal(): CancellationSignal;
+    get disposedSignal(): CancellationSignal;
+    get disposing(): boolean;
+    get disposed(): boolean;
+    readonly [Symbol.toStringTag] = "AsyncDisposable";
+    constructor();
+    use<T extends globalThis.AsyncDisposable | globalThis.Disposable | null | undefined>(value: T): T;
+    adopt<T>(value: T, onDisposeAsync: (value: T) => void | PromiseLike<void>): T;
+    move(): AsyncDisposableStack;
+    getDeferrer(): Deferrer;
+    defer<T>(func: () => Promise<T>): Promise<T>;
+    /**
+     *
+     * @param fnOrDisposable
+     */
+    add(fnOrDisposable: AsyncDisposeHandler): void;
+    disposeAsync(): Promise<void>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export {};

package/distributed-loop/distributed-loop.d.ts

@@ -0,0 +1,32 @@
+import type { CancellationSignal } from '../cancellation/index.js';
+import { resolveArgumentType } from '../injector/index.js';
+import type { Resolvable } from '../injector/interfaces.js';
+import { LockProvider } from '../lock/index.js';
+import type { LoopController } from './controller.js';
+export type LoopFunction = (controller: LoopController) => any | Promise<any>;
+/** loop key */
+export type DistributedLoopArgument = string;
+export declare class DistributedLoop implements Resolvable<DistributedLoopArgument> {
+    private readonly key;
+    private readonly lockProvider;
+    readonly [resolveArgumentType]: string;
+    /**
+     * a loop which runs distributed in the scope of the provided {@link LockProvider}.
+     * There will be at most only one actively running handler at the same time
+     *
+     * you can for example use the MongoLockProvider to have a shared loop over
+     * multiple app processes (cluster) to regularly call an api for updates
+     * @param key loop key to distinguish between multiple loops
+     * @param lockProvider
+     */
+    constructor(key: string, lockProvider: LockProvider);
+    /**
+     * run the function {@link func} every {@link interval} milliseconds with an accuracy of {@link accuracy}
+     * until {@link cancellationSignal} is set or stop on the {@link LoopController} is called
+     * @param interval in millseconds
+     * @param accuracy in millseconds
+     * @param func handler to run
+     * @param cancellationSignal token to cancel loop (same as calling stop on the {@link LoopController})
+     */
+    run(interval: number, accuracy: number, func: LoopFunction, cancellationSignal?: CancellationSignal): LoopController;
+}

package/distributed-loop/provider.d.ts

@@ -0,0 +1,7 @@
+import { LockProvider } from '../lock/index.js';
+import { DistributedLoop } from './distributed-loop.js';
+export declare class DistributedLoopProvider {
+    private readonly lockProvider;
+    constructor(lockProvider: LockProvider);
+    get(key: string): DistributedLoop;
+}