@tstdl/base 0.92.123 → 0.92.124

package/orm/server/transaction.js

@@ -1,5 +1,5 @@
-import { DeferredPromise } from '../../promise/deferred-promise.js';
 import { Subject } from 'rxjs';
+import { DeferredPromise } from '../../promise/deferred-promise.js';
 export class Transaction {
     #afterCommitSubject = new Subject();
     #useCounter = 0;
@@ -36,12 +36,12 @@ export class Transaction {
     }
 }
 export class DrizzleTransaction extends Transaction {
-    transaction;
+    pgTransaction;
     deferPromise = new DeferredPromise();
     pgTransactionPromise;
-    constructor(transaction, pgTransactionPromise) {
+    constructor(pgTransaction, pgTransactionPromise) {
         super();
-        this.transaction = transaction;
+        this.pgTransaction = pgTransaction;
         this.pgTransactionPromise = pgTransactionPromise;
     }
     static async create(session, config) {
@@ -64,7 +64,7 @@ export class DrizzleTransaction extends Transaction {
     }
     _rollback() {
         try {
-            this.transaction.rollback();
+            this.pgTransaction.rollback();
         }
         catch (error) {
             this.deferPromise.reject(error);

package/orm/server/transactional.js

@@ -0,0 +1,134 @@
+import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
+import { createContextProvider } from '../../context/context.js';
+import { Injector } from '../../injector/index.js';
+import { inject, runInInjectionContext } from '../../injector/inject.js';
+import { isDefined, isUndefined } from '../../utils/type-guards.js';
+import { Database } from './database.js';
+import { DrizzleTransaction } from './transaction.js';
+const transactionCache = new WeakMap();
+const { getCurrentTransactionalContext, runInTransactionalContext, isInTransactionalContext } = createContextProvider('Transactional');
+export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext };
+function transactionalContextDataGuardFunction() {
+    throw new Error('function getTransactionalContextData must be implemented to use transactional context data.');
+}
+const transactionalContextDataGuard = new Proxy({}, {
+    apply: transactionalContextDataGuardFunction,
+    construct: transactionalContextDataGuardFunction,
+    defineProperty: transactionalContextDataGuardFunction,
+    deleteProperty: transactionalContextDataGuardFunction,
+    get: transactionalContextDataGuardFunction,
+    getOwnPropertyDescriptor: transactionalContextDataGuardFunction,
+    getPrototypeOf: transactionalContextDataGuardFunction,
+    has: transactionalContextDataGuardFunction,
+    isExtensible: transactionalContextDataGuardFunction,
+    ownKeys: transactionalContextDataGuardFunction,
+    preventExtensions: transactionalContextDataGuardFunction,
+    set: transactionalContextDataGuardFunction,
+    setPrototypeOf: transactionalContextDataGuardFunction,
+});
+export class Transactional {
+    #injector = inject(Injector);
+    #classConstructor;
+    #instanceCache = getCurrentTransactionalContext()?.cache ?? new WeakMap();
+    #context = getCurrentTransactionalContext() ?? {};
+    session = this.#context.session ?? inject(Database);
+    isInTransaction = this.session instanceof DrizzlePgTransaction;
+    constructor() {
+        this.#classConstructor = new.target;
+    }
+    /**
+     * Starts a new database transaction.
+     * @param config Optional transaction configuration.
+     * @returns A promise that resolves to the new Transaction instance.
+     */
+    async startTransaction(config) {
+        if ((config?.useExisting != false) && this.isInTransaction) {
+            const existing = transactionCache.get(this.session);
+            if (isDefined(existing)) {
+                return existing;
+            }
+        }
+        const transaction = await DrizzleTransaction.create(this.session, config);
+        transactionCache.set(transaction.pgTransaction, transaction);
+        return transaction;
+    }
+    /**
+     * Returns a new instance of the repository bound to the provided session.
+     * Useful for performing multiple operations within a single database session.
+     * @param session The session to bind to.
+     * @returns A new repository instance bound to the session.
+     */
+    withSession(session) {
+        if (this.#instanceCache.has(session)) {
+            return this.#instanceCache.get(session);
+        }
+        if (session == this.session) {
+            this.#instanceCache.set(session, this);
+            return this;
+        }
+        const context = {
+            session: session,
+            cache: this.#instanceCache,
+            data: this.getTransactionalContextData(),
+        };
+        const repositoryWithSession = runInInjectionContext(this.#injector, () => runInTransactionalContext(context, () => new this.#classConstructor()));
+        this.#instanceCache.set(session, repositoryWithSession);
+        return repositoryWithSession;
+    }
+    /**
+       * Returns a new instance of the repository bound to the provided transaction, if a transaction is provided.
+       * Otherwise, returns the current instance.
+       * @param transaction The transaction to bind to (optional).
+       * @returns A repository instance bound to the transaction or the current instance.
+       */
+    withOptionalTransaction(transaction) {
+        if (isUndefined(transaction)) {
+            return this;
+        }
+        return this.withTransaction(transaction);
+    }
+    /**
+     * Returns a new instance of the repository bound to the provided transaction.
+     * Useful for performing multiple operations within a single database transaction.
+     * @param transaction The transaction to bind to.
+     * @returns A new repository instance bound to the transaction.
+     */
+    withTransaction(transaction) {
+        return this.withSession(transaction.pgTransaction);
+    }
+    /**
+     * Executes a handler function within the provided transaction. If no transaction is provided,
+     * it starts a new transaction, executes the handler, and commits or rolls back based on the outcome.
+     * @template R The return type of the handler.
+     * @param existingTransaction The transaction to use (optional). Creates a new one otherwise.
+     * @param handler The function to execute within the transaction.
+     * @returns A promise that resolves to the result of the handler function.
+     */
+    async useTransaction(existingTransaction, handler) {
+        if (isUndefined(existingTransaction)) {
+            return this.transaction(handler);
+        }
+        return existingTransaction.use(async () => handler(existingTransaction));
+    }
+    /**
+     * Starts a new transaction, executes the provided handler function within it,
+     * and automatically commits the transaction if the handler succeeds or rolls it back if it throws an error.
+     * @template R The return type of the handler.
+     * @param handler The function to execute within the transaction.
+     * @param config Optional transaction configuration.
+     * @returns A promise that resolves to the result of the handler function.
+     */
+    async transaction(handler, config) {
+        const transaction = await this.startTransaction(config);
+        return transaction.use(async () => handler(transaction));
+    }
+    getTransactionalContextData() {
+        return transactionalContextDataGuard; // eslint-disable-line @typescript-eslint/no-unsafe-return
+    }
+}
+export function tryGetTransactionalContextData(_instance) {
+    return getCurrentTransactionalContext()?.data;
+}
+export function getTransactionalContextData(_instance) {
+    return getCurrentTransactionalContext(true, getTransactionalContextData).data;
+}

package/orm/sqls.js

@@ -1,25 +1,85 @@
+/**
+ * @module
+ * Provides utility SQL functions and constants for use with Drizzle ORM,
+ * simplifying common SQL operations like generating UUIDs, working with intervals,
+ * and aggregating data.
+ */
 import { sql } from 'drizzle-orm';
+/** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
+/** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
 export const RANDOM_UUID = sql `gen_random_uuid()`;
+/**
+ * Creates a Drizzle SQL interval expression.
+ * @param value - The numeric value of the interval.
+ * @param unit - The unit of the interval (e.g., 'day', 'hour').
+ * @returns A Drizzle SQL object representing the interval.
+ */
 export function interval(value, unit) {
     return sql `(${value} ||' ${sql.raw(unit)}')::interval`;
 }
+/**
+ * Creates a Drizzle SQL `array_agg` aggregate function call.
+ * Aggregates values from a column into a PostgreSQL array.
+ * @template T - The Drizzle column type.
+ * @param column - The column to aggregate.
+ * @returns A Drizzle SQL object representing the aggregated array.
+ */
 export function arrayAgg(column) {
     return sql `array_agg(${column})`;
 }
+/**
+ * Creates a Drizzle SQL `json_agg` aggregate function call.
+ * Aggregates rows or column values into a JSON array.
+ * @template T - The Drizzle table or column type.
+ * @param tableOrColumn - The table or column to aggregate into JSON.
+ * @returns A Drizzle SQL object representing the JSON aggregated array.
+ */
 export function jsonAgg(tableOrColumn) {
     return sql `json_agg(${tableOrColumn})`;
 }
+/**
+ * Variant of `jsonAgg` that includes null values in the resulting JSON array.
+ * @template T - The Drizzle table or column type.
+ * @param tableOrColumn - The table or column to aggregate into JSON.
+ * @returns A Drizzle SQL object representing the JSON aggregated array, potentially containing nulls.
+ */
 jsonAgg.withNull = jsonAgg;
+/**
+ * Creates a Drizzle SQL `coalesce` function call.
+ * Returns the first non-null value from the provided list of columns or SQL expressions.
+ * @template T - An array type of Drizzle Columns or SQL expressions.
+ * @param columns - The columns or SQL expressions to check.
+ * @returns A Drizzle SQL object representing the coalesced value.
+ */
 export function coalesce(...columns) {
     return sql `coalesce(${sql.join(columns, sql.raw(', '))})`;
 }
+/**
+ * Creates a Drizzle SQL `to_jsonb` function call.
+ * Converts the input column or SQL expression to a JSONB value.
+ * @template T - The Drizzle column or SQL expression type.
+ * @param column - The column or SQL expression to convert.
+ * @returns A Drizzle SQL object representing the value as JSONB.
+ */
 export function toJsonb(column) {
     return sql `to_jsonb(${column})`;
 }
+/**
+ * Creates a Drizzle SQL `num_nulls` function call.
+ * Counts the number of null arguments.
+ * @param columns - The columns to check for nulls.
+ * @returns A Drizzle SQL object representing the count of nulls.
+ */
 export function numNulls(...columns) {
     return sql `num_nulls(${sql.join(columns, sql.raw(', '))})`;
 }
+/**
+ * Creates a Drizzle SQL `num_nonnulls` function call.
+ * Counts the number of non-null arguments.
+ * @param columns - The columns to check for non-nulls.
+ * @returns A Drizzle SQL object representing the count of non-nulls.
+ */
 export function numNonNulls(...columns) {
     return sql `num_nonnulls(${sql.join(columns, sql.raw(', '))})`;
 }

package/orm/utils.js

@@ -1,6 +1,18 @@
+/**
+ * Converts an array of entities into a Map keyed by entity ID.
+ * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
+ * @param entities - An array of entities.
+ * @returns A Map where keys are entity IDs and values are the corresponding entities.
+ */
 export function getEntityMap(entities) {
     return new Map(entities.map((entity) => [entity.id, entity]));
 }
+/**
+ * Extracts the IDs from an array of entities.
+ * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
+ * @param entities - An array of entities.
+ * @returns An array containing the IDs of the entities.
+ */
 export function getEntityIds(entities) {
     return entities.map((entity) => entity.id);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.123",
+  "version": "0.92.124",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -28,6 +28,7 @@
     "copy:orm:mail": "rm -rf ./dist/mail/drizzle && cp -r ./source/mail/drizzle ./dist/mail/",
     "copy:orm:queue": "rm -rf ./dist/queue/postgres/drizzle && cp -r ./source/queue/postgres/drizzle ./dist/queue/postgres/"
   },
+  "types": "types/",
   "exports": {
     "./tsconfig.json": "./tsconfig.json",
     "./eslint.config.js": "./eslint.config.js",
@@ -124,6 +125,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 +135,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 +142,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.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.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.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,
     };
 }