@tstdl/base 0.93.2 → 0.93.3

package/orm/index.js

@@ -3,10 +3,11 @@
  *
  * @module ORM
  */
-export * from './data-types/index.js';
+export * from './decorators.js';
 export * from './entity.js';
 export * from './query.js';
 export * from './repository.types.js';
+export * from './schemas/index.js';
 export * from './sqls.js';
 export * from './types.js';
 export * from './utils.js';

package/orm/schemas/json.d.ts

@@ -12,4 +12,4 @@ export declare class JsonSchema<T> extends Schema<T> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
 }
 export declare function json<T>(options?: JsonSchemaOptions<T>): JsonSchema<T>;
-export declare function Json(options?: JsonSchemaOptions<any> & TypedOmit<SchemaDecoratorOptions, 'schema'>): Decorator<'class' | 'property' | 'accessor'>;
+export declare function JsonProperty(options?: JsonSchemaOptions<any> & TypedOmit<SchemaDecoratorOptions, 'schema'>): Decorator<'class' | 'property' | 'accessor'>;

package/orm/schemas/json.js

@@ -15,7 +15,7 @@ export class JsonSchema extends Schema {
 export function json(options) {
     return new JsonSchema(options);
 }
-export function Json(options) {
+export function JsonProperty(options) {
     const { schema, ...optionsRest } = options ?? {};
     return createDecorator({ class: true, property: true, accessor: true }, (data, metadata, args) => {
         if (data.type == 'class') {

package/orm/schemas/numeric-date.d.ts

@@ -5,4 +5,4 @@ export declare class NumericDateSchema extends NumberSchema {
     constructor(options?: NumericDateSchemaOptions);
 }
 export declare function numericDate(options?: NumericDateSchemaOptions): NumericDateSchema;
-export declare function NumericDate(options?: NumericDateSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;
+export declare function NumericDateProperty(options?: NumericDateSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/numeric-date.js

@@ -8,6 +8,6 @@ export class NumericDateSchema extends NumberSchema {
 export function numericDate(options) {
     return new NumericDateSchema(options);
 }
-export function NumericDate(options) {
+export function NumericDateProperty(options) {
     return Property(numericDate(options), options);
 }

package/orm/schemas/timestamp.d.ts

@@ -7,4 +7,4 @@ export declare class TimestampSchema extends NumberSchema {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<number>;
 }
 export declare function timestamp(options?: TimestampSchemaOptions): TimestampSchema;
-export declare function Timestamp(options?: TimestampSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;
+export declare function TimestampProperty(options?: TimestampSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/timestamp.js

@@ -15,6 +15,6 @@ export class TimestampSchema extends NumberSchema {
 export function timestamp(options) {
     return new TimestampSchema(options);
 }
-export function Timestamp(options) {
+export function TimestampProperty(options) {
     return Property(timestamp(options), options);
 }

package/orm/schemas/uuid.d.ts

@@ -1,4 +1,4 @@
-import { StringSchema, type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../../schema/index.js';
+import { StringSchema, type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../../schema/index.js';
 export type UuidSchemaOptions = {
     defaultRandom?: boolean;
 };
@@ -8,4 +8,4 @@ export declare class UuidSchema extends StringSchema {
     constructor(options?: UuidSchemaOptions);
 }
 export declare function uuid(options?: UuidSchemaOptions): UuidSchema;
-export declare function Uuid(options?: UuidSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;
+export declare function UuidProperty(options?: UuidSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/uuid.js

@@ -11,6 +11,6 @@ export class UuidSchema extends StringSchema {
 export function uuid(options) {
     return new UuidSchema(options);
 }
-export function Uuid(options) {
+export function UuidProperty(options) {
     return Property(uuid(options), options);
 }

package/orm/server/repository.d.ts

@@ -279,7 +279,7 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
      */
     deleteMany(ids: string[], metadataUpdate?: EntityMetadataUpdate): Promise<T[]>;
     /**
-     * Deletes multiple entities matching a query (soft delete if metadata is available).
+     * Deletes multiple entities matching a query (soft delete if metadata is available). Already deleted entities are ignored.
      * @param query The query to filter entities.
      * @param metadataUpdate Optional metadata update to apply during soft delete.
      * @returns A promise that resolves to an array of the deleted entities.

package/orm/server/repository.js

@@ -62,13 +62,14 @@ let EntityRepository = class EntityRepository extends Transactional {
         }
     }
     async expirationLoop() {
-        const softExpirationColumns = this.#columnDefinitions.filter((column) => column.reflectionData?.expirationField?.mode == 'soft');
-        const hardExpirationColumns = this.#columnDefinitions.filter((column) => column.reflectionData?.expirationField?.mode == 'hard');
+        const expirationColumns = this.#columnDefinitions.filter((column) => isDefined(column.reflectionData?.expirationField));
+        const softExpirationColumns = expirationColumns.filter((column) => column.reflectionData.expirationField.mode == 'soft');
+        const hardExpirationColumns = expirationColumns.filter((column) => column.reflectionData.expirationField.mode == 'hard');
         if ((softExpirationColumns.length + hardExpirationColumns.length) == 0) {
             return;
         }
-        const softDeletionQuery = or(...softExpirationColumns.map((column) => lte(this.getColumn(column), TRANSACTION_TIMESTAMP)));
-        const hardDeletionQuery = or(...hardExpirationColumns.map((column) => lte(this.getColumn(column), TRANSACTION_TIMESTAMP)));
+        const softDeletionQuery = or(...softExpirationColumns.map((column) => lte(sql `${this.getColumn(column)} + INTERVAL '${sql.raw(String(column.reflectionData.expirationField.after))} ms'`, TRANSACTION_TIMESTAMP)));
+        const hardDeletionQuery = or(...hardExpirationColumns.map((column) => lte(sql `${this.getColumn(column)} + INTERVAL '${sql.raw(String(column.reflectionData.expirationField.after))} ms'`, TRANSACTION_TIMESTAMP)));
         assertDefined(this.#cancellationSignal);
         while (this.#cancellationSignal.isUnset) {
             if (isDefined(softDeletionQuery)) {
@@ -550,7 +551,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (!this.hasMetadata) {
             return await this.tryHardDelete(id);
         }
-        const sqlQuery = this.convertQuery(eq(this.#table.id, id));
+        const sqlQuery = and(isNull(this.#tableWithMetadata.deleteTimestamp), this.convertQuery(eq(this.#table.id, id)));
         const [row] = await this.session
             .update(this.#tableWithMetadata)
             .set({
@@ -591,13 +592,14 @@ let EntityRepository = class EntityRepository extends Transactional {
             return await this.tryHardDeleteByQuery(query);
         }
         const idQuery = this.getIdLimitQuery(query).for('update');
+        const sqlQuery = and(isNull(this.#tableWithMetadata.deleteTimestamp), inArray(this.#table.id, idQuery));
         const [row] = await this.session
             .update(this.#tableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
             attributes: this.getAttributesUpdate(metadataUpdate?.attributes),
         })
-            .where(inArray(this.#table.id, idQuery))
+            .where(sqlQuery)
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -617,7 +619,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         return await this.deleteManyByQuery(inArray(this.#table.id, ids), metadataUpdate);
     }
     /**
-     * Deletes multiple entities matching a query (soft delete if metadata is available).
+     * Deletes multiple entities matching a query (soft delete if metadata is available). Already deleted entities are ignored.
      * @param query The query to filter entities.
      * @param metadataUpdate Optional metadata update to apply during soft delete.
      * @returns A promise that resolves to an array of the deleted entities.
@@ -626,7 +628,7 @@ let EntityRepository = class EntityRepository extends Transactional {
         if (!this.hasMetadata) {
             return await this.hardDeleteManyByQuery(query);
         }
-        const sqlQuery = this.convertQuery(query);
+        const sqlQuery = and(isNull(this.#tableWithMetadata.deleteTimestamp), this.convertQuery(query));
         const rows = await this.session
             .update(this.#tableWithMetadata)
             .set({
@@ -690,9 +692,10 @@ let EntityRepository = class EntityRepository extends Transactional {
      */
     async tryHardDeleteByQuery(query) {
         const idQuery = this.getIdLimitQuery(query).for('update');
+        const sqlQuery = inArray(this.#table.id, idQuery);
         const [row] = await this.session
             .delete(this.#table)
-            .where(inArray(this.#table.id, idQuery))
+            .where(sqlQuery)
             .returning();
         if (isUndefined(row)) {
             return undefined;

package/orm/sqls.d.ts

@@ -4,7 +4,7 @@ import type { Uuid } from './types.js';
 /** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
 export declare const TRANSACTION_TIMESTAMP: SQL<Date>;
 /** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
-export declare const RANDOM_UUID: SQL<Uuid>;
+export declare const RANDOM_UUID_V4: SQL<Uuid>;
 /** Represents valid units for PostgreSQL interval values. */
 export type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
 export declare function autoAlias<T>(column: AnyColumn<{

package/orm/sqls.js

@@ -9,7 +9,7 @@ import { sql, Table } 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()`;
+export const RANDOM_UUID_V4 = sql `gen_random_uuid()`;
 export function autoAlias(column) {
     return sql `${column}`.as(`${column.table[Table['Symbol']['Name']]}_${column.name}`);
 }

package/orm/types.d.ts

@@ -6,12 +6,8 @@
  */
 import type { $Type, HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
 import type { boolean, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, uuid } from 'drizzle-orm/pg-core';
-import { Array, Integer } from '../schema/index.js';
-import type { AbstractConstructor, EnumerationObject, EnumerationValue, ObjectLiteral, UnionToTuple } from '../types/index.js';
-import type { GetTagMetadata, HasTag, Tagged, UnwrapTagged } from '../types/index.js';
+import type { AbstractConstructor, EnumerationObject, EnumerationValue, GetTagMetadata, HasTag, ObjectLiteral, Tagged, UnionToTuple, UnwrapTagged } from '../types/index.js';
 import type { bytea, numericDate, timestamp } from './data-types/index.js';
-import { Check, Column, Embedded, Encrypted, Index, PrimaryKey, References, Table, Unique } from './decorators.js';
-import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
 /** Tag identifier for column type information. */
 export type ColumnTypeTag = 'column';
 /** Tag identifier for embedded type configuration. */
@@ -90,4 +86,4 @@ export type Bytea = Tagged<Uint8Array, ColumnTypeTag, ReturnType<typeof bytea>>;
  * @template T - The original (unencrypted) type of the data.
  */
 export type Encrypted<T> = Tagged<T, ColumnTypeTag, ReturnType<typeof bytea>>;
-export { Array, Check, Column, Embedded, Encrypted, Index, Integer, Json, NumericDate, PrimaryKey, References, Table, Timestamp, Unique, Uuid };
+export {};

package/orm/types.js

@@ -1,4 +1 @@
-import { Array, Integer } from '../schema/index.js';
-import { Check, Column, Embedded, Encrypted, Index, PrimaryKey, References, Table, Unique } from './decorators.js';
-import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
-export { Array, Check, Column, Embedded, Encrypted, Index, Integer, Json, NumericDate, PrimaryKey, References, Table, Timestamp, Unique, Uuid };
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.2",
+  "version": "0.93.3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -30,6 +30,7 @@
     "./tsconfig.json": "./tsconfig.json",
     "./eslint.config.js": "./eslint.config.js",
     ".": "./index.js",
+    "./constants": "./constants.js",
     "./environment": "./environment.js",
     "./interfaces": "./interfaces.js",
     "./polyfills": "./polyfills.js",
@@ -83,6 +84,8 @@
     "./object-storage": "./object-storage/index.js",
     "./openid-connect": "./openid-connect/index.js",
     "./orm": "./orm/index.js",
+    "./orm/schemas": "./orm/schemas/index.js",
+    "./orm/data-types": "./orm/data-types/index.js",
     "./orm/server": "./orm/server/index.js",
     "./password": "./password/index.js",
     "./pdf": "./pdf/index.js",
@@ -129,11 +132,11 @@
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
     "ts-pattern": "^5.8",
-    "type-fest": "4.37"
+    "type-fest": "^5.0"
   },
   "peerDependencies": {
     "@google-cloud/storage": "^7.17",
-    "@google/genai": "^1.19",
+    "@google/genai": "^1.22",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
@@ -143,7 +146,7 @@
     "file-type": "^21.0",
     "handlebars": "^4.7",
     "minio": "^8.0",
-    "mjml": "^4.15",
+    "mjml": "^4.16",
     "nodemailer": "^7.0",
     "pg": "^8.16",
     "playwright": "^1.55",
@@ -159,24 +162,23 @@
     }
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "5.3",
+    "@stylistic/eslint-plugin": "5.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.7",
-    "@types/minio": "7.1",
     "@types/mjml": "4.7",
     "@types/node": "24",
     "@types/nodemailer": "7.0",
     "@types/pg": "8.15",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
-    "eslint": "9.35",
+    "eslint": "9.37",
     "globals": "16.4",
     "tsc-alias": "1.8",
     "typedoc-github-wiki-theme": "2.1",
-    "typedoc-plugin-markdown": "4.8",
+    "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.43"
+    "typescript-eslint": "8.45"
   },
   "overrides": {
     "drizzle-kit": {

package/queue/postgres/job.model.d.ts

@@ -1,12 +1,12 @@
-import { EntityWithoutMetadata, Integer, Json, Timestamp } from '../../orm/index.js';
+import { EntityWithoutMetadata, type Json, type Timestamp } from '../../orm/index.js';
 import type { ObjectLiteral } from '../../types/index.js';
 import type { Job } from '../queue.js';
 export declare class PostgresJob<T extends ObjectLiteral = ObjectLiteral> extends EntityWithoutMetadata implements Job<T> {
     queue: string;
     tag: string | null;
-    priority: Integer;
+    priority: number;
     enqueueTimestamp: Timestamp;
-    tries: Integer;
+    tries: number;
     lastDequeueTimestamp: Timestamp | null;
     data: Json<T>;
 }

package/queue/postgres/job.model.js

@@ -7,9 +7,8 @@ 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 { Index, Table } from '../../orm/decorators.js';
-import { EntityWithoutMetadata, Integer, Json, Timestamp } from '../../orm/index.js';
-import { StringProperty } from '../../schema/index.js';
+import { EntityWithoutMetadata, Index, JsonProperty, Table, TimestampProperty } from '../../orm/index.js';
+import { Integer, StringProperty } from '../../schema/index.js';
 let PostgresJob = class PostgresJob extends EntityWithoutMetadata {
     queue;
     tag;
@@ -32,7 +31,7 @@ __decorate([
     __metadata("design:type", Number)
 ], PostgresJob.prototype, "priority", void 0);
 __decorate([
-    Timestamp(),
+    TimestampProperty(),
     __metadata("design:type", Number)
 ], PostgresJob.prototype, "enqueueTimestamp", void 0);
 __decorate([
@@ -40,11 +39,11 @@ __decorate([
     __metadata("design:type", Number)
 ], PostgresJob.prototype, "tries", void 0);
 __decorate([
-    Timestamp({ nullable: true }),
+    TimestampProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], PostgresJob.prototype, "lastDequeueTimestamp", void 0);
 __decorate([
-    Json(),
+    JsonProperty(),
     __metadata("design:type", Object)
 ], PostgresJob.prototype, "data", void 0);
 PostgresJob = __decorate([

package/queue/postgres/queue.js

@@ -9,7 +9,7 @@ import { merge } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/index.js';
 import { inject, injectArgument, provide, Singleton } from '../../injector/index.js';
 import { MessageBus } from '../../message-bus/index.js';
-import { interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { interval, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
 import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../orm/server/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
@@ -27,7 +27,7 @@ let PostgresQueue = class PostgresQueue extends Queue {
     processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
     maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
     #takeNewUpdate = {
-        id: RANDOM_UUID,
+        id: RANDOM_UUID_V4,
         queue: this.#queueName,
         priority: sql `excluded.priority`,
         tag: sql `excluded.tag`,

package/queue/postgres/schemas.d.ts

@@ -1,3 +1,3 @@
 import { PostgresJob } from './job.model.js';
-export declare const queueSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"queue">;
+export declare const queueSchema: import("../../orm/server/index.js").DatabaseSchema<"queue">;
 export declare const job: import("../../orm/server/types.js").PgTableFromType<typeof PostgresJob, "queue">;

package/queue/postgres/schemas.js

@@ -1,4 +1,4 @@
-import { databaseSchema } from '../../orm/server/database-schema.js';
+import { databaseSchema } from '../../orm/server/index.js';
 import { PostgresJob } from './job.model.js';
 export const queueSchema = databaseSchema('queue');
 export const job = queueSchema.getTable(PostgresJob);

package/supports.d.ts

@@ -4,3 +4,4 @@ export declare const supportsBuffer: boolean;
 export declare const supportsStructuredClone: boolean;
 export declare const supportsNotification: boolean;
 export declare const supportsColoredStdout: boolean;
+export declare const supportsColoredStderr: boolean;

package/supports.js

@@ -3,4 +3,5 @@ export const supportsBlob = (typeof Blob == 'function');
 export const supportsBuffer = (typeof Buffer == 'function');
 export const supportsStructuredClone = (typeof structuredClone == 'function');
 export const supportsNotification = (typeof Notification == 'function');
-export const supportsColoredStdout = (typeof process == 'object' && process.stdout.hasColors());
+export const supportsColoredStdout = (typeof process == 'object' && (process.stdout.hasColors?.() ?? false));
+export const supportsColoredStderr = (typeof process == 'object' && (process.stderr.hasColors?.() ?? false));

package/types/types.d.ts

@@ -117,7 +117,18 @@ export type OmitBy<T, V> = Omit<T, {
 /**
  * Normalize properties of a type that allow `undefined` to make them optional.
  */
-export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
+export type Optionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & Partial<PickBy<T, undefined>>>;
+export type OptionalizeDeep<T> = T extends BuiltIn ? T : T extends (infer U)[] ? OptionalizeDeep<U>[] : T extends readonly (infer U)[] ? readonly OptionalizeDeep<U>[] : Optionalize<{
+    [P in keyof T]: OptionalizeDeep<T[P]>;
+}>;
+export type OptionalizeNull<T extends object> = SimplifyObject<OmitBy<T, null> & Partial<PickBy<T, null>>>;
+export type OptionalizeNullDeep<T> = T extends BuiltIn ? T : T extends (infer U)[] ? OptionalizeNullDeep<U>[] : T extends readonly (infer U)[] ? readonly OptionalizeNullDeep<U>[] : OptionalizeNull<{
+    [P in keyof T]: OptionalizeNullDeep<T[P]>;
+}>;
+export type OptionalizeNullable<T extends object> = SimplifyObject<OmitBy<T, null | undefined> & Partial<PickBy<T, null | undefined>>>;
+export type OptionalizeNullableDeep<T> = T extends BuiltIn ? T : T extends readonly (infer U)[] ? OptionalizeNullableDeep<U>[] : T extends (infer U)[] ? OptionalizeNullableDeep<U>[] : OptionalizeNullable<{
+    [P in keyof T]: OptionalizeNullableDeep<T[P]>;
+}>;
 export type Unoptionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & {
     [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
 }>;

package/utils/object/object.d.ts

@@ -1,5 +1,5 @@
 import { type JsonPathInput } from '../../json-path/json-path.js';
-import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types/index.js';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, OptionalizeNull, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types/index.js';
 export declare function hasOwnProperty<T extends Record, K extends keyof UnionToIntersection<T>>(obj: T, key: K): obj is Extract<T, Partial<Record<K>>>;
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
@@ -22,7 +22,9 @@ export declare function filterObject<T extends ObjectLiteral, U extends T[keyof
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
 export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
 export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, undefined>>;
+export declare function filterNullishFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, null | undefined>>;
 export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<Optionalize<T>>;
+export declare function filterNullishObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<OptionalizeNull<Optionalize<T>>>;
 export declare function copyObjectProperties<T extends ObjectLiteral>(source: T, target: T): void;
 export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: U, bind: boolean): () => T[U];
 export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];

package/utils/object/object.js

@@ -2,7 +2,7 @@ import { JsonPath } from '../../json-path/json-path.js';
 import { filterAsync } from '../async-iterable-helpers/filter.js';
 import { mapAsync } from '../async-iterable-helpers/map.js';
 import { toArrayAsync } from '../async-iterable-helpers/to-array.js';
-import { isArray, isDefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
+import { isArray, isDefined, isNotNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
 export function hasOwnProperty(obj, key) {
     return Object.hasOwn(obj, key);
 }
@@ -55,9 +55,15 @@ export async function filterObjectAsync(object, predicate) {
 export function filterUndefinedFromRecord(record) {
     return filterObject(record, isDefined);
 }
+export function filterNullishFromRecord(record) {
+    return filterObject(record, isNotNullOrUndefined);
+}
 export function filterUndefinedObjectProperties(object) {
     return filterObject(object, isDefined);
 }
+export function filterNullishObjectProperties(object) {
+    return filterObject(object, isNotNullOrUndefined);
+}
 export function copyObjectProperties(source, target) {
     for (const key of objectKeys(source)) {
         target[key] = source[key];