bigal 13.0.0-beta4 → 13.0.0-beta5

package/dist/index.d.cts

@@ -1,7 +1,30 @@
 import { Pool } from 'postgres-pool';
-import { E as Entity, a as ExcludeEntityCollections, b as ExcludeFunctions, N as NotEntityBrand, M as ModelMetadata, C as CreateUpdateParams, c as EntityStatic } from './shared/bigal.06e3c45d.cjs';
-export { h as ColumnBaseMetadata, f as ColumnBaseMetadataOptions, j as ColumnCollectionMetadata, i as ColumnCollectionMetadataOptions, k as ColumnMetadata, m as ColumnModelMetadata, l as ColumnModelMetadataOptions, n as ColumnModifierMetadata, p as ColumnTypeMetadata, o as ColumnTypeMetadataOptions, d as EntityFieldValue, q as ModelMetadataOptions, e as NotEntity, g as getMetadataStorage } from './shared/bigal.06e3c45d.cjs';
-export { C as ClassLike, c as column, a as createDateColumn, p as primaryColumn, t as table, u as updateDateColumn, v as versionColumn } from './shared/bigal.03669aef.cjs';
+
+interface ClassLike {
+    /**
+     * Returns the name of the function. Function names are read-only and can not be changed.
+     */
+    readonly constructor: {
+        readonly name: string;
+    };
+}
+
+/**
+ * Removes all entity collection properties. To be used as a re-map key function
+ */
+type ExcludeEntityCollections<T, K extends PropertyKey> = T extends NotEntityBrand[] | undefined ? K : T extends Entity[] | undefined ? never : K;
+
+/**
+ * Removes all functions and entity collection properties. To be used as a re-map key function
+ */
+type ExcludeFunctions<T, K extends PropertyKey> = T extends Function ? never : K;
+
+/**
+ * Changes all Entity value properties to Primitive (string|number) | Pick<Entity, 'id'>
+ */
+type CreateUpdateParams<T extends Entity> = {
+    [K in keyof T as ExcludeEntityCollections<NonNullable<T[K]>, ExcludeFunctions<T[K], K>>]?: T[K] extends NotEntityBrand | undefined ? T[K] : Extract<T[K], Entity> extends undefined ? T[K] : Exclude<T[K], Entity> | Pick<Extract<T[K], Entity>, 'id'>;
+};
 
 type EntityPrimitiveOrId<T> = T extends [] ? T extends (infer U)[] ? EntityPrimitiveOrId<U>[] : T : Extract<NonNullable<T>, Entity> extends undefined ? T : Exclude<NonNullable<T>, Entity> | Pick<Extract<NonNullable<T>, Entity>, 'id'>;
 
@@ -69,6 +92,303 @@ type QueryResultOptionalPopulated<T extends Entity, K extends keyof T> = Omit<Qu
     [P in K]-?: T[P] extends [] ? undefined extends T[P] ? EntityPrimitiveOrId<T[P]> | null : EntityPrimitiveOrId<T[P]> : EntityPrimitiveOrId<T[P]>;
 };
 
+type EntityFieldValue = boolean[] | Date | number[] | Record<string, unknown> | string[] | boolean | number | string | unknown | null;
+declare abstract class Entity {
+    abstract id: unknown;
+    static beforeCreate(values: CreateUpdateParams<Entity>): CreateUpdateParams<Entity> | Promise<CreateUpdateParams<Entity>>;
+    static beforeUpdate(values: CreateUpdateParams<Entity>): CreateUpdateParams<Entity> | Promise<CreateUpdateParams<Entity>>;
+}
+interface NotEntityBrand {
+    _notEntityBrand: void;
+}
+type NotEntity<T> = NotEntityBrand & T;
+interface EntityStatic<T extends Entity> {
+    beforeCreate?: (values: CreateUpdateParams<any>) => CreateUpdateParams<any> | Promise<CreateUpdateParams<any>>;
+    beforeUpdate?: (values: CreateUpdateParams<any>) => CreateUpdateParams<any> | Promise<CreateUpdateParams<any>>;
+    new (): T;
+}
+
+interface ColumnBaseMetadataOptions {
+    /**
+     * Name of class with @table decorator
+     */
+    target: string;
+    /**
+     * Column name in the database
+     */
+    name: string;
+    /**
+     * Class property to which the column is applied
+     */
+    propertyName: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required?: boolean;
+    /**
+     * Indicates if column is inserted by default. Default is true
+     */
+    insert?: boolean;
+    /**
+     * Indicates if column value is updated by "save" operation. Default is true
+     */
+    update?: boolean;
+    /**
+     * Indicates if this column is a primary key.
+     * Same can be achieved when @primaryColumn decorator is used
+     */
+    primary?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is inserted into the table
+     * Same can be achieved when @createDateColumn decorator is used
+     */
+    createDate?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is updated
+     * Same can be achieved when @updateDateColumn decorator is used
+     */
+    updateDate?: boolean;
+    /**
+     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+     * Same can be achieved when @versionColumn decorator is used
+     */
+    version?: boolean;
+}
+declare abstract class ColumnBaseMetadata {
+    /**
+     * Name of class with @table decorator
+     */
+    target: string;
+    /**
+     * Column name in the database
+     */
+    name: string;
+    /**
+     * Class property to which the column is applied
+     */
+    propertyName: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required: boolean;
+    /**
+     * Indicates if column is inserted by default. Default is true
+     */
+    insert: boolean;
+    /**
+     * Indicates if column value is updated by "save" operation. Default is true
+     */
+    update: boolean;
+    /**
+     * Indicates if this column is a primary key.
+     * Same can be achieved when @primaryColumn decorator is used
+     */
+    primary: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is inserted into the table
+     * Same can be achieved when @createDateColumn decorator is used
+     */
+    createDate: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is updated
+     * Same can be achieved when @updateDateColumn decorator is used
+     */
+    updateDate: boolean;
+    /**
+     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+     * Same can be achieved when @versionColumn decorator is used
+     */
+    version: boolean;
+    protected constructor({ target, name, propertyName, required, insert, update, primary, createDate, updateDate, version, }: ColumnBaseMetadataOptions);
+}
+
+interface ColumnCollectionMetadataOptions extends ColumnBaseMetadataOptions {
+    /**
+     * Type of the items in the collection
+     */
+    collection: string | (() => string);
+    /**
+     * Property name of the on the collection item type
+     */
+    via: string;
+    /**
+     * Name of the junction table for multi-multi associations
+     */
+    through?: string | (() => string);
+}
+declare class ColumnCollectionMetadata extends ColumnBaseMetadata {
+    private _collectionString?;
+    private _collectionFn?;
+    private _throughString?;
+    private _throughFn?;
+    /**
+     * Type of the items in the collection
+     */
+    get collection(): string;
+    /**
+     * Property name of the on the collection item type
+     */
+    via: string;
+    /**
+     * Name of the junction table for multi-multi associations
+     */
+    get through(): string | undefined;
+    constructor({ target, //
+    name, propertyName, required, insert, update, primary, createDate, updateDate, version, collection, via, through, }: ColumnCollectionMetadataOptions);
+}
+
+interface ColumnModelMetadataOptions extends ColumnBaseMetadataOptions {
+    /**
+     * Name of the model represented by this column id
+     */
+    model: string | (() => string);
+}
+declare class ColumnModelMetadata extends ColumnBaseMetadata {
+    private _modelString?;
+    private _modelFn?;
+    /**
+     * Name of the model represented by this column id
+     */
+    get model(): string;
+    constructor({ target, //
+    name, propertyName, required, insert, update, primary, createDate, updateDate, version, model, }: ColumnModelMetadataOptions);
+}
+
+interface ColumnTypeMetadataOptions extends ColumnBaseMetadataOptions {
+    /**
+     * Type of sql column
+     */
+    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Default database value
+     */
+    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+    /**
+     * Array of possible enumerated values
+     */
+    enum?: string[];
+    /**
+     * If set, enforces a maximum length check on the column
+     *
+     * Applies to types: string | string[]
+     */
+    maxLength?: number;
+}
+declare class ColumnTypeMetadata extends ColumnBaseMetadata {
+    /**
+     * Type of the column
+     */
+    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Default database value
+     */
+    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+    /**
+     * Array of possible enumerated values
+     */
+    enum?: string[];
+    /**
+     * If set, enforces a maximum length check on the column
+     *
+     * Applies to types: string | string[]
+     */
+    maxLength?: number;
+    constructor(options: ColumnTypeMetadataOptions);
+}
+
+type ColumnMetadata = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
+
+interface ColumnModifierMetadata {
+    /**
+     * Name of class with @table decorator
+     */
+    target: string;
+    /**
+     * Column name in the database
+     */
+    name?: string;
+    /**
+     * Class property to which the column is applied
+     */
+    propertyName: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required?: boolean;
+    /**
+     * Indicates if this column is a primary key.
+     * Same can be achieved when @primaryColumn decorator is used
+     */
+    primary?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is inserted into the table
+     * Same can be achieved when @createDateColumn decorator is used
+     */
+    createDate?: boolean;
+    /**
+     * Value will be equal to `new Date()` when the row is updated
+     * Same can be achieved when @updateDateColumn decorator is used
+     */
+    updateDate?: boolean;
+    /**
+     * Value will be set to 1 when the row is inserted. Value will be incremented by one when the row is updated
+     * Same can be achieved when @versionColumn decorator is used
+     */
+    version?: boolean;
+    /**
+     * Type of sql column
+     */
+    type?: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Name of the model represented by this column id
+     */
+    model?: string | (() => string);
+}
+
+type Column = ColumnCollectionMetadata | ColumnModelMetadata | ColumnTypeMetadata;
+type ColumnByStringId = Record<string, Column>;
+interface ModelMetadataOptions<T extends Entity> {
+    name: string;
+    type: EntityStatic<T>;
+    connection?: string;
+    tableName?: string;
+    readonly?: boolean;
+}
+declare class ModelMetadata<T extends Entity> {
+    private _columns;
+    private _primaryKeyColumn;
+    private _createDateColumns;
+    private _updateDateColumns;
+    private _versionDateColumns;
+    set columns(columns: readonly Column[]);
+    get columns(): readonly Column[];
+    get primaryKeyColumn(): Column | undefined;
+    get createDateColumns(): readonly Column[];
+    get updateDateColumns(): readonly Column[];
+    get versionColumns(): readonly Column[];
+    name: string;
+    type: EntityStatic<T>;
+    connection?: string;
+    tableName: string;
+    readonly: boolean;
+    columnsByColumnName: ColumnByStringId;
+    columnsByPropertyName: ColumnByStringId;
+    constructor({ name, //
+    type, connection, tableName, readonly, }: ModelMetadataOptions<T>);
+}
+
+/**
+ * This represents an object to store all of the decorator data. Since there can be multiple decorators per
+ * class/property, things will be reconciled when entities are initialized
+ */
+declare class MetadataStorage<T extends Entity> {
+    readonly models: ModelMetadata<T>[];
+    readonly columns: ColumnMetadata[];
+    readonly columnModifiers: ColumnModifierMetadata[];
+}
+
+declare function getMetadataStorage<T extends Entity>(): MetadataStorage<T>;
+
 type ExcludeUndefined<T> = Exclude<T, undefined>;
 type LiteralValues<TValue> = (TValue | null)[] | TValue | null;
 type WhereClauseValue<TValue> = TValue extends NotEntityBrand | undefined ? Exclude<TValue, NotEntityBrand | undefined> : Extract<TValue, Entity> extends undefined ? LiteralValues<ExcludeUndefined<TValue>> : (ExcludeUndefined<Exclude<TValue, Entity>> | null)[] | (Pick<Extract<ExcludeUndefined<TValue>, Entity>, 'id'> | null)[] | ExcludeUndefined<Exclude<TValue, Entity>> | Pick<Extract<ExcludeUndefined<TValue>, Entity>, 'id'> | null;
@@ -453,6 +773,101 @@ declare class Repository<T extends Entity> extends ReadonlyRepository<T> impleme
     destroy(where: WhereQuery<T>, options: DeleteOptions<T>): DestroyResult<T, QueryResult<T>[]>;
 }
 
+interface ColumnBaseOptions {
+    /**
+     * Column name in the database
+     */
+    name?: string;
+    /**
+     * Indicates if a value is required for creates.
+     */
+    required?: boolean;
+}
+
+interface ColumnCollectionOptions extends ColumnBaseOptions {
+    /**
+     * Type of the items in the collection
+     */
+    collection: string | (() => string);
+    /**
+     * Property name of the on the collection item type
+     */
+    via: string;
+    /**
+     * Name of the junction table for multi-multi associations
+     */
+    through?: string | (() => string);
+}
+
+interface ColumnModelOptions extends ColumnBaseOptions {
+    /**
+     * Type of the entity represented by this column id
+     */
+    model: string | (() => string);
+}
+
+interface ColumnTypeOptions extends ColumnBaseOptions {
+    /**
+     * Type of the column
+     */
+    type: 'array' | 'binary' | 'boolean' | 'boolean[]' | 'date' | 'datetime' | 'float' | 'float[]' | 'integer' | 'integer[]' | 'json' | 'string' | 'string[]';
+    /**
+     * Default database value
+     */
+    defaultsTo?: boolean[] | number[] | string[] | boolean | number | string | (() => Date | Record<string, unknown> | boolean | number | string) | [];
+    /**
+     * Array of possible enumerated values
+     */
+    enum?: string[];
+    /**
+     * If set, enforces a maximum length check on the column
+     *
+     * Applies to types: string | string[]
+     */
+    maxLength?: number;
+}
+
+type ColumnOptions$1 = ColumnCollectionOptions | ColumnModelOptions | ColumnTypeOptions;
+type ReturnFunctionType$5 = (object: ClassLike, propertyName: string) => void;
+declare function column(options?: ColumnOptions$1): ReturnFunctionType$5;
+declare function column(dbColumnName: string, options?: ColumnOptions$1): ReturnFunctionType$5;
+
+type ReturnFunctionType$4 = (object: ClassLike, propertyName: string) => void;
+declare function createDateColumn(options?: ColumnTypeOptions): ReturnFunctionType$4;
+declare function createDateColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType$4;
+
+type ColumnOptions = ColumnModelOptions | ColumnTypeOptions;
+type ReturnFunctionType$3 = (object: ClassLike, propertyName: string) => void;
+declare function primaryColumn(options?: ColumnOptions): ReturnFunctionType$3;
+declare function primaryColumn(dbColumnName: string, options?: ColumnOptions): ReturnFunctionType$3;
+
+interface TableOptions {
+    /**
+     * Table name in the database
+     */
+    name?: string;
+    /**
+     * Connection name to use for queries
+     */
+    connection?: string;
+    /**
+     * Indicates if create, update, delete statements should be available
+     */
+    readonly?: boolean;
+}
+
+type ReturnFunctionType$2 = (object: any) => void;
+declare function table(options?: TableOptions): ReturnFunctionType$2;
+declare function table(dbName: string, options: TableOptions): ReturnFunctionType$2;
+
+type ReturnFunctionType$1 = (object: ClassLike, propertyName: string) => void;
+declare function updateDateColumn(options?: ColumnTypeOptions): ReturnFunctionType$1;
+declare function updateDateColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType$1;
+
+type ReturnFunctionType = (object: ClassLike, propertyName: string) => void;
+declare function versionColumn(options?: ColumnTypeOptions): ReturnFunctionType;
+declare function versionColumn(dbColumnName: string, options?: ColumnTypeOptions): ReturnFunctionType;
+
 interface IConnection {
     pool: Pool;
     readonlyPool?: Pool;
@@ -474,4 +889,4 @@ interface InitializeOptions extends IConnection {
  */
 declare function initialize({ models, pool, readonlyPool, connections, expose }: InitializeOptions): Record<string, IReadonlyRepository<Entity> | IRepository<Entity>>;
 
-export { CreateUpdateParams, Entity, type EntityPrimitiveOrId, EntityStatic, ExcludeEntityCollections, ExcludeFunctions, type GetValueType, type IConnection, type IReadonlyRepository, type IRepository, type IRepositoryOptions, type IncludeFunctions, type InitializeOptions, type IsValueOfType, ModelMetadata, NotEntityBrand, type OmitEntityCollections, type OmitFunctions, type PickAsType, type PickByValueType, type PickFunctions, type Populated, type QueryResult, type QueryResultOptionalPopulated, type QueryResultPopulated, ReadonlyRepository, Repository, initialize };
+export { type ClassLike, ColumnBaseMetadata, type ColumnBaseMetadataOptions, ColumnCollectionMetadata, type ColumnCollectionMetadataOptions, type ColumnMetadata, ColumnModelMetadata, type ColumnModelMetadataOptions, type ColumnModifierMetadata, ColumnTypeMetadata, type ColumnTypeMetadataOptions, type CreateUpdateParams, Entity, type EntityFieldValue, type EntityPrimitiveOrId, type EntityStatic, type ExcludeEntityCollections, type ExcludeFunctions, type GetValueType, type IConnection, type IReadonlyRepository, type IRepository, type IRepositoryOptions, type IncludeFunctions, type InitializeOptions, type IsValueOfType, ModelMetadata, type ModelMetadataOptions, type NotEntity, type NotEntityBrand, type OmitEntityCollections, type OmitFunctions, type PickAsType, type PickByValueType, type PickFunctions, type Populated, type QueryResult, type QueryResultOptionalPopulated, type QueryResultPopulated, ReadonlyRepository, Repository, column, createDateColumn, getMetadataStorage, initialize, primaryColumn, table, updateDateColumn, versionColumn };