@tstdl/base 0.92.123 → 0.92.125

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.123",
+  "version": "0.92.125",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -124,6 +124,7 @@
     "./types/geo-json": "./types/geo-json.js",
     "./utils": "./utils/index.js",
     "./utils/array": "./utils/array/index.js",
+    "./utils/async-hook": "./utils/async-hook/index.js",
     "./utils/async-iterable-helpers": "./utils/async-iterable-helpers/index.js",
     "./utils/async-iterable-helpers/parallel": "./utils/async-iterable-helpers/parallel/index.js",
     "./utils/function": "./utils/function/index.js",
@@ -133,8 +134,6 @@
     "./utils/string": "./utils/string/index.js"
   },
   "dependencies": {
-    "@google-cloud/storage": "^7.16",
-    "@google-cloud/vertexai": "^1.9",
     "disposablestack": "^1.1",
     "luxon": "^3.6",
     "reflect-metadata": "^0.2",
@@ -142,52 +141,54 @@
     "ts-pattern": "^5.7",
     "type-fest": "4.37"
   },
-  "devDependencies": {
-    "@biomejs/biome": "1.9",
-    "@stylistic/eslint-plugin": "4.2",
-    "@types/chroma-js": "2.4",
-    "@types/koa__router": "12.0",
-    "@types/luxon": "3.6",
-    "@types/minio": "7.1",
-    "@types/mjml": "4.7",
-    "@types/node": "22",
-    "@types/nodemailer": "6.4",
-    "@types/pg": "8.11",
-    "@typescript-eslint/eslint-plugin": "8.29",
-    "concurrently": "9.1",
-    "drizzle-kit": "0.30",
-    "eslint": "9.23",
-    "globals": "16.0",
-    "tsc-alias": "1.8",
-    "typescript": "5.8"
-  },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.17",
-    "@google/generative-ai": "^0.24",
+    "@elastic/elasticsearch": "^9.0",
+    "@google-cloud/storage": "7.16",
+    "@google/genai": "^1.0",
     "@tstdl/angular": "^0.92",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
-    "drizzle-orm": "^0.41",
+    "drizzle-orm": "^0.43",
     "handlebars": "^4.7",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.15",
-    "nodemailer": "^6.10",
-    "pg": "^8.14",
-    "playwright": "^1.51",
+    "mongodb": "^6.16",
+    "nodemailer": "^7.0",
+    "pg": "^8.16",
+    "playwright": "^1.52",
     "preact": "^10.26",
     "preact-render-to-string": "^6.5",
-    "undici": "^7.7",
-    "urlpattern-polyfill": "^10.0"
+    "sharp": "^0.34",
+    "undici": "^7.10",
+    "urlpattern-polyfill": "^10.1"
   },
   "peerDependenciesMeta": {
     "@tstdl/angular": {
       "optional": true
     }
   },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "4.2",
+    "@types/chroma-js": "2.4",
+    "@types/koa__router": "12.0",
+    "@types/luxon": "3.6",
+    "@types/minio": "7.1",
+    "@types/mjml": "4.7",
+    "@types/node": "22",
+    "@types/nodemailer": "6.4",
+    "@types/pg": "8.15",
+    "@typescript-eslint/eslint-plugin": "8.32",
+    "concurrently": "9.1",
+    "drizzle-kit": "0.31",
+    "eslint": "9.27",
+    "globals": "16.1",
+    "tsc-alias": "1.8",
+    "typedoc-plugin-missing-exports": "4.0",
+    "typescript": "5.8"
+  },
   "overrides": {
     "drizzle-kit": {
       "@esbuild-kit/esm-loader": "^2.6",

package/password/password-check-result.model.d.ts

@@ -1,10 +1,12 @@
-export declare enum PasswordStrength {
-    VeryWeak = 0,
-    Weak = 1,
-    Medium = 2,
-    Strong = 3,
-    VeryStrong = 4
-}
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const PasswordStrength: {
+    readonly VeryWeak: 0;
+    readonly Weak: 1;
+    readonly Medium: 2;
+    readonly Strong: 3;
+    readonly VeryStrong: 4;
+};
+export type PasswordStrength = EnumType<typeof PasswordStrength>;
 export declare class PasswordCheckResult {
     strength: PasswordStrength;
     /**

package/password/password-check-result.model.js

@@ -7,17 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+import { defineEnum } from '../enumeration/enumeration.js';
 import { NumberProperty } from '../schema/index.js';
 import { Array } from '../schema/schemas/array.js';
 import { Enumeration } from '../schema/schemas/enumeration.js';
-export var PasswordStrength;
-(function (PasswordStrength) {
-    PasswordStrength[PasswordStrength["VeryWeak"] = 0] = "VeryWeak";
-    PasswordStrength[PasswordStrength["Weak"] = 1] = "Weak";
-    PasswordStrength[PasswordStrength["Medium"] = 2] = "Medium";
-    PasswordStrength[PasswordStrength["Strong"] = 3] = "Strong";
-    PasswordStrength[PasswordStrength["VeryStrong"] = 4] = "VeryStrong";
-})(PasswordStrength || (PasswordStrength = {}));
+export const PasswordStrength = defineEnum('PasswordStrength', {
+    VeryWeak: 0,
+    Weak: 1,
+    Medium: 2,
+    Strong: 3,
+    VeryStrong: 4,
+});
 export class PasswordCheckResult {
     strength;
     /**

package/password/password-check.js

@@ -7,7 +7,7 @@ export async function checkPassword(password, { checkForPwned = true } = {}) {
     const zxcvbn = await getZxcvbn();
     const [zxcvbnResult, pwnedResult] = await Promise.all([
         zxcvbn(password),
-        checkForPwned ? Promise.race([haveIBeenPwned(password).catch(() => undefined), timeout(1000).then(() => undefined)]) : undefined
+        checkForPwned ? Promise.race([haveIBeenPwned(password).catch(() => undefined), timeout(1000).then(() => undefined)]) : undefined,
     ]);
     const pwnedWarnings = (isNotNullOrUndefined(pwnedResult) && (pwnedResult > 0)) ? [passwordCheckLocalizationKeys.tstdl.passwordCheck.warnings.pwned[propertyName]] : [];
     const warnings = isNotNullOrUndefined(zxcvbnResult.feedback.warning)
@@ -19,7 +19,7 @@ export async function checkPassword(password, { checkForPwned = true } = {}) {
         strength: ((pwnedResult ?? 0) > 0) ? 0 : zxcvbnResult.score,
         pwned: pwnedResult,
         warnings,
-        suggestions
+        suggestions,
     };
 }
 let zxcvbnAsyncInstance;
@@ -32,11 +32,9 @@ async function getZxcvbn() {
 async function importZxcvbn() {
     const [{ zxcvbnAsync, zxcvbnOptions }, common, english, german] = await Promise.all([
         import('@zxcvbn-ts/core'),
-        /* eslint-disable @typescript-eslint/no-unnecessary-condition */
         import('@zxcvbn-ts/language-common'),
         import('@zxcvbn-ts/language-en'),
-        import('@zxcvbn-ts/language-de')
-        /* eslint-enable @typescript-eslint/no-unnecessary-condition */
+        import('@zxcvbn-ts/language-de'),
     ]);
     const options = {
         graphs: common.adjacencyGraphs,
@@ -44,8 +42,8 @@ async function importZxcvbn() {
         dictionary: {
             ...common.dictionary,
             ...english.dictionary,
-            ...german.dictionary
-        }
+            ...german.dictionary,
+        },
     };
     zxcvbnOptions.setOptions(options);
     return zxcvbnAsync;

package/password/password-check.localization.js

@@ -21,7 +21,7 @@ export const germanPasswordCheckLocalization = {
                     namesByThemselves: 'Einzelne Namen oder Nachnamen sind leicht zu erraten.',
                     commonNames: 'Vornamen und Nachnamen sind leicht zu erraten.',
                     userInputs: 'Es sollten keine persönlichen oder Seiten relevanten Daten vorkommen.',
-                    pwned: 'Ihr Kennwort wurde durch eine Datenpanne im Internet offengelegt (https://haveibeenpwned.com/passwords).'
+                    pwned: 'Ihr Kennwort wurde durch eine Datenpanne im Internet offengelegt (https://haveibeenpwned.com/passwords).',
                 },
                 suggestions: {
                     l33t: 'Vorhersehbare Buchstabenersetzungen wie \'@\' für \'a\' vermeiden.',
@@ -37,12 +37,12 @@ export const germanPasswordCheckLocalization = {
                     anotherWord: 'Weitere Wörter, die weniger häufig vorkommen, hinzufügen.',
                     useWords: 'Mehrere Wörter verwenden, aber allgemeine Phrasen vermeiden.',
                     noNeed: 'Es ist möglich, starke Passwörter zu erstellen, ohne Symbole, Zahlen oder Großbuchstaben zu verwenden.',
-                    pwned: 'Wenn Sie dieses Kennwort an anderer Stelle verwenden, sollten Sie es ändern.'
-                }
-            }
-        }
+                    pwned: 'Wenn Sie dieses Kennwort an anderer Stelle verwenden, sollten Sie es ändern.',
+                },
+            },
+        },
     },
-    enums: []
+    enums: [],
 };
 export const englishPasswordCheckLocalization = {
     language: { code: 'en', name: 'English' },
@@ -65,7 +65,7 @@ export const englishPasswordCheckLocalization = {
                     namesByThemselves: 'Single names or surnames are easy to guess.',
                     commonNames: 'Common names and surnames are easy to guess.',
                     userInputs: 'There should not be any personal or page related data.',
-                    pwned: 'Your password was exposed by a data breach on the Internet (https://haveibeenpwned.com/passwords).'
+                    pwned: 'Your password was exposed by a data breach on the Internet (https://haveibeenpwned.com/passwords).',
                 },
                 suggestions: {
                     l33t: 'Avoid predictable letter substitutions like \'@\' for \'a\'.',
@@ -81,10 +81,10 @@ export const englishPasswordCheckLocalization = {
                     anotherWord: 'Add more words that are less common.',
                     useWords: 'Use multiple words, but avoid common phrases.',
                     noNeed: 'You can create strong passwords without using symbols, numbers, or uppercase letters.',
-                    pwned: 'If you use this password elsewhere, you should change it.'
-                }
-            }
-        }
+                    pwned: 'If you use this password elsewhere, you should change it.',
+                },
+            },
+        },
     },
-    enums: []
+    enums: [],
 };

package/pdf/pdf.service.js

@@ -21,7 +21,7 @@ import { Logger } from '../logger/logger.js';
 import { Optional } from '../schema/index.js';
 import { Template, TemplateService } from '../templates/index.js';
 import { finalizeStream } from '../utils/stream/finalize-stream.js';
-import { readableStreamFromPromise } from '../utils/stream/readable-stream-from-promise.js';
+import { readableStreamFromPromise } from '../utils/stream/from-promise.js';
 import { readBinaryStream } from '../utils/stream/stream-reader.js';
 import { timeout } from '../utils/timing.js';
 import { isDefined } from '../utils/type-guards.js';

package/pdf/utils.d.ts

@@ -1,3 +1,12 @@
 export declare function getPdfPageCount(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<number>;
 export declare function mergePdfs(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<Uint8Array>;
 export declare function mergePdfsStream(pdfs: (string | Uint8Array | ReadableStream<Uint8Array>)[]): Promise<ReadableStream<Uint8Array>>;
+/**
+ * Convert a PDF page to an image.
+ * @param file The PDF file to convert.
+ * @param page The page number to convert.
+ * @param size The size of the output image.
+ * @param format The format of the output image.
+ * @returns The converted image as a byte array.
+ */
+export declare function pdfToImage(file: string | Uint8Array | ReadableStream<Uint8Array>, page: number, size: number, format: 'png' | 'jpeg' | 'tiff' | 'ps' | 'eps' | 'pdf' | 'svg'): Promise<Uint8Array>;

package/pdf/utils.js

@@ -52,12 +52,12 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { TemporaryFile } from '../file/server/temporary-file.js';
 import { spawnCommand } from '../process/spawn.js';
-import { isString } from '../utils/type-guards.js';
+import { isNotString, isString } from '../utils/type-guards.js';
 export async function getPdfPageCount(file) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const fileIsPath = isString(file);
-        const tmpFile = __addDisposableResource(env_1, fileIsPath ? await TemporaryFile.from(file) : undefined, true);
+        const tmpFile = __addDisposableResource(env_1, fileIsPath ? undefined : await TemporaryFile.from(file), true);
         const path = fileIsPath ? file : tmpFile.path;
         const process = await spawnCommand('qpdf', ['--show-npages', path]);
         const { code } = await process.wait();
@@ -134,3 +134,20 @@ async function pdfunite(sourceFiles, resultFile) {
         throw new Error(errorOutput);
     }
 }
+/**
+ * Convert a PDF page to an image.
+ * @param file The PDF file to convert.
+ * @param page The page number to convert.
+ * @param size The size of the output image.
+ * @param format The format of the output image.
+ * @returns The converted image as a byte array.
+ */
+export async function pdfToImage(file, page, size, format) {
+    const path = isString(file) ? file : '-';
+    const process = await spawnCommand('pdftocairo', ['-f', String(page), '-l', String(page), '-scale-to', String(size), '-singlefile', `-${format}`, path, '-']);
+    process.handleNonZeroExitCode();
+    if (isNotString(file)) {
+        process.autoWrite(file);
+    }
+    return process.readOutputBytes();
+}

package/process/spawn.d.ts

@@ -1,15 +1,22 @@
 import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+type WaitOptions = {
+    throwOnNonZeroExitCode?: boolean;
+};
+type ProcessResult = {
+    code: number | null;
+    signal: string | null;
+};
 export type SpawnCommandResult = TransformStream<Uint8Array, Uint8Array> & {
     process: ChildProcessWithoutNullStreams;
     stderr: ReadableStream<Uint8Array>;
     write(chunk: ReadableStream<Uint8Array> | Uint8Array | string, options?: StreamPipeOptions): Promise<void>;
+    autoWrite(chunk: ReadableStream<Uint8Array> | Uint8Array | string, options?: StreamPipeOptions): void;
     readOutputBytes(): Promise<Uint8Array>;
     readOutput(): Promise<string>;
     readErrorBytes(): Promise<Uint8Array>;
     readError(): Promise<string>;
-    wait(): Promise<{
-        code: number | null;
-        signal: string | null;
-    }>;
+    handleNonZeroExitCode(): void;
+    wait(options?: WaitOptions): Promise<ProcessResult>;
 };
 export declare function spawnCommand(command: string, args?: string[]): Promise<SpawnCommandResult>;
+export {};

package/process/spawn.js

@@ -1,15 +1,16 @@
 import { dynamicImport } from '../import.js';
+import { LazyPromise } from '../promise/lazy-promise.js';
 import { decodeTextStream, encodeUtf8Stream } from '../utils/encoding.js';
 import { readBinaryStream, readTextStream } from '../utils/stream/stream-reader.js';
 import { toReadableStream } from '../utils/stream/to-readable-stream.js';
-import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
+import { assertNotNullOrUndefinedPass, isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
 export async function spawnCommand(command, args) {
     const { spawn } = await dynamicImport('node:child_process');
     const { Readable, Writable } = await dynamicImport('node:stream');
     const process = spawn(command, args, { stdio: 'pipe' });
     await Promise.race([
         new Promise((resolve) => process.on('spawn', resolve)),
-        new Promise((_, reject) => process.on('error', reject))
+        new Promise((_, reject) => process.on('error', reject)),
     ]);
     const readable = Readable.toWeb(process.stdout);
     const writable = Writable.toWeb(process.stdin);
@@ -25,6 +26,12 @@ export async function spawnCommand(command, args) {
             await toReadableStream(data).pipeThrough(encodeUtf8Stream()).pipeTo(writable, options);
         }
     }
+    function autoWrite(data, options) {
+        write(data, options).catch((error) => {
+            readable.cancel(error).catch(() => { });
+            writable.abort(error).catch(() => { });
+        });
+    }
     async function readOutputBytes() {
         return readBinaryStream(readable);
     }
@@ -38,18 +45,48 @@ export async function spawnCommand(command, args) {
         return readTextStream(stderr.pipeThrough(decodeTextStream()));
     }
     const signalPromise = new Promise((resolve) => process.on('close', (code, signal) => resolve({ code, signal })));
+    const nonZeroExitCodeError = new LazyPromise(async () => {
+        const result = await signalPromise;
+        if (result.code != 0) {
+            try {
+                const errorOutput = await readError();
+                return new Error(errorOutput.trim());
+            }
+            catch {
+                return new Error(`Process exited with code ${result.code} and signal ${result.signal}.`);
+            }
+        }
+        return null;
+    });
+    async function handleNonZeroExitCode() {
+        const error = await nonZeroExitCodeError;
+        if (error) {
+            console.log('ERROR HAPPENED', error);
+            await writable.abort(error).catch(() => { });
+            await readable.cancel(error).catch(() => { });
+        }
+    }
+    async function wait({ throwOnNonZeroExitCode = true } = {}) {
+        const result = await signalPromise;
+        const handleNonZeroExitCode = (result.code != 0) && throwOnNonZeroExitCode;
+        if (handleNonZeroExitCode) {
+            const error = await nonZeroExitCodeError;
+            throw assertNotNullOrUndefinedPass(error);
+        }
+        return result;
+    }
     return {
         process,
         readable,
         writable,
         stderr,
         write,
+        autoWrite,
         readOutputBytes,
         readOutput,
         readErrorBytes,
         readError,
-        async wait() {
-            return signalPromise;
-        }
+        handleNonZeroExitCode: () => void handleNonZeroExitCode(),
+        wait,
     };
 }

package/queue/postgres/queue.js

@@ -34,12 +34,12 @@ let PostgresQueue = class PostgresQueue extends Queue {
         tries: 0,
         enqueueTimestamp: TRANSACTION_TIMESTAMP,
         lastDequeueTimestamp: null,
-        data: sql `excluded.data`
+        data: sql `excluded.data`,
     };
     #dequeueQuery = and(eq(job.queue, this.#queueName), lt(job.tries, this.maxTries), or(isSqlNull(job.lastDequeueTimestamp), lte(sql `${job.lastDequeueTimestamp} + ${interval(this.processTimeout, 'milliseconds')}`, TRANSACTION_TIMESTAMP)));
     #dequeueUpdate = {
         tries: sql `${job.tries} + 1`,
-        lastDequeueTimestamp: TRANSACTION_TIMESTAMP
+        lastDequeueTimestamp: TRANSACTION_TIMESTAMP,
     };
     async enqueue(data, options) {
         const jobs = await this.enqueueMany([{ data, tag: options?.tag, priority: options?.priority }], { uniqueTag: options?.uniqueTag, returnJobs: true });
@@ -53,7 +53,7 @@ let PostgresQueue = class PostgresQueue extends Queue {
             tries: 0,
             enqueueTimestamp: TRANSACTION_TIMESTAMP,
             lastDequeueTimestamp: null,
-            data: item.data
+            data: item.data,
         }));
         const update = (options?.uniqueTag == UniqueTagStrategy.TakeNew)
             ? this.#takeNewUpdate
@@ -157,8 +157,8 @@ PostgresQueue = __decorate([
         argumentIdentityProvider: JSON.stringify,
         providers: [
             provide(EntityRepositoryConfig, { useValue: { schema: 'queue' } }),
-            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) })
-        ]
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresQueueModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
+        ],
     })
 ], PostgresQueue);
 export { PostgresQueue };

package/queue/queue.d.ts

@@ -1,4 +1,5 @@
 import type { CancellationSignal } from '../cancellation/token.js';
+import { type EnumType } from '../enumeration/enumeration.js';
 import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
 import type { Logger } from '../logger/logger.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
@@ -19,10 +20,11 @@ export type Job<T> = {
     tries: number;
 };
 export declare const defaultJobPriority = 1000;
-export declare enum UniqueTagStrategy {
-    KeepOld = 0,
-    TakeNew = 1
-}
+export declare const UniqueTagStrategy: {
+    readonly KeepOld: 0;
+    readonly TakeNew: 1;
+};
+export type UniqueTagStrategy = EnumType<typeof UniqueTagStrategy>;
 export type EnqueueOptions = {
     tag?: JobTag;
     priority?: number;

package/queue/queue.js

@@ -1,14 +1,14 @@
+import { defineEnum } from '../enumeration/enumeration.js';
 import { millisecondsPerMinute } from '../utils/units.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
 export const defaultJobPriority = 1000;
-export var UniqueTagStrategy;
-(function (UniqueTagStrategy) {
-    UniqueTagStrategy[UniqueTagStrategy["KeepOld"] = 0] = "KeepOld";
-    UniqueTagStrategy[UniqueTagStrategy["TakeNew"] = 1] = "TakeNew";
-})(UniqueTagStrategy || (UniqueTagStrategy = {}));
+export const UniqueTagStrategy = defineEnum('UniqueTagStrategy', {
+    KeepOld: 0,
+    TakeNew: 1,
+});
 export const defaultQueueConfig = {
     processTimeout: millisecondsPerMinute,
-    maxTries: 3
+    maxTries: 3,
 };
 export class Queue {
     batch() {

package/schema/schemas/one-or-many.d.ts

@@ -2,7 +2,8 @@ import type { JsonPath } from '../../json-path/json-path.js';
 import type { OneOrMany as OneOrManyType } from '../../types.js';
 import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-export type OneOrManySchemaOptions<T> = SchemaOptions<T | T[]>;
+import { type ArraySchemaOptions } from './array.js';
+export type OneOrManySchemaOptions<T> = SchemaOptions<T | T[]> & Pick<ArraySchemaOptions<T>, 'minimum' | 'maximum'>;
 export type OneOrMany<T> = OneOrManyType<T>;
 export declare class OneOrManySchema<T> extends Schema<T | T[]> {
     readonly name: string;

package/schema/schemas/one-or-many.js

@@ -10,7 +10,7 @@ export class OneOrManySchema extends Schema {
     constructor(schema, options) {
         super(options);
         const oneSchema = schemaTestableToSchema(schema);
-        this.schema = union(oneSchema, array(oneSchema));
+        this.schema = union(oneSchema, array(oneSchema, { minimum: options?.minimum, maximum: options?.maximum }));
         lazyProperty(this, 'name', () => `OneOrMany[${oneSchema.name}]`);
     }
     _test(value, path, options) {

package/search-index/elastic/model/index-mapping.d.ts

@@ -1,6 +1,6 @@
+import type { estypes } from '@elastic/elasticsearch';
 import type { Entity } from '../../../database/index.js';
 import type { DeepFlatten, StringMap, TypedOmit } from '../../../types.js';
-import type { estypes } from '@elastic/elasticsearch';
 export type ElasticIndexMapping<T extends Entity = Entity> = TypedOmit<estypes.MappingTypeMapping, 'properties'> & ElasticNestedIndexMapping<TypedOmit<T, 'id'>>;
 export type ElasticNestedIndexMapping<T> = {
     properties: {

package/search-index/elastic/model/index-mapping.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/naming-convention */
 import { mergeObjects } from '../../../utils/object/merge.js';
 export function mergeElasticSearchMappings(mappings) {
     return mergeObjects(mappings);

package/search-index/elastic/search-index.d.ts

@@ -1,11 +1,10 @@
-import type { Client } from '@elastic/elasticsearch';
+import type { Client, estypes } from '@elastic/elasticsearch';
 import type { Entity, Query, QueryOptions } from '../../database/index.js';
 import type { AfterResolve } from '../../injector/interfaces.js';
 import { afterResolve } from '../../injector/interfaces.js';
 import type { Logger } from '../../logger/index.js';
 import type { SearchResult } from '../../search-index/index.js';
 import { SearchIndex } from '../../search-index/index.js';
-import type { estypes } from '@elastic/elasticsearch';
 import type { ElasticSearchIndexConfig } from './config.js';
 import { KeywordRewriter } from './keyword-rewriter.js';
 import type { ElasticIndexMapping } from './model/index.js';

package/search-index/elastic/search-index.js

@@ -43,10 +43,10 @@ export class ElasticSearchIndex extends SearchIndex {
         await this.client.indices.close({ index: this.indexName });
         this.logger.info(`closed index ${this.indexName} for updates`);
         this.logger.info(`updating settings for index ${this.indexName}`);
-        await this.client.indices.putSettings({ index: this.indexName, body: this.indexSettings });
+        await this.client.indices.putSettings({ index: this.indexName, settings: this.indexSettings });
         this.logger.info(`updated settings for index ${this.indexName}`);
         this.logger.info(`updating mapping for index ${this.indexName}`);
-        await this.client.indices.putMapping({ index: this.indexName, body: this.indexMapping });
+        await this.client.indices.putMapping({ index: this.indexName, ...this.indexMapping });
         this.logger.info(`updated mapping for index ${this.indexName}`);
         this.logger.info(`reopening index ${this.indexName}`);
         await this.client.indices.open({ index: this.indexName });
@@ -82,7 +82,7 @@ export class ElasticSearchIndex extends SearchIndex {
     }
     async deleteByQuery(query) {
         const queryBody = convertQuery(query);
-        await this.client.deleteByQuery({ index: this.indexName, body: { query: queryBody } });
+        await this.client.deleteByQuery({ index: this.indexName, query: queryBody });
     }
     // eslint-disable-next-line max-statements
     async search(searchQueryOrCursor, options) {

package/types.d.ts

@@ -100,6 +100,7 @@ export type OptionalKeys<T> = {
     [K in keyof T]-?: ObjectLiteral extends Pick<T, K> ? K : never;
 }[keyof T];
 export type TypedOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type TypedExclude<T, U extends T> = T extends U ? never : T;
 export type TypedExtract<T, U extends T> = T extends U ? T : never;
 export type ReplaceIfUnknown<T, U> = IfUnknown<T, U, T>;
 export type OmitNever<T extends Record> = {

package/utils/async-hook/async-hook.d.ts

@@ -0,0 +1,9 @@
+export type AsyncHook<T, C = never, R = unknown> = {
+    register: (handler: AsyncHookHandler<T, C, R>) => AsyncHookHandlerRegistration;
+    trigger: [C] extends [never] ? ((value: T) => Promise<R[]>) : ((value: T, context: C) => Promise<R[]>);
+};
+export type AsyncHookHandler<T, C, R> = [C] extends [never] ? ((value: T) => R | Promise<R>) : ((value: T, context: C) => R | Promise<R>);
+export type AsyncHookHandlerRegistration = {
+    unregister: () => void;
+};
+export declare function asyncHook<T, C = never, R = unknown>(): AsyncHook<T, C, R>;

package/utils/async-hook/async-hook.js

@@ -0,0 +1,21 @@
+export function asyncHook() {
+    const handlers = [];
+    return {
+        register: (handler) => {
+            handlers.push(handler);
+            return {
+                unregister() {
+                    handlers.splice(handlers.indexOf(handler));
+                },
+            };
+        },
+        trigger: async (value, context) => {
+            let returnValues = [];
+            for (const handler of handlers) {
+                const returnValue = await handler(value, context);
+                returnValues.push(returnValue);
+            }
+            return returnValues;
+        },
+    };
+}

package/utils/async-hook/index.d.ts

@@ -0,0 +1 @@
+export * from './async-hook.js';

package/utils/async-hook/index.js

@@ -0,0 +1 @@
+export * from './async-hook.js';

package/utils/compression.js

@@ -1,7 +1,7 @@
 import { dynamicImport } from '../import.js';
 import { encodeBase64, encodeBase64Url } from './base64.js';
 import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
-import { readableStreamFromPromise } from './stream/readable-stream-from-promise.js';
+import { readableStreamFromPromise } from './stream/from-promise.js';
 import { assertDefined, isNotNullOrUndefined } from './type-guards.js';
 import { zBase32Encode } from './z-base32.js';
 export function compressString(input, algorithm, options) {

package/utils/function/class.d.ts

@@ -0,0 +1,6 @@
+import type { AbstractConstructor } from '../../types.js';
+declare class EmptyClass {
+}
+export declare function getClassOfName(name: string): typeof EmptyClass;
+export declare function getClassOfName<T extends AbstractConstructor>(name: string, extend: T): T;
+export {};