@tstdl/base 0.93.1 → 0.93.3

package/lock/postgres/models/lock.model.js

@@ -7,9 +7,7 @@ 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 { ExpiresAt, Table } from '../../../orm/decorators.js';
-import { EntityWithoutMetadata } from '../../../orm/entity.js';
-import { Timestamp, Unique } from '../../../orm/types.js';
+import { EntityWithoutMetadata, Expires, Table, TimestampProperty, Unique } from '../../../orm/index.js';
 import { StringProperty } from '../../../schema/index.js';
 let PostgresLock = class PostgresLock extends EntityWithoutMetadata {
     resource;
@@ -26,8 +24,8 @@ __decorate([
     __metadata("design:type", String)
 ], PostgresLock.prototype, "key", void 0);
 __decorate([
-    ExpiresAt(),
-    Timestamp(),
+    Expires(),
+    TimestampProperty(),
     __metadata("design:type", Number)
 ], PostgresLock.prototype, "expiration", void 0);
 PostgresLock = __decorate([

package/lock/postgres/models/schemas.d.ts

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

package/lock/postgres/models/schemas.js

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

package/lock/postgres/provider.js

@@ -5,8 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Singleton, provide } from '../../injector/index.js';
-import { DatabaseConfig } from '../../orm/server/index.js';
-import { EntityRepositoryConfig, injectRepository } from '../../orm/server/repository.js';
+import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../orm/server/index.js';
 import { LockProvider } from '../provider.js';
 import { PostgresLockAdapter } from './lock.js';
 import { PostgresLock } from './models/lock.model.js';

package/mail/models/mail-log.model.d.ts

@@ -1,4 +1,4 @@
-import { Entity, Json, Timestamp } from '../../orm/index.js';
+import { Entity, type Json, type Timestamp } from '../../orm/index.js';
 import type { MailData } from './mail-data.model.js';
 import type { MailSendResult } from './mail-send-result.model.js';
 export declare class MailLog extends Entity {

package/mail/models/mail-log.model.js

@@ -7,8 +7,7 @@ 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 { Table } from '../../orm/decorators.js';
-import { Entity, Json, Timestamp } from '../../orm/index.js';
+import { Entity, JsonProperty, Table, TimestampProperty } from '../../orm/index.js';
 import { StringProperty } from '../../schema/index.js';
 let MailLog = class MailLog extends Entity {
     timestamp;
@@ -18,7 +17,7 @@ let MailLog = class MailLog extends Entity {
     errors;
 };
 __decorate([
-    Timestamp(),
+    TimestampProperty(),
     __metadata("design:type", Number)
 ], MailLog.prototype, "timestamp", void 0);
 __decorate([
@@ -26,11 +25,11 @@ __decorate([
     __metadata("design:type", Object)
 ], MailLog.prototype, "template", void 0);
 __decorate([
-    Json(),
+    JsonProperty(),
     __metadata("design:type", Object)
 ], MailLog.prototype, "data", void 0);
 __decorate([
-    Json({ nullable: true }),
+    JsonProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], MailLog.prototype, "sendResult", void 0);
 __decorate([

package/mail/models/schemas.d.ts

@@ -1,3 +1,3 @@
 import { MailLog } from './mail-log.model.js';
-export declare const mailSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"mail">;
+export declare const mailSchema: import("../../orm/server/index.js").DatabaseSchema<"mail">;
 export declare const mailLog: import("../../orm/server/types.js").PgTableFromType<typeof MailLog, "mail">;

package/mail/models/schemas.js

@@ -1,4 +1,4 @@
-import { databaseSchema } from '../../orm/server/database-schema.js';
+import { databaseSchema } from '../../orm/server/index.js';
 import { MailLog } from './mail-log.model.js';
 export const mailSchema = databaseSchema('mail');
 export const mailLog = mailSchema.getTable(MailLog);

package/openid-connect/oidc-state.model.d.ts

@@ -1,4 +1,4 @@
-import { EntityWithoutMetadata, Json } from '../orm/index.js';
+import { EntityWithoutMetadata, type Json } from '../orm/index.js';
 export declare class OidcState<Data> extends EntityWithoutMetadata {
     value: string;
     codeVerifier: string;

package/openid-connect/oidc-state.model.js

@@ -7,8 +7,7 @@ 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 { ExpiresAt as Expires } from '../orm/decorators.js';
-import { EntityWithoutMetadata, Json, Unique } from '../orm/index.js';
+import { EntityWithoutMetadata, Expires, JsonProperty, Unique } from '../orm/index.js';
 import { any, NumberProperty, StringProperty } from '../schema/index.js';
 export class OidcState extends EntityWithoutMetadata {
     value;
@@ -46,6 +45,6 @@ __decorate([
     __metadata("design:type", Number)
 ], OidcState.prototype, "expiration", void 0);
 __decorate([
-    Json({ schema: any() }),
+    JsonProperty({ schema: any() }),
     __metadata("design:type", Object)
 ], OidcState.prototype, "data", void 0);

package/openid-connect/oidc.service.js

@@ -9,7 +9,7 @@ import { NotImplementedError } from '../errors/not-implemented.error.js';
 import { HttpClient } from '../http/client/index.js';
 import { HttpHeaders } from '../http/http-headers.js';
 import { inject, Singleton } from '../injector/index.js';
-import { injectRepository } from '../orm/server/repository.js';
+import { injectRepository } from '../orm/server/index.js';
 import { object, optional, Schema, string } from '../schema/index.js';
 import { Alphabet } from '../utils/alphabet.js';
 import { digest } from '../utils/cryptography.js';

package/orm/data-types/bytea.js

@@ -16,5 +16,5 @@ export const bytea = customType({
     },
     fromDriver(value) {
         return value;
-    }
+    },
 });

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

@@ -19,5 +19,5 @@ export const numericDate = customType({
     fromDriver(value) {
         const date = new Date(value);
         return dateToNumericDate(date);
-    }
+    },
 });

package/orm/decorators.d.ts

@@ -4,6 +4,7 @@
  */
 import type { SQL } from 'drizzle-orm';
 import type { LiteralUnion } from 'type-fest';
+import { type SpecificCreateDecoratorOptions } from '../reflection/index.js';
 import type { AbstractConstructor, TypedOmit } from '../types/index.js';
 import type { AnyEntity, Entity, EntityType, EntityWithoutMetadata } from './entity.js';
 import type { Query } from './query.js';
@@ -14,14 +15,12 @@ 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.
+ * @param table The Drizzle table object.
  */
 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.
+ * @param table The Drizzle table object.
  */
 export type WhereBuilder<T extends Entity | EntityWithoutMetadata = any> = (table: PgTableFromType<EntityType<T>>) => Query<T>;
 /**
@@ -58,6 +57,7 @@ export type OrmColumnReflectionData = {
     }[];
     encrypted?: boolean;
     expirationField?: {
+        after: number;
         mode: 'soft' | 'hard';
     };
 };
@@ -74,7 +74,7 @@ export type UniqueReflectionData = {
 };
 /**
  * Reflection data for index definitions.
- * @template T - The entity type.
+ * @template T The entity type.
  */
 export type IndexReflectionData<T extends Entity | EntityWithoutMetadata = any> = {
     columns?: (string | [string, 'asc' | 'desc'])[];
@@ -107,123 +107,116 @@ export type ForeignKeyReflectionData = {
 /**
  * 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.
+ * @param data The ORM table reflection data to add.
  */
 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.
+ * @param data The ORM column reflection data to add.
  */
-export declare function createColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator;
+export declare function createColumnDecorator(data?: OrmColumnReflectionData, decoratorOptions?: TypedOmit<SpecificCreateDecoratorOptions<'property'>, 'handler'>): 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.
+ * @param data The ORM reflection data to add.
  */
 export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator & ClassDecorator;
 /**
- * Decorator to specify ORM column options.
- * @param options - Column configuration options.
- * @returns A property decorator.
+ * Specify ORM column options.
+ * @param options Column configuration options.
  */
 export declare function Column(options: OrmColumnReflectionData): PropertyDecorator;
 /**
- * Decorator to mark a property as the primary key column.
- * @returns A property decorator.
+ * Mark a property as the primary key column.
  */
-export declare function PrimaryKey(): PropertyDecorator;
+export declare function PrimaryKeyProperty(): PropertyDecorator;
 /**
- * Decorator to define a foreign key relationship.
- * @param type - A function returning the referenced entity type.
- * @returns A property decorator.
+ * Define a foreign key relationship.
+ * @param type A function returning the referenced entity type.
  */
 export declare function References(target: () => EntityType): PropertyDecorator;
 export declare function References<T extends AnyEntity>(target: () => EntityType<T>, targetColumn?: TargetColumnPaths<T>): 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.
+ * 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.
  */
 export declare function Check<T extends Entity>(name: string, builder: CheckBuilder<T>): ClassDecorator;
 /**
- * Decorator to mark a column for encryption.
+ * Mark a column for encryption.
  * The underlying database type will typically be `bytea`.
- * @returns A property decorator.
  */
-export declare function Encrypted(): PropertyDecorator;
+export declare function EncryptedProperty(): 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.
+ * 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.
  */
-export declare function Embedded(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
+export declare function EmbeddedProperty(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
 export 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.
+ * Specify the database table name and optionally the schema.
+ * @param name The table name.
+ * @param options Additional table options (currently only schema).
  */
 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.
+ * Specify database table options like name and schema.
+ * @param options Table options including name and schema.
  */
 export declare function Table(options?: TableOptions): ClassDecorator;
 /**
- * Decorator to define a foreign key relationship.
- * @param target - A function returning the referenced entity type.
- * @param columns - The columns in the current entity that form the foreign key.
- * @param foreignColumns - The columns in the referenced entity that the foreign key points to.
- * @param options - Additional foreign key options (e.g., name, naming strategy).
- * @template TThis - The entity type of the current entity.
- * @template TTarget - The entity type of the referenced entity.
- * @returns A property decorator.
+ * Define a foreign key relationship.
+ * @param target A function returning the referenced entity type.
+ * @param columns The columns in the current entity that form the foreign key.
+ * @param foreignColumns The columns in the referenced entity that the foreign key points to.
+ * @param options Additional foreign key options (e.g., name, naming strategy).
+ * @template TThis The entity type of the current entity.
+ * @template TTarget The entity type of the referenced entity.
  */
 export declare function ForeignKey<TThis extends AnyEntity, TTarget extends AnyEntity>(target: () => EntityType<TTarget>, columns: Columns<TThis>, foreignColumns: Columns<TTarget>, options?: ForeignKeyReflectionData['options']): 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.
+ * Define a unique constraint on a single column.
+ * @param name Optional name for the unique constraint.
+ * @param options Additional unique constraint options.
  */
 export declare function Unique(options?: UniqueReflectionData['options']): PropertyDecorator;
 /**
- * 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.
+ * 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.
  */
 export declare function Unique<T extends AnyEntity>(columns: Columns<T>, options?: UniqueReflectionData['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.
+ * 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).
  */
 export declare function Index<T extends Entity | EntityWithoutMetadata = any>(options?: IndexReflectionData<T>['options']): PropertyDecorator;
 /**
- * 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.
+ * 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.
  */
 export declare function Index<T extends Entity | EntityWithoutMetadata = any>(columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
 /**
- * Decorator to mark a column as an expiration field. This will be used to automatically delete records when expired.
- * @param mode - Whether to delete soft or hard.
- * @returns A property decorator.
+ * Automatically expire records after a certain time to live (TTL) based on the createTimestamp metadata. Requires extension of {@link Entity} instead of {@link EntityWithoutMetadata}.
+ * @param ttl Time To Live in milliseconds.
+ * @param mode Whether to delete soft or hard.
  */
-export declare function ExpiresAt(mode?: 'soft' | 'hard'): PropertyDecorator;
+export declare function TimeToLive(ttl: number, mode: 'soft' | 'hard'): ClassDecorator;
+/**
+ * Mark a column as an expiration field, automatically deleting records after the specified duration after the column value.
+ * @param options.after Time in milliseconds after which the record expires.
+ * @param options.mode Whether to delete soft or hard.
+ */
+export declare function Expires(options?: {
+    after?: number;
+    mode?: 'soft' | 'hard';
+}): PropertyDecorator;
 export {};

package/orm/decorators.js

@@ -1,12 +1,11 @@
 import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/index.js';
 import { Property } from '../schema/index.js';
-import { filterUndefinedObjectProperties, objectEntries } from '../utils/object/object.js';
+import { filterUndefinedObjectProperties, objectEntries, propertyNameOf } from '../utils/object/index.js';
 import { 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.
+ * @param data The ORM table reflection data to add.
  */
 export function createTableDecorator(data = {}) {
     return createClassDecorator({
@@ -32,10 +31,9 @@ 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.
+ * @param data The ORM column reflection data to add.
  */
-export function createColumnDecorator(data = {}) {
+export function createColumnDecorator(data = {}, decoratorOptions) {
     return createPropertyDecorator({
         handler: (_, metadata) => {
             const reflectionData = metadata.data.tryGet('orm') ?? {};
@@ -54,60 +52,55 @@ export function createColumnDecorator(data = {}) {
             }
             metadata.data.set('orm', reflectionData, true);
         },
+        ...decoratorOptions,
     });
 }
 /**
  * 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.
+ * @param data The ORM reflection data to add.
  */
 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.
+ * Specify ORM column options.
+ * @param options Column configuration options.
  */
 export function Column(options) {
     return createColumnDecorator({ ...options });
 }
 /**
- * Decorator to mark a property as the primary key column.
- * @returns A property decorator.
+ * Mark a property as the primary key column.
  */
-export function PrimaryKey() {
+export function PrimaryKeyProperty() {
     return createColumnDecorator({ primaryKey: true });
 }
 export function References(target, targetColumn) {
     return createColumnDecorator({ references: [{ target, targetColumn }] });
 }
 /**
- * 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.
+ * 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.
  */
 export function Check(name, builder) {
     return createTableDecorator({ checks: [{ name, builder }] });
 }
 /**
- * Decorator to mark a column for encryption.
+ * Mark a column for encryption.
  * The underlying database type will typically be `bytea`.
- * @returns A property decorator.
  */
-export function Encrypted() {
+export function EncryptedProperty() {
     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.
+ * 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.
  */
-export function Embedded(type, options) {
+export function EmbeddedProperty(type, options) {
     return createPropertyDecorator({
         include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })],
     });
@@ -121,14 +114,13 @@ export function Table(nameOrOptions, optionsOrNothing) {
     return createTableDecorator(data);
 }
 /**
- * Decorator to define a foreign key relationship.
- * @param target - A function returning the referenced entity type.
- * @param columns - The columns in the current entity that form the foreign key.
- * @param foreignColumns - The columns in the referenced entity that the foreign key points to.
- * @param options - Additional foreign key options (e.g., name, naming strategy).
- * @template TThis - The entity type of the current entity.
- * @template TTarget - The entity type of the referenced entity.
- * @returns A property decorator.
+ * Define a foreign key relationship.
+ * @param target A function returning the referenced entity type.
+ * @param columns The columns in the current entity that form the foreign key.
+ * @param foreignColumns The columns in the referenced entity that the foreign key points to.
+ * @param options Additional foreign key options (e.g., name, naming strategy).
+ * @template TThis The entity type of the current entity.
+ * @template TTarget The entity type of the referenced entity.
  */
 export function ForeignKey(target, columns, foreignColumns, options) {
     return createTableDecorator({ foreignKeys: [{ target, columns, foreignColumns, options }] });
@@ -146,10 +138,20 @@ export function Index(columnsOrOptions, options) {
     return createColumnDecorator({ index: { options: columnsOrOptions } });
 }
 /**
- * Decorator to mark a column as an expiration field. This will be used to automatically delete records when expired.
- * @param mode - Whether to delete soft or hard.
- * @returns A property decorator.
+ * Automatically expire records after a certain time to live (TTL) based on the createTimestamp metadata. Requires extension of {@link Entity} instead of {@link EntityWithoutMetadata}.
+ * @param ttl Time To Live in milliseconds.
+ * @param mode Whether to delete soft or hard.
  */
-export function ExpiresAt(mode = 'soft') {
-    return createColumnDecorator({ expirationField: { mode } });
+export function TimeToLive(ttl, mode) {
+    return createClassDecorator({
+        handler: (data) => Expires({ after: ttl, mode })(data.prototype, propertyNameOf((entity) => entity.metadata.createTimestamp)),
+    });
+}
+/**
+ * Mark a column as an expiration field, automatically deleting records after the specified duration after the column value.
+ * @param options.after Time in milliseconds after which the record expires.
+ * @param options.mode Whether to delete soft or hard.
+ */
+export function Expires(options) {
+    return createColumnDecorator({ expirationField: { after: options?.after ?? 0, mode: options?.mode ?? 'soft' } });
 }

package/orm/entity.d.ts

@@ -1,5 +1,5 @@
 import type { Type } from '../types/index.js';
-import { Embedded, type HasDefault, type IsPrimaryKey, Json, Timestamp, Uuid } from './types.js';
+import type { Embedded, HasDefault, 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.
@@ -40,3 +40,9 @@ export declare abstract class Entity {
 export declare abstract class EntityWithoutMetadata {
     id: IsPrimaryKey<HasDefault<Uuid>>;
 }
+export declare abstract class TenantEntity extends Entity {
+    tenantId: Uuid;
+}
+export declare abstract class TenantEntityWithoutMetadata extends EntityWithoutMetadata {
+    tenantId: Uuid;
+}

package/orm/entity.js

@@ -12,8 +12,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
  * Defines base entity classes and related types for the ORM.
  */
 import { Defaulted, Integer } from '../schema/index.js';
-import { PrimaryKey } from './decorators.js';
-import { Embedded, Json, Timestamp, Uuid } from './types.js';
+import { EmbeddedProperty, PrimaryKeyProperty } from './decorators.js';
+import { JsonProperty, TimestampProperty, UuidProperty } from './schemas/index.js';
 /**
  * Base class for extensible metadata attributes associated with an entity.
  * Allows storing arbitrary key-value pairs.
@@ -21,7 +21,7 @@ import { Embedded, Json, Timestamp, Uuid } from './types.js';
 let EntityMetadataAttributes = class EntityMetadataAttributes {
 };
 EntityMetadataAttributes = __decorate([
-    Json()
+    JsonProperty()
 ], EntityMetadataAttributes);
 export { EntityMetadataAttributes };
 /**
@@ -39,15 +39,15 @@ __decorate([
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revision", void 0);
 __decorate([
-    Timestamp(),
+    TimestampProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revisionTimestamp", void 0);
 __decorate([
-    Timestamp(),
+    TimestampProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "createTimestamp", void 0);
 __decorate([
-    Timestamp({ nullable: true }),
+    TimestampProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "deleteTimestamp", void 0);
 __decorate([
@@ -63,12 +63,12 @@ export class Entity {
     metadata;
 }
 __decorate([
-    PrimaryKey(),
-    Uuid({ defaultRandom: true }),
+    PrimaryKeyProperty(),
+    UuidProperty({ defaultRandom: true }),
     __metadata("design:type", Object)
 ], Entity.prototype, "id", void 0);
 __decorate([
-    Embedded(EntityMetadata, { prefix: null }),
+    EmbeddedProperty(EntityMetadata, { prefix: null }),
     __metadata("design:type", Object)
 ], Entity.prototype, "metadata", void 0);
 /**
@@ -79,7 +79,21 @@ export class EntityWithoutMetadata {
     id;
 }
 __decorate([
-    PrimaryKey(),
-    Uuid({ defaultRandom: true }),
+    PrimaryKeyProperty(),
+    UuidProperty({ defaultRandom: true }),
     __metadata("design:type", Object)
 ], EntityWithoutMetadata.prototype, "id", void 0);
+export class TenantEntity extends Entity {
+    tenantId;
+}
+__decorate([
+    UuidProperty(),
+    __metadata("design:type", String)
+], TenantEntity.prototype, "tenantId", void 0);
+export class TenantEntityWithoutMetadata extends EntityWithoutMetadata {
+    tenantId;
+}
+__decorate([
+    UuidProperty(),
+    __metadata("design:type", String)
+], TenantEntityWithoutMetadata.prototype, "tenantId", void 0);

package/orm/index.d.ts

@@ -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';