@decaf-ts/core 0.18.0 → 0.19.0

package/lib/types/model/decorators.d.cts

@@ -0,0 +1,237 @@
+import { OperationKeys } from "@decaf-ts/db-decorators";
+import { Constructor } from "@decaf-ts/decoration";
+import { CascadeMetadata } from "../repository/types.cjs";
+import { Model } from "@decaf-ts/decorator-validation";
+import type { Repo } from "../repository/Repository.cjs";
+import { JoinColumnOptions, JoinTableMultipleColumnsOptions, JoinTableOptions, RelationsMetadata } from "./types.cjs";
+import { ContextOf } from "../persistence/types.cjs";
+/**
+ * @description Specifies the database table name for a model
+ * @summary Decorator that sets the table name for a model class in the database
+ * @param {string} opts - The name of the table in the database
+ * @return {Function} A decorator function that can be applied to a class
+ * @function table
+ * @category Class Decorators
+ */
+export declare function table<OPTS = string>(opts?: OPTS): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Specifies the database column name for a model property
+ * @summary Decorator that maps a model property to a specific column name in the database
+ * @param {string} columnName - The name of the column in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function column
+ * @category Property Decorators
+ */
+export declare function column<OPTS = string>(columnName?: OPTS): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Enforces uniqueness constraint during model creation and update
+ * @summary Internal function used by the unique decorator to check if a property value already exists in the database
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The metadata type
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to check for uniqueness
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that resolves when the check is complete or rejects with a ConflictError
+ * @function uniqueOnCreateUpdate
+ * @memberOf module:core
+ */
+export declare function uniqueOnCreateUpdate<M extends Model, R extends Repo<M>>(this: R, context: ContextOf<R>, data: object, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Tags a property as unique
+ * @summary Decorator that ensures a property value is unique across all instances of a model in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function unique
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @unique()
+ *   @required()
+ *   username!: string;
+ * }
+ * ```
+ */
+export declare function unique(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Handles user identification for ownership tracking
+ * @summary Internal function used by the createdBy and updatedBy decorators to set ownership information
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to store the user identifier
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that rejects with an AuthorizationError if user identification is not supported
+ * @function createdByOnCreateUpdate
+ * @memberOf module:core
+ */
+export declare function createdByOnCreateUpdate<M extends Model, R extends Repo<M>>(this: R, context: ContextOf<R>, data: RelationsMetadata, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Tracks the creator of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who created the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function createdBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @createdBy()
+ *   creator!: string;
+ * }
+ * ```
+ */
+export declare function createdBy(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Tracks the last updater of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who last updated the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function updatedBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @updatedBy()
+ *   lastEditor!: string;
+ * }
+ * ```
+ */
+export declare function updatedBy(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function createdAt(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function updatedAt(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function persistentVersion(): (target: any, propertyKey?: any) => any;
+export declare function version(persistent?: boolean): (target: any, propertyKey?: any) => any;
+export declare function getPkTypes(model: Constructor | (() => Constructor)): (() => any)[];
+/**
+ * @description Defines a one-to-one relationship between models
+ * @summary Decorator that establishes a one-to-one relationship between the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function oneToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @oneToOne(Profile)
+ *   profile!: string | Profile;
+ * }
+ *
+ * class Profile extends BaseModel {
+ *   @required()
+ *   bio!: string;
+ * }
+ * ```
+ * @see oneToMany
+ * @see manyToOne
+ */
+export declare function oneToOne<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinColumnOpts?: JoinColumnOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Defines a one-to-many relationship between models
+ * @summary Decorator that establishes a one-to-many relationship between the current model and multiple instances of another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function oneToMany
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ *
+ *   @oneToMany(Book)
+ *   books!: string[] | Book[];
+ * }
+ *
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ * }
+ * ```
+ * @see oneToOne
+ * @see manyToOne
+ */
+export declare function oneToMany<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Defines a many-to-one relationship between models
+ * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function manyToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ *
+ *   @manyToOne(Author)
+ *   author!: string | Author;
+ * }
+ *
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ * }
+ * ```
+ * @see oneToMany
+ * @see oneToOne
+ */
+export declare function manyToOne<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Defines a many-to-one relationship between models
+ * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function manyToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ *
+ *   @manyToOne(Author)
+ *   author!: string | Author;
+ * }
+ *
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ * }
+ * ```
+ * @see oneToMany
+ * @see oneToOne
+ */
+export declare function manyToMany<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function noValidateOn(...ops: OperationKeys[]): (target: any, propertyKey?: any) => void;
+export declare function noValidateOnCreate(): (target: any, propertyKey?: any) => void;
+export declare function noValidateOnUpdate(): (target: any, propertyKey?: any) => void;
+export declare function noValidateOnCreateUpdate(): (target: any, propertyKey?: any) => void;
+/**
+ * @description Specifies the model property as a relation
+ * @summary Decorator that specifies the model property as a relation in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function relation
+ * @category Property Decorators
+ */
+export declare function relation(relationKey: string, meta: RelationsMetadata): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/model/decorators.d.mts

@@ -0,0 +1,237 @@
+import { OperationKeys } from "@decaf-ts/db-decorators";
+import { Constructor } from "@decaf-ts/decoration";
+import { CascadeMetadata } from "../repository/types.js";
+import { Model } from "@decaf-ts/decorator-validation";
+import type { Repo } from "../repository/Repository.js";
+import { JoinColumnOptions, JoinTableMultipleColumnsOptions, JoinTableOptions, RelationsMetadata } from "./types.js";
+import { ContextOf } from "../persistence/types.js";
+/**
+ * @description Specifies the database table name for a model
+ * @summary Decorator that sets the table name for a model class in the database
+ * @param {string} opts - The name of the table in the database
+ * @return {Function} A decorator function that can be applied to a class
+ * @function table
+ * @category Class Decorators
+ */
+export declare function table<OPTS = string>(opts?: OPTS): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Specifies the database column name for a model property
+ * @summary Decorator that maps a model property to a specific column name in the database
+ * @param {string} columnName - The name of the column in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function column
+ * @category Property Decorators
+ */
+export declare function column<OPTS = string>(columnName?: OPTS): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Enforces uniqueness constraint during model creation and update
+ * @summary Internal function used by the unique decorator to check if a property value already exists in the database
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The metadata type
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to check for uniqueness
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that resolves when the check is complete or rejects with a ConflictError
+ * @function uniqueOnCreateUpdate
+ * @memberOf module:core
+ */
+export declare function uniqueOnCreateUpdate<M extends Model, R extends Repo<M>>(this: R, context: ContextOf<R>, data: object, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Tags a property as unique
+ * @summary Decorator that ensures a property value is unique across all instances of a model in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function unique
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @unique()
+ *   @required()
+ *   username!: string;
+ * }
+ * ```
+ */
+export declare function unique(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Handles user identification for ownership tracking
+ * @summary Internal function used by the createdBy and updatedBy decorators to set ownership information
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to store the user identifier
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that rejects with an AuthorizationError if user identification is not supported
+ * @function createdByOnCreateUpdate
+ * @memberOf module:core
+ */
+export declare function createdByOnCreateUpdate<M extends Model, R extends Repo<M>>(this: R, context: ContextOf<R>, data: RelationsMetadata, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Tracks the creator of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who created the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function createdBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @createdBy()
+ *   creator!: string;
+ * }
+ * ```
+ */
+export declare function createdBy(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Tracks the last updater of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who last updated the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function updatedBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @updatedBy()
+ *   lastEditor!: string;
+ * }
+ * ```
+ */
+export declare function updatedBy(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function createdAt(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function updatedAt(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function persistentVersion(): (target: any, propertyKey?: any) => any;
+export declare function version(persistent?: boolean): (target: any, propertyKey?: any) => any;
+export declare function getPkTypes(model: Constructor | (() => Constructor)): (() => any)[];
+/**
+ * @description Defines a one-to-one relationship between models
+ * @summary Decorator that establishes a one-to-one relationship between the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function oneToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @oneToOne(Profile)
+ *   profile!: string | Profile;
+ * }
+ *
+ * class Profile extends BaseModel {
+ *   @required()
+ *   bio!: string;
+ * }
+ * ```
+ * @see oneToMany
+ * @see manyToOne
+ */
+export declare function oneToOne<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinColumnOpts?: JoinColumnOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Defines a one-to-many relationship between models
+ * @summary Decorator that establishes a one-to-many relationship between the current model and multiple instances of another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function oneToMany
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ *
+ *   @oneToMany(Book)
+ *   books!: string[] | Book[];
+ * }
+ *
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ * }
+ * ```
+ * @see oneToOne
+ * @see manyToOne
+ */
+export declare function oneToMany<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Defines a many-to-one relationship between models
+ * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function manyToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ *
+ *   @manyToOne(Author)
+ *   author!: string | Author;
+ * }
+ *
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ * }
+ * ```
+ * @see oneToMany
+ * @see oneToOne
+ */
+export declare function manyToOne<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Defines a many-to-one relationship between models
+ * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function manyToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ *
+ *   @manyToOne(Author)
+ *   author!: string | Author;
+ * }
+ *
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ * }
+ * ```
+ * @see oneToMany
+ * @see oneToOne
+ */
+export declare function manyToMany<M extends Model>(clazz: Constructor<M> | (() => Constructor<M>), cascadeOptions?: CascadeMetadata, populate?: boolean, joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions, fk?: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function noValidateOn(...ops: OperationKeys[]): (target: any, propertyKey?: any) => void;
+export declare function noValidateOnCreate(): (target: any, propertyKey?: any) => void;
+export declare function noValidateOnUpdate(): (target: any, propertyKey?: any) => void;
+export declare function noValidateOnCreateUpdate(): (target: any, propertyKey?: any) => void;
+/**
+ * @description Specifies the model property as a relation
+ * @summary Decorator that specifies the model property as a relation in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function relation
+ * @category Property Decorators
+ */
+export declare function relation(relationKey: string, meta: RelationsMetadata): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/model/index.d.cts

@@ -0,0 +1,11 @@
+/**
+ * @description Exports for the model module.
+ * @summary This file exports all the necessary components for the model functionality, including the BaseModel, construction utilities, decorators, and more.
+ * @module core/model
+ */
+export * from "./BaseModel.cjs";
+export * from "./construction.cjs";
+export * from "./decorators.cjs";
+export * from "./indexing.cjs";
+export * from "./SequenceModel.cjs";
+export * from "./types.cjs";

package/lib/types/model/index.d.mts

@@ -0,0 +1,11 @@
+/**
+ * @description Exports for the model module.
+ * @summary This file exports all the necessary components for the model functionality, including the BaseModel, construction utilities, decorators, and more.
+ * @module core/model
+ */
+export * from "./BaseModel.js";
+export * from "./construction.js";
+export * from "./decorators.js";
+export * from "./indexing.js";
+export * from "./SequenceModel.js";
+export * from "./types.js";

package/lib/types/model/indexing.d.cts

@@ -0,0 +1,20 @@
+import { OrderDirection } from "../repository/constants.cjs";
+import { propMetadata } from "@decaf-ts/decoration";
+/**
+ * @description Creates an index on a model property for improved query performance
+ * @summary Decorator that marks a property to be indexed in the database, optionally with specific directions and compositions
+ * @param {OrderDirection[]} [directions] - Optional array of sort directions for the index
+ * @param {string[]} [compositions] - Optional array of property names to create a composite index
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function index
+ * @category Property Decorators
+ */
+export declare function index(): ReturnType<typeof propMetadata>;
+export declare function index(name: string): ReturnType<typeof propMetadata>;
+export declare function index(directions: OrderDirection[]): ReturnType<typeof propMetadata>;
+export declare function index(directions: OrderDirection[], name: string): ReturnType<typeof propMetadata>;
+export declare function index(directions: OrderDirection[], compositions: string[]): ReturnType<typeof propMetadata>;
+export declare function index(directions: readonly OrderDirection[], compositions: readonly string[]): ReturnType<typeof propMetadata>;
+export declare function index(directions: readonly OrderDirection[], compositions: readonly string[], name: string): ReturnType<typeof propMetadata>;
+export declare function index(compositions: string[]): ReturnType<typeof propMetadata>;
+export declare function index(compositions: string[], name: string): ReturnType<typeof propMetadata>;

package/lib/types/model/indexing.d.mts

@@ -0,0 +1,20 @@
+import { OrderDirection } from "../repository/constants.js";
+import { propMetadata } from "@decaf-ts/decoration";
+/**
+ * @description Creates an index on a model property for improved query performance
+ * @summary Decorator that marks a property to be indexed in the database, optionally with specific directions and compositions
+ * @param {OrderDirection[]} [directions] - Optional array of sort directions for the index
+ * @param {string[]} [compositions] - Optional array of property names to create a composite index
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function index
+ * @category Property Decorators
+ */
+export declare function index(): ReturnType<typeof propMetadata>;
+export declare function index(name: string): ReturnType<typeof propMetadata>;
+export declare function index(directions: OrderDirection[]): ReturnType<typeof propMetadata>;
+export declare function index(directions: OrderDirection[], name: string): ReturnType<typeof propMetadata>;
+export declare function index(directions: OrderDirection[], compositions: string[]): ReturnType<typeof propMetadata>;
+export declare function index(directions: readonly OrderDirection[], compositions: readonly string[]): ReturnType<typeof propMetadata>;
+export declare function index(directions: readonly OrderDirection[], compositions: readonly string[], name: string): ReturnType<typeof propMetadata>;
+export declare function index(compositions: string[]): ReturnType<typeof propMetadata>;
+export declare function index(compositions: string[], name: string): ReturnType<typeof propMetadata>;

package/lib/types/model/types.d.cts

@@ -0,0 +1,60 @@
+import { Constructor } from "@decaf-ts/decoration";
+import { CascadeMetadata } from "../repository/index.cjs";
+import { PersistenceKeys } from "../persistence/constants.cjs";
+/**
+ * Describes join column options.
+ */
+export type JoinColumnOptions = {
+    /**
+     * Name of the column.
+     */
+    name?: string;
+    /**
+     * Name of the column in the entity to which this column is referenced.
+     */
+    referencedColumnName?: string;
+    /**
+     * Name of the foreign key constraint.
+     */
+    foreignKeyConstraintName?: string;
+};
+export type JoinTableOptions = {
+    /**
+     * Name of the table that will be created to store values of the both tables (join table).
+     * By default is auto generated.
+     */
+    name?: string;
+    /**
+     * First column of the join table.
+     */
+    joinColumn?: JoinColumnOptions;
+    /**
+     * Second (inverse) column of the join table.
+     */
+    inverseJoinColumn?: JoinColumnOptions;
+};
+export type JoinTableMultipleColumnsOptions = {
+    /**
+     * Name of the table that will be created to store values of the both tables (join table).
+     * By default is auto generated.
+     */
+    name?: string;
+    /**
+     * First column of the join table.
+     */
+    joinColumns?: JoinColumnOptions[];
+    /**
+     * Second (inverse) column of the join table.
+     */
+    inverseJoinColumns?: JoinColumnOptions[];
+};
+export type RelationsMetadata = {
+    class: Constructor<any> | (() => Constructor<any>);
+    cascade: CascadeMetadata;
+    populate: boolean;
+    name?: string;
+    joinTable?: JoinTableOptions;
+};
+export type ExtendedRelationsMetadata = RelationsMetadata & {
+    key: PersistenceKeys.ONE_TO_ONE | PersistenceKeys.ONE_TO_MANY | PersistenceKeys.MANY_TO_ONE | PersistenceKeys.MANY_TO_MANY;
+};

package/lib/types/model/types.d.mts

@@ -0,0 +1,60 @@
+import { Constructor } from "@decaf-ts/decoration";
+import { CascadeMetadata } from "../repository/index.js";
+import { PersistenceKeys } from "../persistence/constants.js";
+/**
+ * Describes join column options.
+ */
+export type JoinColumnOptions = {
+    /**
+     * Name of the column.
+     */
+    name?: string;
+    /**
+     * Name of the column in the entity to which this column is referenced.
+     */
+    referencedColumnName?: string;
+    /**
+     * Name of the foreign key constraint.
+     */
+    foreignKeyConstraintName?: string;
+};
+export type JoinTableOptions = {
+    /**
+     * Name of the table that will be created to store values of the both tables (join table).
+     * By default is auto generated.
+     */
+    name?: string;
+    /**
+     * First column of the join table.
+     */
+    joinColumn?: JoinColumnOptions;
+    /**
+     * Second (inverse) column of the join table.
+     */
+    inverseJoinColumn?: JoinColumnOptions;
+};
+export type JoinTableMultipleColumnsOptions = {
+    /**
+     * Name of the table that will be created to store values of the both tables (join table).
+     * By default is auto generated.
+     */
+    name?: string;
+    /**
+     * First column of the join table.
+     */
+    joinColumns?: JoinColumnOptions[];
+    /**
+     * Second (inverse) column of the join table.
+     */
+    inverseJoinColumns?: JoinColumnOptions[];
+};
+export type RelationsMetadata = {
+    class: Constructor<any> | (() => Constructor<any>);
+    cascade: CascadeMetadata;
+    populate: boolean;
+    name?: string;
+    joinTable?: JoinTableOptions;
+};
+export type ExtendedRelationsMetadata = RelationsMetadata & {
+    key: PersistenceKeys.ONE_TO_ONE | PersistenceKeys.ONE_TO_MANY | PersistenceKeys.MANY_TO_ONE | PersistenceKeys.MANY_TO_MANY;
+};