@sqb/connect 4.10.0 → 4.10.2

package/types/orm/commands/create.command.d.ts

@@ -0,0 +1,20 @@
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+export type CreateCommandArgs = {
+    entity: EntityMetadata;
+    connection: SqbConnection;
+    values: any;
+    returning?: boolean;
+};
+type CreateCommandContext = {
+    entity: EntityMetadata;
+    queryParams: any;
+    queryValues: any;
+    colCount: number;
+};
+export declare class CreateCommand {
+    protected constructor();
+    static execute(args: CreateCommandArgs): Promise<any>;
+    protected static _prepareParams(ctx: CreateCommandContext, entity: EntityMetadata, values: any, prefix?: string, suffix?: string): Promise<void>;
+}
+export {};

package/types/orm/commands/delete.command.d.ts

@@ -0,0 +1,11 @@
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
+export type DestroyCommandArgs = {
+    entity: EntityMetadata;
+    connection: SqbConnection;
+} & Repository.DeleteManyOptions;
+export declare class DeleteCommand {
+    protected constructor();
+    static execute(args: DestroyCommandArgs): Promise<number>;
+}

package/types/orm/commands/find.command.d.ts

@@ -0,0 +1,44 @@
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { AssociationNode } from '../model/association-node.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
+import { RowConverter } from './row-converter.js';
+export type FindCommandArgs = {
+    entity: EntityMetadata;
+    connection: SqbConnection;
+} & Repository.FindManyOptions;
+export declare class FindCommand {
+    maxEagerFetch: number;
+    maxSubQueries: number;
+    readonly mainEntity: EntityMetadata;
+    readonly resultEntity: EntityMetadata;
+    readonly converter: RowConverter;
+    readonly mainAlias: string;
+    resultAlias: string;
+    private _joins;
+    private _selectColumns;
+    private _filter;
+    private _sort?;
+    protected constructor(selectEntity: EntityMetadata, outputEntity: EntityMetadata);
+    static create(source: EntityMetadata | AssociationNode, opts?: {
+        maxSubQueries?: number;
+        maxEagerFetch?: number;
+    }): Promise<FindCommand>;
+    static execute(args: FindCommandArgs): Promise<any[]>;
+    addFields(opts?: {
+        tableAlias?: string;
+        converter?: RowConverter;
+        entity?: EntityMetadata;
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+        sort?: string[];
+        prefix?: string;
+        suffix?: string;
+    }): Promise<void>;
+    private _selectColumn;
+    filter(filter: any): Promise<void>;
+    sort(sortFields: string[]): Promise<void>;
+    execute(args: Pick<FindCommandArgs, 'connection' | 'distinct' | 'offset' | 'limit' | 'params' | 'onTransformRow'>): Promise<any[]>;
+    private _getEntityFromAlias;
+}

package/types/orm/commands/row-converter.d.ts

@@ -0,0 +1,55 @@
+import { Type } from 'ts-gems';
+import { DataType } from '@sqb/builder';
+import type { FieldInfoMap } from '../../client/field-info-map';
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { ColumnTransformFunction } from '../orm.type.js';
+import type { Repository } from '../repository.class.js';
+import type { FindCommand } from './find.command.js';
+export interface ValueProperty {
+    fieldAlias: string;
+    dataType?: DataType;
+    parse?: ColumnTransformFunction;
+}
+export interface ObjectProperty {
+    converter: RowConverter;
+    type: Type;
+}
+export interface NestedProperty {
+    converter: RowConverter;
+    type: Type;
+    parentField: string;
+    keyField: string;
+    findCommand: FindCommand;
+    sort?: string[];
+    paramValues: any[];
+}
+export declare class RowConverter {
+    resultType: Type;
+    parent?: RowConverter | undefined;
+    private _properties;
+    private _propertyKeys?;
+    constructor(resultType: Type, parent?: RowConverter | undefined);
+    addValueProperty(args: {
+        name: string;
+        fieldAlias: string;
+        dataType?: DataType;
+        parse?: ColumnTransformFunction;
+    }): ValueProperty;
+    addObjectProperty(args: {
+        name: string;
+        type: Type;
+    }): ObjectProperty;
+    addNestedProperty(args: {
+        name: string;
+        type: Type;
+        findCommand: FindCommand;
+        parentField: string;
+        keyField: string;
+        sort?: string[];
+    }): NestedProperty;
+    get keys(): string[];
+    transform(connection: SqbConnection, fields: FieldInfoMap, rows: any, onTransform?: Repository.TransformRowFunction): Promise<any[]>;
+    private _rowToObject;
+    private _iterateForNested;
+    private _checkCircularDep;
+}

package/types/orm/commands/update.command.d.ts

@@ -0,0 +1,22 @@
+import { SqbConnection } from '../../client/sqb-connection.js';
+import { EntityMetadata } from '../model/entity-metadata.js';
+import { Repository } from '../repository.class.js';
+export type UpdateCommandArgs = {
+    entity: EntityMetadata;
+    connection: SqbConnection;
+    values: any;
+} & Repository.UpdateManyOptions;
+type UpdateCommandContext = {
+    entity: EntityMetadata;
+    queryParams: any;
+    queryValues: any;
+    queryFilter: any[];
+    colCount: number;
+};
+export declare class UpdateCommand {
+    protected constructor();
+    static execute(args: UpdateCommandArgs): Promise<number>;
+    protected static _prepareFilter(ctx: UpdateCommandContext, filter: any): Promise<void>;
+    protected static _prepareParams(ctx: UpdateCommandContext, entity: EntityMetadata, values: any, prefix?: string, suffix?: string): Promise<void>;
+}
+export {};

package/types/orm/decorators/column.decorator.d.ts

@@ -0,0 +1,4 @@
+import { DataType } from '@sqb/builder';
+import { ColumnFieldOptions } from '../model/column-field-metadata.js';
+export declare function Column(type?: DataType): PropertyDecorator;
+export declare function Column(options?: ColumnFieldOptions): PropertyDecorator;

package/types/orm/decorators/embedded.decorator.d.ts

@@ -0,0 +1,3 @@
+import { EmbeddedFieldOptions } from '../model/embedded-field-metadata.js';
+import { TypeThunk } from '../orm.type.js';
+export declare function Embedded(type?: TypeThunk, options?: EmbeddedFieldOptions): PropertyDecorator;

package/types/orm/decorators/entity.decorator.d.ts

@@ -0,0 +1,38 @@
+import { Maybe, Type } from 'ts-gems';
+import { AssociationFieldMetadata } from '../model/association-field-metadata.js';
+import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
+import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import { AnyFieldMetadata, EntityMetadata, EntityOptions } from '../model/entity-metadata.js';
+import { IndexMetadata } from '../model/index-metadata.js';
+export declare function Entity(options?: EntityOptions | string): ClassDecorator;
+export declare namespace Entity {
+    const getMetadata: typeof EntityMetadata.get;
+    const getOwnMetadata: typeof EntityMetadata.getOwn;
+    function getField<T>(ctor: Type<T>, key: keyof T | string): Maybe<AnyFieldMetadata>;
+    function getColumnField<T>(ctor: Type<T>, key: keyof T | string): Maybe<ColumnFieldMetadata>;
+    function getEmbeddedField<T>(ctor: Type<T>, key: keyof T | string): Maybe<EmbeddedFieldMetadata>;
+    function getAssociationField<T>(ctor: Type<T>, key: keyof T | string): Maybe<AssociationFieldMetadata>;
+    function getColumnFieldByFieldName(ctor: Type, fieldName: string): Maybe<ColumnFieldMetadata>;
+    function find(ctor: Type, predicate: (el: AnyFieldMetadata) => boolean): Maybe<AnyFieldMetadata>;
+    function getFieldNames(ctor: Type, filter?: (el: AnyFieldMetadata) => boolean): string[];
+    function getColumnFieldNames(ctor: Type): string[];
+    function getEmbeddedFieldNames(ctor: Type): string[];
+    function getAssociationFieldNames(ctor: Type): string[];
+    function getNonAssociationFieldNames(ctor: Type): string[];
+    function getInsertColumnNames(ctor: Type): string[];
+    function getUpdateColumnNames(ctor: Type): string[];
+    function getPrimaryIndex(ctor: Type): Maybe<IndexMetadata>;
+    function getPrimaryIndexColumns(ctor: Type): ColumnFieldMetadata[];
+    function mixin<A, B>(derivedCtor: Type<A>, baseB: Type<B>): Type<A & B>;
+    function mixin<A, B, C>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
+    function mixin<A, B, C, D>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;
+    function mixin<A, B, C, D, E>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>): Type<A & B & C & D & E>;
+    function mixin<A, B, C, D, E, F>(derivedCtor: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>, baseF: Type<F>): Type<A & B & C & D & E & F>;
+    function Pick<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Pick<T, typeof keys[number]>>;
+    function Omit<T, K extends keyof T>(classRef: Type<T>, keys: readonly K[]): Type<Omit<T, typeof keys[number]>>;
+    function Union<A, B>(baseA: Type<A>, baseB: Type<B>): Type<A & B>;
+    function Union<A, B, C>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>): Type<A & B & C>;
+    function Union<A, B, C, D>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>): Type<A & B & C & D>;
+    function Union<A, B, C, D, E>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>): Type<A & B & C & D & E>;
+    function Union<A, B, C, D, E, F>(baseA: Type<A>, baseB: Type<B>, baseC: Type<C>, baseD: Type<D>, baseE: Type<E>, baseF: Type<F>): Type<A & B & C & D & E & F>;
+}

package/types/orm/decorators/events.decorator.d.ts

@@ -0,0 +1,6 @@
+export declare function BeforeInsert(): PropertyDecorator;
+export declare function BeforeUpdate(): PropertyDecorator;
+export declare function BeforeDestroy(): PropertyDecorator;
+export declare function AfterInsert(): PropertyDecorator;
+export declare function AfterUpdate(): PropertyDecorator;
+export declare function AfterDestroy(): PropertyDecorator;

package/types/orm/decorators/foreignkey.decorator.d.ts

@@ -0,0 +1,2 @@
+import { TypeThunk } from '../orm.type.js';
+export declare function ForeignKey(type: TypeThunk, targetKey?: string): PropertyDecorator;

package/types/orm/decorators/index.decorator.d.ts

@@ -0,0 +1,3 @@
+import { IndexMetadata } from '../model/index-metadata.js';
+export declare function Index(fields: string | string[], options?: Omit<IndexMetadata, 'columns'>): ClassDecorator;
+export declare function Index(options?: Omit<IndexMetadata, 'columns'>): PropertyDecorator;

package/types/orm/decorators/link.decorator.d.ts

@@ -0,0 +1,13 @@
+import { AssociationFieldOptions } from '../model/association-field-metadata.js';
+import { TypeThunk } from '../orm.type.js';
+type LinkArgs<T> = {
+    sourceKey?: string;
+    targetKey?: keyof T;
+    where?: object | object[];
+};
+type LinkPropertyDecorator = PropertyDecorator & {
+    toOne<T>(type: TypeThunk<T>, args?: LinkArgs<T>): LinkPropertyDecorator;
+    toMany<T>(type: TypeThunk<T>, args?: LinkArgs<T>): LinkPropertyDecorator;
+};
+export declare function Link(options?: AssociationFieldOptions): LinkPropertyDecorator;
+export {};

package/types/orm/decorators/primarykey.decorator.d.ts

@@ -0,0 +1,3 @@
+import { IndexMetadata } from '../model/index-metadata.js';
+export declare function PrimaryKey(fields: string | string[], options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): ClassDecorator;
+export declare function PrimaryKey(options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): PropertyDecorator;

package/types/orm/decorators/transform.decorator.d.ts

@@ -0,0 +1,3 @@
+import { ColumnTransformFunction } from '../orm.type.js';
+export declare function Parse(fn: ColumnTransformFunction): PropertyDecorator;
+export declare function Serialize(fn: ColumnTransformFunction): PropertyDecorator;

package/types/orm/model/association-field-metadata.d.ts

@@ -0,0 +1,12 @@
+import { AssociationNode } from './association-node.js';
+import { EntityMetadata } from './entity-metadata.js';
+import { FieldMetadata } from './field-metadata.js';
+export type AssociationFieldOptions = Partial<Omit<AssociationFieldMetadata, 'entity' | 'name' | 'kind' | 'association'>>;
+export interface AssociationFieldMetadata extends FieldMetadata {
+    readonly kind: 'association';
+    readonly association: AssociationNode;
+}
+export declare namespace AssociationFieldMetadata {
+    function create(entity: EntityMetadata, name: string, association: AssociationNode, options?: AssociationFieldOptions): AssociationFieldMetadata;
+    function assign(target: AssociationFieldMetadata, options: AssociationFieldOptions): void;
+}

package/types/orm/model/association-node.d.ts

@@ -0,0 +1,9 @@
+import { Association } from './association.js';
+export declare class AssociationNode extends Association {
+    prior?: AssociationNode;
+    next?: AssociationNode;
+    conditions?: any[];
+    getFirst(): AssociationNode;
+    getLast(): AssociationNode;
+    returnsMany(): boolean;
+}

package/types/orm/model/association.d.ts

@@ -0,0 +1,27 @@
+import { AssociationSettings, TypeThunk } from '../orm.type.js';
+import { ColumnFieldMetadata } from './column-field-metadata.js';
+import { EntityMetadata } from './entity-metadata.js';
+export declare class Association {
+    private _resolved?;
+    private _source?;
+    private _target?;
+    private _sourceKey?;
+    private _targetKey?;
+    private _sourceProperty?;
+    private _targetProperty?;
+    name: string;
+    readonly source: TypeThunk;
+    readonly target: TypeThunk;
+    readonly sourceKey?: string;
+    readonly targetKey?: string;
+    readonly many: boolean;
+    constructor(name: string, args: AssociationSettings);
+    resolveSource(): Promise<EntityMetadata>;
+    resolveTarget(): Promise<EntityMetadata>;
+    resolveSourceKey(): Promise<string>;
+    resolveSourceProperty(): Promise<ColumnFieldMetadata>;
+    resolveTargetKey(): Promise<string>;
+    resolveTargetProperty(): Promise<ColumnFieldMetadata>;
+    returnsMany(): boolean;
+    protected _resolveKeys(): Promise<void>;
+}

package/types/orm/model/column-field-metadata.d.ts

@@ -0,0 +1,75 @@
+import { DataType } from '@sqb/builder';
+import type { ColumnAutoGenerationStrategy, ColumnTransformFunction, DefaultValueGetter, EnumValue, FieldValue } from '../orm.type.js';
+import type { EntityMetadata } from './entity-metadata.js';
+import { FieldMetadata } from './field-metadata.js';
+export type ColumnFieldOptions = Partial<Omit<ColumnFieldMetadata, 'entity' | 'name' | 'kind'>>;
+export interface ColumnFieldMetadata extends FieldMetadata {
+    readonly kind: 'column';
+    /**
+     Name of table field
+     */
+    fieldName: string;
+    /**
+     JS type. String, Boolean, Person etc
+     */
+    type?: Function;
+    /**
+     * Column data type
+     */
+    dataType?: DataType;
+    /**
+     * Field comment
+     */
+    comment?: string;
+    /**
+     * Column's default value
+     */
+    default?: FieldValue | DefaultValueGetter;
+    /**
+     * Indicates if column data is an array
+     */
+    isArray?: boolean;
+    /**
+     * Indicates enum values
+     */
+    enum?: EnumValue;
+    /**
+     * Character or byte length of column
+     */
+    length?: number;
+    /**
+     * The precision for a decimal field
+     */
+    precision?: number;
+    /**
+     * The scale for a decimal field
+     */
+    scale?: number;
+    /**
+     * Fields's collation.
+     */
+    collation?: string;
+    /**
+     * Indicates auto generation strategy
+     */
+    autoGenerated?: ColumnAutoGenerationStrategy;
+    /**
+     * Indicates if column value can be null
+     */
+    notNull?: boolean;
+    /**
+     * Indicates if column value is used in update queries
+     */
+    noUpdate?: boolean;
+    /**
+     * Indicates if column value is used in insert queries
+     */
+    noInsert?: boolean;
+    parse?: ColumnTransformFunction;
+    serialize?: ColumnTransformFunction;
+}
+export declare namespace ColumnFieldMetadata {
+    function create(entity: EntityMetadata, name: string, options?: ColumnFieldOptions): ColumnFieldMetadata;
+    function assign(target: ColumnFieldMetadata, options: ColumnFieldOptions): void;
+    function checkEnumValue(col: ColumnFieldMetadata, v: FieldValue): void;
+}

package/types/orm/model/embedded-field-metadata.d.ts

@@ -0,0 +1,14 @@
+import { TypeThunk } from '../orm.type.js';
+import type { EntityMetadata } from './entity-metadata.js';
+import { FieldMetadata } from './field-metadata.js';
+export type EmbeddedFieldOptions = Partial<Omit<EmbeddedFieldMetadata, 'entity' | 'name' | 'kind' | 'type'>>;
+export interface EmbeddedFieldMetadata extends FieldMetadata {
+    readonly kind: 'object';
+    type: TypeThunk;
+    fieldNamePrefix?: string;
+    fieldNameSuffix?: string;
+}
+export declare namespace EmbeddedFieldMetadata {
+    function create(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedFieldOptions): EmbeddedFieldMetadata;
+    function resolveType(meta: EmbeddedFieldMetadata): Promise<EntityMetadata>;
+}

package/types/orm/model/entity-metadata.d.ts

@@ -0,0 +1,50 @@
+import { Maybe, Type } from 'ts-gems';
+import { Ctor, TypeThunk } from '../orm.type.js';
+import { Association } from './association.js';
+import { AssociationFieldMetadata, AssociationFieldOptions } from './association-field-metadata.js';
+import { AssociationNode } from './association-node.js';
+import { ColumnFieldMetadata, ColumnFieldOptions } from './column-field-metadata.js';
+import { EmbeddedFieldMetadata, EmbeddedFieldOptions } from './embedded-field-metadata.js';
+import { IndexMetadata } from './index-metadata.js';
+export type AnyFieldMetadata = ColumnFieldMetadata | EmbeddedFieldMetadata | AssociationFieldMetadata;
+export type EntityOptions = Partial<Pick<EntityMetadata, 'name' | 'schema' | 'comment' | 'tableName'>>;
+export interface EntityMetadata {
+    readonly ctor: Type;
+    readonly name: string;
+    tableName?: string;
+    schema?: string;
+    comment?: string;
+    fields: Record<string, AnyFieldMetadata>;
+    indexes: IndexMetadata[];
+    foreignKeys: Association[];
+    eventListeners: Record<string, Function[]>;
+}
+export declare namespace EntityMetadata {
+    function define(ctor: Ctor): EntityMetadata;
+    function get(ctor: Ctor): Maybe<EntityMetadata>;
+    function getOwn(ctor: Ctor): Maybe<EntityMetadata>;
+    function getField(entity: EntityMetadata, fieldName: string): Maybe<AnyFieldMetadata>;
+    function getColumnField(entity: EntityMetadata, fieldName: string): Maybe<ColumnFieldMetadata>;
+    function getEmbeddedField(entity: EntityMetadata, fieldName: string): Maybe<EmbeddedFieldMetadata>;
+    function getAssociationField(entity: EntityMetadata, fieldName: string): Maybe<AssociationFieldMetadata>;
+    function findField(entity: EntityMetadata, predicate: (el: AnyFieldMetadata) => boolean): Maybe<AnyFieldMetadata>;
+    function getColumnFieldByFieldName(entity: EntityMetadata, fieldName: string): Maybe<ColumnFieldMetadata>;
+    function getFieldNames(entity: EntityMetadata, filter?: (el: AnyFieldMetadata) => boolean): string[];
+    function getColumnFieldNames(entity: EntityMetadata): string[];
+    function getEmbeddedFieldNames(entity: EntityMetadata): string[];
+    function getAssociationFieldNames(entity: EntityMetadata): string[];
+    function getNonAssociationFieldNames(entity: EntityMetadata): string[];
+    function getInsertColumnNames(entity: EntityMetadata): string[];
+    function getUpdateColumnNames(entity: EntityMetadata): string[];
+    function getPrimaryIndex(entity: EntityMetadata): Maybe<IndexMetadata>;
+    function getPrimaryIndexColumns(entity: EntityMetadata): ColumnFieldMetadata[];
+    function getForeignKeyFor(src: EntityMetadata, trg: EntityMetadata): Promise<Maybe<Association>>;
+    function addIndex(entity: EntityMetadata, index: IndexMetadata): void;
+    function addForeignKey(entity: EntityMetadata, propertyKey: string, target: TypeThunk, targetKey?: string): void;
+    function addEventListener(entity: EntityMetadata, event: string, fn: Function): void;
+    function defineColumnField(entity: EntityMetadata, name: string, options?: ColumnFieldOptions): ColumnFieldMetadata;
+    function defineEmbeddedField(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedFieldOptions): EmbeddedFieldMetadata;
+    function defineAssociationField(entity: EntityMetadata, propertyKey: string, association: AssociationNode, options?: AssociationFieldOptions): AssociationFieldMetadata;
+    function setPrimaryKeys(entity: EntityMetadata, column: string | string[], options?: Omit<IndexMetadata, 'columns' | 'unique' | 'primary'>): void;
+    function mixin(derived: EntityMetadata, base: EntityMetadata, filter?: (n: string) => boolean): void;
+}

package/types/orm/model/field-metadata.d.ts

@@ -0,0 +1,16 @@
+import type { FieldKind } from '../orm.type.js';
+import type { EntityMetadata } from './entity-metadata.js';
+export interface FieldMetadata {
+    readonly entity: EntityMetadata;
+    readonly name: string;
+    readonly kind: FieldKind;
+    /**
+     * Indicates whether or not to hide this field by default when making queries.
+     */
+    hidden?: boolean;
+    /**
+     * Indicates whether or not to include this field by default when making queries.
+     * If this set to "true" the field must be requested using "include" or "pick" option.
+     */
+    exclusive?: boolean;
+}

package/types/orm/model/index-metadata.d.ts

@@ -0,0 +1,18 @@
+export interface IndexMetadata {
+    /**
+     *  Columns of the index
+     */
+    columns: string[];
+    /**
+     *  Name of the index
+     */
+    name?: string;
+    /**
+     * Specifies if index is unique
+     */
+    unique?: boolean;
+    /**
+     * Specifies if index is primary
+     */
+    primary?: boolean;
+}

package/types/orm/model/link-chain.d.ts

@@ -0,0 +1,13 @@
+import { Type } from 'ts-gems';
+import { TypeResolver, TypeThunk } from '../orm.type.js';
+import { AssociationNode } from './association-node.js';
+export declare class LinkChain<T> {
+    target: TypeThunk<T>;
+    first: AssociationNode;
+    current: AssociationNode;
+    constructor(target: TypeThunk<T>, targetKey?: keyof T, sourceKey?: string, many?: boolean);
+    where(conditions: object | object[]): this;
+    linkToOne<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
+    linkToMany<K>(target: Type<K> | TypeResolver<K>, targetColumn?: keyof K, parentColumn?: keyof T): LinkChain<K>;
+    private _newNode;
+}

package/types/orm/orm.const.d.ts

@@ -0,0 +1,2 @@
+export declare const ENTITY_METADATA_KEY: unique symbol;
+export declare const REPOSITORY_KEY: unique symbol;

package/types/orm/orm.type.d.ts

@@ -0,0 +1,20 @@
+import { Type } from 'ts-gems';
+export type Ctor = Type | Function;
+export type FieldKind = 'column' | 'object' | 'association';
+/**
+ * Indicates auto generation strategy
+ */
+export type ColumnAutoGenerationStrategy = 'increment' | 'uuid' | 'rowid' | 'timestamp' | 'custom';
+export type ColumnTransformFunction = (value: any, name: string) => any;
+export type TypeResolver<T> = () => Type<T> | Promise<Type<T>>;
+export type TypeThunk<T = any> = Type<T> | TypeResolver<T>;
+export type EnumValue = (FieldValue)[] | Object;
+export type FieldValue = string | number | boolean | Date | null;
+export type DefaultValueGetter = (obj?: any) => FieldValue | undefined;
+export interface AssociationSettings {
+    source: TypeThunk;
+    target: TypeThunk;
+    sourceKey?: string;
+    targetKey?: string;
+    many?: boolean;
+}