@tstdl/base 0.92.123 → 0.92.125

package/formats.js

@@ -7,35 +7,35 @@ export function configureFormats(options) {
 }
 export const integerFormat = {
     useGrouping: true,
-    maximumFractionDigits: 0
+    maximumFractionDigits: 0,
 };
 export const decimalFormat = {
     useGrouping: true,
     minimumFractionDigits: 2,
-    maximumFractionDigits: 2
+    maximumFractionDigits: 2,
 };
 export const decimal1Format = {
     useGrouping: true,
     minimumFractionDigits: 0,
-    maximumFractionDigits: 1
+    maximumFractionDigits: 1,
 };
 export const yearFormat = {
     useGrouping: false,
-    maximumFractionDigits: 0
+    maximumFractionDigits: 0,
 };
 export const dateTimeNumeric = {
     year: 'numeric',
     month: '2-digit',
     day: '2-digit',
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
 export const dateTimeShort = {
     year: 'numeric',
     month: 'short',
     day: '2-digit',
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
 export const dateTimeLong = {
     year: 'numeric',
@@ -43,48 +43,48 @@ export const dateTimeLong = {
     month: 'long',
     day: '2-digit',
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
 export const dateShort = {
     year: 'numeric',
     month: '2-digit',
-    day: '2-digit'
+    day: '2-digit',
 };
 export const dateMedium = {
     year: 'numeric',
     month: 'long',
-    day: '2-digit'
+    day: '2-digit',
 };
 export const dateLong = {
     year: 'numeric',
     weekday: 'long',
     month: 'long',
-    day: '2-digit'
+    day: '2-digit',
 };
 export const timeShort = {
     hour: '2-digit',
-    minute: '2-digit'
+    minute: '2-digit',
 };
-export const euroFormat = {
+export const currencyFormat = {
     style: 'currency',
-    currency: 'EUR'
 };
-export const euroFormatWithoutCents = {
-    ...euroFormat,
-    minimumFractionDigits: 0
+export const currencyFormatWithoutCents = {
+    ...currencyFormat,
+    minimumFractionDigits: 0,
 };
 export const percentFormat = {
     style: 'percent',
     minimumFractionDigits: 2,
-    maximumFractionDigits: 2
+    maximumFractionDigits: 2,
 };
 const getDecimalFormatter = memoize(_getDecimalFormatter);
-const dateFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
 const integerFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, integerFormat));
 const decimalFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, decimalFormat));
 const yearFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, yearFormat));
-const euroFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, euroFormat));
 const percentFormatter = memoizeSingle((loc) => Intl.NumberFormat(loc, percentFormat));
+const dateFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
+const currencyFormatter = memoize((currency, loc) => Intl.NumberFormat(loc, { ...currencyFormat, currency }));
+const currencyFormatterWithoutCents = memoize((currency, loc) => Intl.NumberFormat(loc, { ...currencyFormatWithoutCents, currency }));
 const timeShortFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, timeShort));
 const dateShortFormatter = memoizeSingle((loc) => Intl.DateTimeFormat(loc, dateShort));
 export function formatNumber(value, format) {
@@ -97,7 +97,7 @@ export function formatDecimal(value, minimumFractionDigits, maximumFractionDigit
     if (isUndefined(minimumFractionDigits) && isUndefined(maximumFractionDigits)) {
         return decimalFormatter(locale).format(value);
     }
-    return getDecimalFormatter(minimumFractionDigits ?? 2, maximumFractionDigits ?? 2).format(value);
+    return getDecimalFormatter(locale, minimumFractionDigits ?? 2, maximumFractionDigits ?? 2).format(value);
 }
 export function formatYear(value) {
     return yearFormatter(locale).format(value);
@@ -114,8 +114,17 @@ export function formatDate(dateOrTimestamp) {
 export function formatNumericDate(numericDate) {
     return formatDate(numericDateToTimestamp(numericDate));
 }
+export function formatCurrency(value, currency) {
+    return currencyFormatter(currency, locale).format(value);
+}
+export function formatCurrencyWithoutCents(value, currency) {
+    return currencyFormatterWithoutCents(currency, locale).format(value);
+}
 export function formatEuro(value) {
-    return euroFormatter(locale).format(value);
+    return currencyFormatter('EUR', locale).format(value);
+}
+export function formatEuroWithoutCents(value) {
+    return currencyFormatterWithoutCents('EUR', locale).format(value);
 }
 export function formatPercent(value) {
     return percentFormatter(locale).format(value);
@@ -133,10 +142,10 @@ export function formatPersonName(person, { lastNameFirst = false, fallback } = {
  * @deprecated use {@link formatPersonName} instead
  */
 export const formatUserName = formatPersonName;
-function _getDecimalFormatter(minimumFractionDigits = 2, maximumFractionDigits = 2) {
+function _getDecimalFormatter(locale, minimumFractionDigits = 2, maximumFractionDigits = 2) {
     return Intl.NumberFormat(locale, {
         useGrouping: true,
         minimumFractionDigits,
-        maximumFractionDigits
+        maximumFractionDigits,
     });
 }

package/http/client/http-client.js

@@ -14,7 +14,7 @@ import { encodeBase64 } from '../../utils/base64.js';
 import { encodeUtf8 } from '../../utils/encoding.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
 import { objectEntries } from '../../utils/object/object.js';
-import { readableStreamFromPromise } from '../../utils/stream/readable-stream-from-promise.js';
+import { readableStreamFromPromise } from '../../utils/stream/from-promise.js';
 import { assertDefined, isArray, isBlob, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
 import { buildUrl } from '../../utils/url-builder.js';
 import { HttpHeaders } from '../http-headers.js';

package/injector/injector.js

@@ -209,8 +209,8 @@ export class Injector {
         this.assertNotDisposed();
         if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
             assert(options.optional != true, 'ForwardRef does not support optional without resolveAll/injectAll as undefined is not forwardable.');
-            const forwardRef = ForwardRef.create();
             const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
+            const forwardRef = ForwardRef.create({ typeHint: (options.forwardRefTypeHint ?? isFunction(forwardToken)) ? forwardToken : undefined });
             context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolve(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;
@@ -234,8 +234,8 @@ export class Injector {
     _resolveAll(token, argument, options, context, chain) {
         this.assertNotDisposed();
         if (isDefined(options.forwardRef) && (options.forwardRef != false)) {
-            const forwardRef = ForwardRef.create({ typeHint: options.forwardRefTypeHint });
             const forwardToken = isFunction(options.forwardRef) ? options.forwardRef() : token;
+            const forwardRef = ForwardRef.create({ typeHint: (options.forwardRefTypeHint ?? isFunction(forwardToken)) ? forwardToken : undefined });
             context.forwardRefQueue.add(() => ForwardRef.setRef(forwardRef, this._resolveAll(forwardToken, argument, { ...options, forwardRef: false }, context, chain.markAsForwardRef(forwardToken))));
             context.forwardRefs.add(forwardRef);
             return forwardRef;

package/object-storage/s3/s3.object-storage.js

@@ -62,7 +62,7 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
             const errorPromise = new Promise((_, reject) => readable.on('error', reject));
             await Promise.race([
                 this.client.putObject(this.bucket, bucketKey, readable, options?.contentLength, options?.metadata),
-                errorPromise
+                errorPromise,
             ]);
         }
     }

package/orm/data-types/bytea.d.ts

@@ -1,8 +1,16 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `bytea` columns.
+ */
 import { type ConvertCustomConfig, type PgCustomColumnBuilder } from 'drizzle-orm/pg-core';
 type Config = {
     data: Uint8Array;
     driverData: Uint8Array;
 };
+/**
+ * Custom Drizzle type for PostgreSQL `bytea` columns.
+ * Maps between `Uint8Array` in JavaScript and `bytea` in the database.
+ */
 export declare const bytea: {
     (): PgCustomColumnBuilder<ConvertCustomConfig<"", Config>>;
     <TName extends string>(dbName: TName): PgCustomColumnBuilder<ConvertCustomConfig<TName, Config>>;

package/orm/data-types/bytea.js

@@ -1,4 +1,12 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `bytea` columns.
+ */
 import { customType } from 'drizzle-orm/pg-core';
+/**
+ * Custom Drizzle type for PostgreSQL `bytea` columns.
+ * Maps between `Uint8Array` in JavaScript and `bytea` in the database.
+ */
 export const bytea = customType({
     dataType() {
         return 'bytea';

package/orm/data-types/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Exports custom Drizzle data types for PostgreSQL.
+ */
 export * from './bytea.js';
 export * from './numeric-date.js';
 export * from './timestamp.js';

package/orm/data-types/index.js

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Exports custom Drizzle data types for PostgreSQL.
+ */
 export * from './bytea.js';
 export * from './numeric-date.js';
 export * from './timestamp.js';

package/orm/data-types/numeric-date.d.ts

@@ -1,8 +1,17 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `date` columns
+ * using numeric representation (YYYYMMDD).
+ */
 import { type ConvertCustomConfig, type PgCustomColumnBuilder } from 'drizzle-orm/pg-core';
 type Config = {
     data: number;
     driverData: string;
 };
+/**
+ * Custom Drizzle type for PostgreSQL `date` columns, storing dates as numeric values (YYYYMMDD).
+ * Converts between JavaScript `number` (YYYYMMDD) and database `date` (ISO string).
+ */
 export declare const numericDate: {
     (): PgCustomColumnBuilder<ConvertCustomConfig<"", Config>>;
     <TName extends string>(dbName: TName): PgCustomColumnBuilder<ConvertCustomConfig<TName, Config>>;

package/orm/data-types/numeric-date.js

@@ -1,5 +1,14 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `date` columns
+ * using numeric representation (YYYYMMDD).
+ */
 import { customType } from 'drizzle-orm/pg-core';
 import { dateToNumericDate, numericDateToDate } from '../../utils/date-time.js';
+/**
+ * Custom Drizzle type for PostgreSQL `date` columns, storing dates as numeric values (YYYYMMDD).
+ * Converts between JavaScript `number` (YYYYMMDD) and database `date` (ISO string).
+ */
 export const numericDate = customType({
     dataType() {
         return 'date';

package/orm/data-types/timestamp.d.ts

@@ -1,8 +1,17 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `timestamp with time zone` columns
+ * using numeric representation (Unix timestamp in milliseconds).
+ */
 import { type ConvertCustomConfig, type PgCustomColumnBuilder } from 'drizzle-orm/pg-core';
 type Config = {
     data: number;
     driverData: string;
 };
+/**
+ * Custom Drizzle type for PostgreSQL `timestamp with time zone` columns, storing timestamps as numeric values (Unix timestamp in milliseconds).
+ * Converts between JavaScript `number` (milliseconds since epoch) and database `timestamp with time zone` (ISO string).
+ */
 export declare const timestamp: {
     (): PgCustomColumnBuilder<ConvertCustomConfig<"", Config>>;
     <TName extends string>(dbName: TName): PgCustomColumnBuilder<ConvertCustomConfig<TName, Config>>;

package/orm/data-types/timestamp.js

@@ -1,4 +1,13 @@
+/**
+ * @module
+ * Defines a custom Drizzle type for handling PostgreSQL `timestamp with time zone` columns
+ * using numeric representation (Unix timestamp in milliseconds).
+ */
 import { customType } from 'drizzle-orm/pg-core';
+/**
+ * Custom Drizzle type for PostgreSQL `timestamp with time zone` columns, storing timestamps as numeric values (Unix timestamp in milliseconds).
+ * Converts between JavaScript `number` (milliseconds since epoch) and database `timestamp with time zone` (ISO string).
+ */
 export const timestamp = customType({
     dataType() {
         return 'timestamp with time zone';

package/orm/decorators.d.ts

@@ -1,12 +1,31 @@
+/**
+ * @module
+ * Defines decorators for ORM entities and columns, used to configure database schema mapping.
+ */
 import type { SQL } from 'drizzle-orm';
 import type { LiteralUnion } from 'type-fest';
 import type { AbstractConstructor, TypedOmit } from '../types.js';
-import type { Entity, EntityType } from './entity.js';
+import type { Entity, EntityType, EntityWithoutMetadata } from './entity.js';
+import type { Query } from './query.js';
 import type { PgTableFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
 type NamingStrategy = 'abbreviated-table';
 type Columns<T> = [Extract<keyof T, string>, ...Extract<keyof T, string>[]];
+/**
+ * Builder function type for creating SQL check constraints.
+ * @param table - The Drizzle table object.
+ * @returns The SQL check constraint expression.
+ */
 export type CheckBuilder<T extends Entity = any> = (table: PgTableFromType<EntityType<T>>) => SQL;
+/**
+ * Builder function type for creating partial index WHERE clauses.
+ * @param table - The Drizzle table object.
+ * @returns The query object representing the WHERE clause.
+ */
+export type WhereBuilder<T extends Entity | EntityWithoutMetadata = any> = (table: PgTableFromType<EntityType<T>>) => Query<T>;
+/**
+ * Reflection data stored for ORM table decorators.
+ */
 export type OrmTableReflectionData = {
     name?: string;
     schema?: string;
@@ -16,6 +35,9 @@ export type OrmTableReflectionData = {
     index?: IndexReflectionData[];
     checks?: CheckReflectionData[];
 };
+/**
+ * Reflection data stored for ORM column decorators.
+ */
 export type OrmColumnReflectionData = {
     name?: string;
     primaryKey?: boolean;
@@ -31,6 +53,9 @@ export type OrmColumnReflectionData = {
     references?: () => EntityType;
     encrypted?: boolean;
 };
+/**
+ * Reflection data for unique constraints.
+ */
 export type UniqueReflectionData = {
     name?: string;
     columns?: string[];
@@ -39,13 +64,18 @@ export type UniqueReflectionData = {
         naming?: NamingStrategy;
     };
 };
-export type IndexReflectionData = {
+/**
+ * Reflection data for index definitions.
+ * @template T - The entity type.
+ */
+export type IndexReflectionData<T extends Entity | EntityWithoutMetadata = any> = {
     name?: string;
     columns?: (string | [string, 'asc' | 'desc'])[];
     order?: 'asc' | 'desc';
     options?: {
         using?: IndexMethod;
         unique?: boolean;
+        where?: WhereBuilder<T>;
         nulls?: 'first' | 'last';
         naming?: NamingStrategy;
     };
@@ -57,22 +87,126 @@ type CheckReflectionData = {
         naming?: NamingStrategy;
     };
 };
+/**
+ * Factory function to create a class decorator for ORM table configuration.
+ * Merges provided data with existing ORM reflection data on the class metadata.
+ * @param data - The ORM table reflection data to add.
+ * @returns A class decorator.
+ */
 export declare function createTableDecorator(data?: OrmTableReflectionData): ClassDecorator;
+/**
+ * Factory function to create a property decorator for ORM column configuration.
+ * Merges provided data with existing ORM reflection data on the property metadata.
+ * @param data - The ORM column reflection data to add.
+ * @returns A property decorator.
+ */
 export declare function createColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator;
+/**
+ * Factory function to create a decorator applicable to both classes and properties for ORM configuration.
+ * Merges provided data with existing ORM reflection data on the target's metadata.
+ * @param data - The ORM reflection data to add.
+ * @returns A class or property decorator.
+ */
 export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): ClassDecorator & PropertyDecorator;
+/**
+ * Decorator to specify ORM column options.
+ * @param options - Column configuration options.
+ * @returns A property decorator.
+ */
 export declare function Column(options: OrmColumnReflectionData): PropertyDecorator;
+/**
+ * Decorator to mark a property as the primary key column.
+ * @returns A property decorator.
+ */
 export declare function PrimaryKey(): PropertyDecorator;
+/**
+ * Decorator to define a foreign key relationship.
+ * @param type - A function returning the referenced entity type.
+ * @returns A property decorator.
+ */
 export declare function References(type: () => EntityType): PropertyDecorator;
+/**
+ * Decorator to define a table check constraint.
+ * @template T - The entity type.
+ * @param name - The name of the check constraint.
+ * @param builder - A function to build the SQL check expression.
+ * @returns A class decorator.
+ */
 export declare function Check<T extends Entity>(name: string, builder: CheckBuilder<T>): ClassDecorator;
+/**
+ * Decorator to mark a column for encryption.
+ * The underlying database type will typically be `bytea`.
+ * @returns A property decorator.
+ */
 export declare function Encrypted(): PropertyDecorator;
+/**
+ * Decorator to embed another class's properties into the current entity's table.
+ * @param type - The constructor of the class to embed.
+ * @param options - Embedding options, like prefixing column names.
+ * @returns A property decorator.
+ */
 export declare function Embedded(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
 type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
+/**
+ * Decorator to specify the database table name and optionally the schema.
+ * @param name - The table name.
+ * @param options - Additional table options (currently only schema).
+ * @returns A class decorator.
+ */
 export declare function Table(name?: string, options?: TypedOmit<TableOptions, 'schema'>): ClassDecorator;
+/**
+ * Decorator to specify database table options like name and schema.
+ * @param options - Table options including name and schema.
+ * @returns A class decorator.
+ */
 export declare function Table(options?: TableOptions): ClassDecorator;
+/**
+ * Decorator to define a unique constraint on a single column.
+ * @param name - Optional name for the unique constraint.
+ * @param options - Additional unique constraint options.
+ * @returns A property decorator.
+ */
 export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
+/**
+ * Decorator to define a composite unique constraint on multiple columns.
+ * @template T - The entity type.
+ * @param name - The name of the unique constraint.
+ * @param columns - An array of property names included in the constraint.
+ * @param options - Additional unique constraint options.
+ * @returns A class decorator.
+ */
 export declare function Unique<T>(name: string | undefined, columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
+/**
+ * Decorator to define a composite unique constraint on multiple columns.
+ * @template T - The entity type.
+ * @param columns - An array of property names included in the constraint.
+ * @param options - Additional unique constraint options.
+ * @returns A class decorator.
+ */
 export declare function Unique<T>(columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
-export declare function Index(name?: string, options?: IndexReflectionData['options']): PropertyDecorator;
-export declare function Index<T>(name: string, columns: Columns<T>, options?: IndexReflectionData['options']): ClassDecorator;
-export declare function Index<T>(columns: Columns<T>, options?: IndexReflectionData['options']): ClassDecorator;
+/**
+ * Decorator to define an index on a single column.
+ * @template T - The entity type.
+ * @param name - Optional name for the index.
+ * @param options - Additional index options (e.g., method, uniqueness, conditions).
+ * @returns A property decorator.
+ */
+export declare function Index<T extends Entity | EntityWithoutMetadata = any>(name?: string, options?: IndexReflectionData<T>['options']): PropertyDecorator;
+/**
+ * Decorator to define a composite index on multiple columns.
+ * @template T - The entity type.
+ * @param name - The name of the index.
+ * @param columns - An array of property names (or tuples with direction) included in the index.
+ * @param options - Additional index options.
+ * @returns A class decorator.
+ */
+export declare function Index<T extends Entity | EntityWithoutMetadata = any>(name: string, columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
+/**
+ * Decorator to define a composite index on multiple columns.
+ * @template T - The entity type.
+ * @param columns - An array of property names (or tuples with direction) included in the index.
+ * @param options - Additional index options.
+ * @returns A class decorator.
+ */
+export declare function Index<T extends Entity | EntityWithoutMetadata = any>(columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
 export {};

package/orm/decorators.js

@@ -2,6 +2,12 @@ import { createClassDecorator, createDecorator, createPropertyDecorator } from '
 import { Property } from '../schema/index.js';
 import { filterUndefinedObjectProperties, objectEntries } from '../utils/object/object.js';
 import { assertNotArrayPass, isArray, isString, isUndefined } from '../utils/type-guards.js';
+/**
+ * Factory function to create a class decorator for ORM table configuration.
+ * Merges provided data with existing ORM reflection data on the class metadata.
+ * @param data - The ORM table reflection data to add.
+ * @returns A class decorator.
+ */
 export function createTableDecorator(data = {}) {
     return createClassDecorator({
         handler: (_, metadata) => {
@@ -23,27 +29,71 @@ export function createTableDecorator(data = {}) {
         }
     });
 }
+/**
+ * Factory function to create a property decorator for ORM column configuration.
+ * Merges provided data with existing ORM reflection data on the property metadata.
+ * @param data - The ORM column reflection data to add.
+ * @returns A property decorator.
+ */
 export function createColumnDecorator(data) {
     return createPropertyDecorator({ data: { orm: data }, mergeData: true });
 }
+/**
+ * Factory function to create a decorator applicable to both classes and properties for ORM configuration.
+ * Merges provided data with existing ORM reflection data on the target's metadata.
+ * @param data - The ORM reflection data to add.
+ * @returns A class or property decorator.
+ */
 export function createTableAndColumnDecorator(data) {
     return createDecorator({ class: true, property: true, data: { orm: data }, mergeData: true });
 }
+/**
+ * Decorator to specify ORM column options.
+ * @param options - Column configuration options.
+ * @returns A property decorator.
+ */
 export function Column(options) {
     return createColumnDecorator({ ...options });
 }
+/**
+ * Decorator to mark a property as the primary key column.
+ * @returns A property decorator.
+ */
 export function PrimaryKey() {
     return createColumnDecorator({ primaryKey: true });
 }
+/**
+ * Decorator to define a foreign key relationship.
+ * @param type - A function returning the referenced entity type.
+ * @returns A property decorator.
+ */
 export function References(type) {
     return createColumnDecorator({ references: type });
 }
+/**
+ * Decorator to define a table check constraint.
+ * @template T - The entity type.
+ * @param name - The name of the check constraint.
+ * @param builder - A function to build the SQL check expression.
+ * @returns A class decorator.
+ */
 export function Check(name, builder) {
     return createTableDecorator({ checks: [{ name, builder }] });
 }
+/**
+ * Decorator to mark a column for encryption.
+ * The underlying database type will typically be `bytea`.
+ * @returns A property decorator.
+ */
 export function Encrypted() {
     return createColumnDecorator({ encrypted: true });
 }
+/**
+ * Decorator to embed another class's properties into the current entity's table.
+ * @param type - The constructor of the class to embed.
+ * @param options - Embedding options, like prefixing column names.
+ * @returns A property decorator.
+ */
 export function Embedded(type, options) {
     return createPropertyDecorator({
         include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })]

package/orm/entity.d.ts

@@ -1,11 +1,22 @@
 import type { Type } from '../types.js';
 import { Embedded, type HasDefault, type IsPrimaryKey, Json, Timestamp, Uuid } from './types.js';
+/**
+ * Represents the type (constructor) of an entity, potentially holding an entity name.
+ * @template T - The entity class type.
+ */
 export interface EntityType<T extends Entity | EntityWithoutMetadata = Entity | EntityWithoutMetadata> extends Type<T> {
     readonly entityName?: string;
 }
+/**
+ * Base class for extensible metadata attributes associated with an entity.
+ * Allows storing arbitrary key-value pairs.
+ */
 export declare abstract class EntityMetadataAttributes {
     [key: string]: unknown;
 }
+/**
+ * Base class defining common metadata fields for entities, such as revision tracking and timestamps.
+ */
 export declare abstract class EntityMetadata {
     revision: number;
     revisionTimestamp: Timestamp;
@@ -13,10 +24,18 @@ export declare abstract class EntityMetadata {
     deleteTimestamp: Timestamp | null;
     attributes: HasDefault<Json<EntityMetadataAttributes>>;
 }
+/**
+ * Abstract base class for entities that include standard metadata.
+ * Provides a default `id` (UUID primary key) and an `metadata` field.
+ */
 export declare abstract class Entity {
     id: IsPrimaryKey<HasDefault<Uuid>>;
     metadata: Embedded<EntityMetadata>;
 }
+/**
+ * Abstract base class for entities that do *not* include the standard metadata fields.
+ * Provides only a default `id` (UUID primary key). Useful for simpler tables or join tables.
+ */
 export declare abstract class EntityWithoutMetadata {
     id: IsPrimaryKey<HasDefault<Uuid>>;
 }