@carno.js/orm 0.2.3

package/dist/driver/driver.interface.d.ts

@@ -0,0 +1,333 @@
+import { PropertyOptions } from "../decorators/property.decorator";
+import { Collection } from "../domain/collection";
+import { Reference } from "../domain/reference";
+import { ValueObject } from "../common/value-object";
+export interface DriverInterface {
+    connectionString: string;
+    readonly dbType: "postgres" | "mysql";
+    executeStatement(statement: Statement<any>): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    executeSql(s: string): Promise<any>;
+    snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined>;
+    getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
+    getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo): string;
+    getCreateIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
+    getAddColumn(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff, colDiffInstructions: string[]): void;
+    getDropColumn(colDiffInstructions: string[], schema: string | undefined, tableName: string, colName: string): void;
+    getDropIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: UniqueStatement, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: UniqueStatement, schema: string | undefined, tableName: string): string;
+    getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getDropConstraint(param: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    getAddUniqueConstraint(schema: string | undefined, tableName: string, colName: string): string;
+    getAlterTableDropNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableDropNotNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableEnumInstruction(schema: string, tableName: string, colName: string, colDiff: ColDiff): string;
+    getDropTypeEnumInstruction(param: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    transaction<T>(callback: (tx: any) => Promise<T>): Promise<T>;
+}
+export type ValueOrInstance<T> = T extends ValueObject<any, any> ? // @ts-ignore
+T | T["value"] : NonNullable<T>;
+export type SnapshotConstraintInfo = {
+    indexName: string;
+    consDef: string;
+    type: string;
+};
+export interface ConnectionSettings<T extends DriverInterface = DriverInterface> {
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    database?: string;
+    connectionString?: string;
+    max?: number;
+    idleTimeout?: number;
+    maxLifetime?: number;
+    connectionTimeout?: number;
+    ssl?: boolean;
+    driver: new (options: ConnectionSettings<T>) => T;
+    entities?: Function[] | string;
+    migrationPath?: string;
+}
+export type ConditionOperators<T, C> = {
+    $ne?: T;
+    $in?: T[];
+    $nin?: T[];
+    $like?: string;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $and?: Condition<C>[];
+    $or?: Condition<C>[];
+};
+export type Condition<T> = {
+    [P in keyof T]?: T[P] | ConditionOperators<T[P], T>;
+};
+export type InstanceOf<T> = {
+    [key in keyof T]: T[key];
+};
+export type ClassType<T = any> = {
+    [k: string]: T;
+};
+export interface EnumOptions<T> extends PropertyOptions {
+    items?: (number | string)[] | (() => ClassType);
+    array?: boolean;
+}
+export type JoinStatement<T> = {
+    type: "INNER" | "LEFT" | "RIGHT";
+    originalEntity?: Function;
+    originTable: string;
+    originSchema: string;
+    originAlias: string;
+    joinTable: string;
+    joinSchema: string;
+    joinAlias: string;
+    joinEntity?: Function;
+    joinWhere?: string;
+    joinProperty: string;
+    on: string;
+    propertyKey: string | symbol;
+    hooks?: {
+        type: string;
+        propertyName: string;
+    }[];
+};
+export type Statement<T> = {
+    statement?: "select" | "insert" | "update" | "delete" | "count";
+    table?: string;
+    alias?: string;
+    customSchema?: string;
+    columns?: string[];
+    join?: JoinStatement<T>[];
+    selectJoin?: Statement<T>[];
+    strategy?: "select" | "joined";
+    where?: string;
+    values?: any;
+    groupBy?: string[];
+    orderBy?: string[];
+    limit?: number;
+    offset?: number;
+    hooks?: {
+        type: string;
+        propertyName: string;
+    }[];
+    instance?: InstanceOf<T>;
+    cache?: boolean | number | Date;
+    joinProperty?: string;
+    fkKey?: string;
+    primaryKey?: string;
+    originAlias?: string;
+    originProperty?: string;
+    joinEntity?: Function;
+    originEntity?: Function;
+};
+export type SnapshotTable = {
+    tableName: string;
+    schema?: string;
+    columns: ColumnsInfo[];
+    indexes: SnapshotIndexInfo[];
+    uniques?: SnapshotUniqueInfo[];
+    foreignKeys?: ForeignKeyInfo[];
+};
+export type SnapshotIndexInfo = {
+    table: string;
+    indexName: string;
+    columnName: string;
+    where?: string;
+};
+export type SnapshotUniqueInfo = {
+    table: string;
+    uniqueName: string;
+    columnName: string;
+};
+export type IndexStatement = {
+    name: string;
+    properties?: string[];
+    where?: string;
+};
+export type UniqueStatement = {
+    name: string;
+    properties?: string[];
+};
+export type ForeignKeyInfo = {
+    referencedTableName: string;
+    referencedColumnName: string;
+};
+export type ColumnsInfo = {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    default?: string | null;
+    primary?: boolean;
+    unique?: boolean;
+    autoIncrement?: boolean;
+    length?: number;
+    isEnum?: boolean;
+    precision?: number;
+    scale?: number;
+    isDecimal?: boolean;
+    enumItems?: string[] | number[] | "__AUTO_DETECT__";
+    foreignKeys?: ForeignKeyInfo[];
+};
+export type SqlActionType = "CREATE" | "DELETE" | "ALTER" | "INDEX";
+export type ColDiff = {
+    actionType: SqlActionType;
+    colName: string;
+    colType?: string;
+    colLength?: number;
+    indexTables?: {
+        name: string;
+        properties?: string[];
+    }[];
+    colChanges?: {
+        default?: string | null;
+        primary?: boolean;
+        unique?: boolean;
+        nullable?: boolean;
+        autoIncrement?: boolean;
+        enumItems?: string[] | number[];
+        enumModified?: boolean;
+        precision?: number;
+        scale?: number;
+        foreignKeys?: ForeignKeyInfo[];
+    };
+};
+export type TableDiff = {
+    tableName: string;
+    schema?: string;
+    newTable?: boolean;
+    colDiffs: ColDiff[];
+};
+export declare const PrimaryKeyType: unique symbol;
+export declare const PrimaryKeyProp: unique symbol;
+type ReadonlyPrimary<T> = T extends any[] ? Readonly<T> : T;
+export type Primary<T> = T extends {
+    [PrimaryKeyType]?: infer PK;
+} ? ReadonlyPrimary<PK> : T extends {
+    _id?: infer PK;
+} ? ReadonlyPrimary<PK> | string : T extends {
+    uuid?: infer PK;
+} ? ReadonlyPrimary<PK> : T extends {
+    id?: infer PK;
+} ? ReadonlyPrimary<PK> : never;
+export type PrimaryProperty<T> = T extends {
+    [PrimaryKeyProp]?: infer PK;
+} ? PK : T extends {
+    _id?: any;
+} ? "_id" | string : T extends {
+    uuid?: any;
+} ? "uuid" : T extends {
+    id?: any;
+} ? "id" : never;
+export type IPrimaryKeyValue = number | string | bigint | Date | {
+    toHexString(): string;
+};
+export type IPrimaryKey<T extends IPrimaryKeyValue = IPrimaryKeyValue> = T;
+export type OperatorMap<T> = {
+    $and?: Query<T>[];
+    $or?: Query<T>[];
+    $eq?: ExpandScalar<T> | ExpandScalar<T>[];
+    $ne?: ExpandScalar<T>;
+    $in?: ExpandScalar<T>[];
+    $nin?: ExpandScalar<T>[];
+    $not?: Query<T>;
+    $gt?: ExpandScalar<T>;
+    $gte?: ExpandScalar<T>;
+    $lt?: ExpandScalar<T>;
+    $lte?: ExpandScalar<T>;
+    $like?: string;
+    $exists?: FilterQuery<ExpandProperty<T>>;
+    $nexists?: FilterQuery<ExpandProperty<T>>;
+};
+export type ExcludeFunctions<T, K extends keyof T> = T[K] extends Function ? never : K extends symbol ? never : K;
+export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp | Uint8Array | {
+    toHexString(): string;
+};
+export type ExpandProperty<T> = T extends Reference<infer U> ? NonNullable<U> : T extends Collection<infer U, any> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
+export type ExpandScalar<T> = null | (T extends string ? T | RegExp : T extends Date ? Date | string : T);
+type ExpandObject<T> = T extends object ? T extends Scalar ? never : {
+    -readonly [K in keyof T as ExcludeFunctions<T, K>]?: Query<ExpandProperty<T[K]>> | FilterValue<ExpandProperty<T[K]>> | null;
+} : never;
+export type EntityProps<T> = {
+    -readonly [K in keyof T as ExcludeFunctions<T, K>]?: T[K];
+};
+export type Query<T> = T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>;
+export type FilterValue2<T> = T | ExpandScalar<T> | Primary<T>;
+export type FilterValue<T> = OperatorMap<FilterValue2<T>> | FilterValue2<T> | FilterValue2<T>[] | null;
+export type EntityClass<T> = Function & {
+    prototype: T;
+};
+export type EntityName<T> = string | EntityClass<T> | {
+    name: string;
+};
+export type ObjectQuery<T> = ExpandObject<T> & OperatorMap<T>;
+export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
+export type Relationship<T> = {
+    isRelation?: boolean;
+    relation: "one-to-many" | "many-to-one";
+    type: Function;
+    fkKey?: (string & keyof T) | ((e: T) => any);
+    entity: () => EntityName<T>;
+    originalEntity?: EntityName<T>;
+    propertyKey: string | symbol;
+    columnName: string;
+} & Partial<PropertyOptions>;
+export type Cast<T, R> = T extends R ? T : R;
+export type IsUnknown<T> = T extends unknown ? unknown extends T ? true : never : never;
+type Loadable<T extends object> = Collection<T, any> | Reference<T> | readonly T[];
+type ExtractType<T> = T extends Loadable<infer U> ? U : T;
+type StringKeys<T, E extends string = never> = T extends Collection<any, any> ? `${Exclude<keyof ExtractType<T> | E, symbol>}` : T extends Reference<any> ? `${Exclude<keyof ExtractType<T> | E, symbol>}` : T extends object ? `${Exclude<keyof ExtractType<T> | E, symbol>}` : never;
+type Defined<T> = Exclude<T, null | undefined>;
+type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : K extends E ? keyof T : never;
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+export type AutoPath<O, P extends string, E extends string = never, D extends Prev[number] = 5> = [D] extends [never] ? string : P extends any ? (P & `${string}.` extends never ? P : P & `${string}.`) extends infer Q ? Q extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<Defined<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : Q extends StringKeys<O, E> ? (Defined<GetStringKey<O, Q, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<Defined<GetStringKey<O, Q, E>>, E> extends never ? never : `${Q}.`) : keyof ExtractType<O> : never : never;
+export declare enum QueryOrder {
+    ASC = "ASC",
+    ASC_NULLS_LAST = "ASC NULLS LAST",
+    ASC_NULLS_FIRST = "ASC NULLS FIRST",
+    DESC = "DESC",
+    DESC_NULLS_LAST = "DESC NULLS LAST",
+    DESC_NULLS_FIRST = "DESC NULLS FIRST",
+    asc = "asc",
+    asc_nulls_last = "asc nulls last",
+    asc_nulls_first = "asc nulls first",
+    desc = "desc",
+    desc_nulls_last = "desc nulls last",
+    desc_nulls_first = "desc nulls first"
+}
+export declare enum QueryOrderNumeric {
+    ASC = 1,
+    DESC = -1
+}
+export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | keyof typeof QueryOrder;
+export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
+export type QueryOrderMap<T> = {
+    [K in keyof T as ExcludeFunctions<T, K>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
+};
+export type EntityField<T, P extends string = never> = AutoPath<T, P, "*">;
+export interface FindOptions<T, P extends string = never> {
+    load?: readonly AutoPath<T, P>[];
+    orderBy?: (QueryOrderMap<T> & {
+        0?: never;
+    }) | QueryOrderMap<T>[];
+    cache?: boolean | number | Date;
+    limit?: number;
+    offset?: number;
+    fields?: readonly EntityField<T, P>[];
+    schema?: string;
+    loadStrategy?: "select" | "joined";
+}
+export type FindOneOption<T, P extends string = never> = Omit<FindOptions<T, P>, "limit" | "offset">;
+export {};

package/dist/driver/driver.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/entry.d.ts

@@ -0,0 +1,2 @@
+import { Carno } from '@carno.js/core';
+export declare const CarnoOrm: Carno;

package/dist/entry.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarnoOrm = void 0;
+const core_1 = require("@carno.js/core");
+const orm_1 = require("./orm");
+const orm_service_1 = require("./orm.service");
+const entities_1 = require("./domain/entities");
+const identity_map_middleware_1 = require("./middleware/identity-map.middleware");
+exports.CarnoOrm = new core_1.Carno({
+    exports: [orm_1.Orm, orm_service_1.OrmService, entities_1.EntityStorage, identity_map_middleware_1.IdentityMapMiddleware],
+    providers: [identity_map_middleware_1.IdentityMapMiddleware],
+    globalMiddlewares: [identity_map_middleware_1.IdentityMapMiddleware],
+});

package/dist/identity-map/entity-key-generator.d.ts

@@ -0,0 +1,10 @@
+export declare class EntityKeyGenerator {
+    private entityStorage;
+    constructor();
+    generate(entityClass: Function, pk: any): string;
+    generateForEntity(entity: any): string;
+    extractPrimaryKey(entity: any): any;
+    private getPrimaryKeyName;
+    private serializePrimaryKey;
+    private getClassName;
+}

package/dist/identity-map/entity-key-generator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityKeyGenerator = void 0;
+const entities_1 = require("../domain/entities");
+class EntityKeyGenerator {
+    constructor() {
+        this.entityStorage = entities_1.EntityStorage.getInstance();
+    }
+    generate(entityClass, pk) {
+        const className = this.getClassName(entityClass);
+        const keyValue = this.serializePrimaryKey(pk);
+        return `${className}:${keyValue}`;
+    }
+    generateForEntity(entity) {
+        const pk = this.extractPrimaryKey(entity);
+        return this.generate(entity.constructor, pk);
+    }
+    extractPrimaryKey(entity) {
+        const pkName = this.getPrimaryKeyName(entity.constructor);
+        return entity[pkName];
+    }
+    getPrimaryKeyName(entityClass) {
+        const options = this.entityStorage.get(entityClass);
+        if (!options) {
+            return 'id';
+        }
+        for (const prop in options.properties) {
+            const property = options.properties[prop];
+            if (property.options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+    serializePrimaryKey(pk) {
+        if (Array.isArray(pk)) {
+            return pk.join(':');
+        }
+        return String(pk);
+    }
+    getClassName(entityClass) {
+        return entityClass.name;
+    }
+}
+exports.EntityKeyGenerator = EntityKeyGenerator;

package/dist/identity-map/entity-registry.d.ts

@@ -0,0 +1,11 @@
+export declare class EntityRegistry {
+    private store;
+    private finalizationRegistry;
+    constructor();
+    private setupFinalizationRegistry;
+    get<T>(key: string): T | undefined;
+    set<T extends object>(key: string, entity: T): void;
+    has(key: string): boolean;
+    remove(key: string): void;
+    clear(): void;
+}

package/dist/identity-map/entity-registry.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityRegistry = void 0;
+class EntityRegistry {
+    constructor() {
+        this.store = new Map();
+        this.setupFinalizationRegistry();
+    }
+    setupFinalizationRegistry() {
+        this.finalizationRegistry = new FinalizationRegistry((key) => {
+            this.store.delete(key);
+        });
+    }
+    get(key) {
+        const weakRef = this.store.get(key);
+        if (!weakRef) {
+            return undefined;
+        }
+        const entity = weakRef.deref();
+        if (!entity) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entity;
+    }
+    set(key, entity) {
+        const weakRef = new WeakRef(entity);
+        this.store.set(key, weakRef);
+        this.finalizationRegistry.register(entity, key, entity);
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    remove(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}
+exports.EntityRegistry = EntityRegistry;

package/dist/identity-map/identity-map-context.d.ts

@@ -0,0 +1,9 @@
+import { IdentityMap } from './identity-map';
+export declare class IdentityMapContext {
+    private storage;
+    constructor();
+    run<T>(callback: () => Promise<T>): Promise<T>;
+    getIdentityMap(): IdentityMap | undefined;
+    hasContext(): boolean;
+}
+export declare const identityMapContext: IdentityMapContext;

package/dist/identity-map/identity-map-context.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identityMapContext = exports.IdentityMapContext = void 0;
+const async_hooks_1 = require("async_hooks");
+const identity_map_1 = require("./identity-map");
+class IdentityMapContext {
+    constructor() {
+        this.storage = new async_hooks_1.AsyncLocalStorage();
+    }
+    run(callback) {
+        const identityMap = new identity_map_1.IdentityMap();
+        return this.storage.run(identityMap, callback);
+    }
+    getIdentityMap() {
+        return this.storage.getStore();
+    }
+    hasContext() {
+        return this.storage.getStore() !== undefined;
+    }
+}
+exports.IdentityMapContext = IdentityMapContext;
+exports.identityMapContext = new IdentityMapContext();

package/dist/identity-map/identity-map-integration.d.ts

@@ -0,0 +1,5 @@
+export declare class IdentityMapIntegration {
+    static getOrCreateInstance<T>(model: new () => T, primaryKey: any, factory: () => T): T;
+    static registerEntity<T extends object>(entity: T): void;
+    static getEntity<T>(entityClass: new () => T, primaryKey: any): T | undefined;
+}

package/dist/identity-map/identity-map-integration.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityMapIntegration = void 0;
+const identity_map_context_1 = require("./identity-map-context");
+class IdentityMapIntegration {
+    static getOrCreateInstance(model, primaryKey, factory) {
+        const identityMap = identity_map_context_1.identityMapContext.getIdentityMap();
+        if (!identityMap) {
+            return factory();
+        }
+        if (primaryKey === undefined || primaryKey === null) {
+            return factory();
+        }
+        const cached = identityMap.get(model, primaryKey);
+        if (cached) {
+            return cached;
+        }
+        const instance = factory();
+        identityMap.setByKey(model, primaryKey, instance);
+        return instance;
+    }
+    static registerEntity(entity) {
+        const identityMap = identity_map_context_1.identityMapContext.getIdentityMap();
+        if (!identityMap) {
+            return;
+        }
+        identityMap.set(entity);
+    }
+    static getEntity(entityClass, primaryKey) {
+        const identityMap = identity_map_context_1.identityMapContext.getIdentityMap();
+        if (!identityMap) {
+            return undefined;
+        }
+        return identityMap.get(entityClass, primaryKey);
+    }
+}
+exports.IdentityMapIntegration = IdentityMapIntegration;

package/dist/identity-map/identity-map.d.ts

@@ -0,0 +1,11 @@
+export declare class IdentityMap {
+    private registry;
+    private keyGenerator;
+    constructor();
+    get<T>(entityClass: Function, pk: any): T | undefined;
+    set<T extends object>(entity: T): void;
+    setByKey<T extends object>(entityClass: Function, pk: any, entity: T): void;
+    has(entityClass: Function, pk: any): boolean;
+    remove(entityClass: Function, pk: any): void;
+    clear(): void;
+}

package/dist/identity-map/identity-map.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityMap = void 0;
+const entity_key_generator_1 = require("./entity-key-generator");
+const entity_registry_1 = require("./entity-registry");
+class IdentityMap {
+    constructor() {
+        this.registry = new entity_registry_1.EntityRegistry();
+        this.keyGenerator = new entity_key_generator_1.EntityKeyGenerator();
+    }
+    get(entityClass, pk) {
+        const key = this.keyGenerator.generate(entityClass, pk);
+        return this.registry.get(key);
+    }
+    set(entity) {
+        const key = this.keyGenerator.generateForEntity(entity);
+        this.registry.set(key, entity);
+    }
+    setByKey(entityClass, pk, entity) {
+        const key = this.keyGenerator.generate(entityClass, pk);
+        this.registry.set(key, entity);
+    }
+    has(entityClass, pk) {
+        const key = this.keyGenerator.generate(entityClass, pk);
+        return this.registry.has(key);
+    }
+    remove(entityClass, pk) {
+        const key = this.keyGenerator.generate(entityClass, pk);
+        this.registry.remove(key);
+    }
+    clear() {
+        this.registry.clear();
+    }
+}
+exports.IdentityMap = IdentityMap;

package/dist/identity-map/index.d.ts

@@ -0,0 +1,5 @@
+export { IdentityMap } from './identity-map';
+export { EntityKeyGenerator } from './entity-key-generator';
+export { EntityRegistry } from './entity-registry';
+export { IdentityMapContext, identityMapContext } from './identity-map-context';
+export { IdentityMapIntegration } from './identity-map-integration';

package/dist/identity-map/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityMapIntegration = exports.identityMapContext = exports.IdentityMapContext = exports.EntityRegistry = exports.EntityKeyGenerator = exports.IdentityMap = void 0;
+var identity_map_1 = require("./identity-map");
+Object.defineProperty(exports, "IdentityMap", { enumerable: true, get: function () { return identity_map_1.IdentityMap; } });
+var entity_key_generator_1 = require("./entity-key-generator");
+Object.defineProperty(exports, "EntityKeyGenerator", { enumerable: true, get: function () { return entity_key_generator_1.EntityKeyGenerator; } });
+var entity_registry_1 = require("./entity-registry");
+Object.defineProperty(exports, "EntityRegistry", { enumerable: true, get: function () { return entity_registry_1.EntityRegistry; } });
+var identity_map_context_1 = require("./identity-map-context");
+Object.defineProperty(exports, "IdentityMapContext", { enumerable: true, get: function () { return identity_map_context_1.IdentityMapContext; } });
+Object.defineProperty(exports, "identityMapContext", { enumerable: true, get: function () { return identity_map_context_1.identityMapContext; } });
+var identity_map_integration_1 = require("./identity-map-integration");
+Object.defineProperty(exports, "IdentityMapIntegration", { enumerable: true, get: function () { return identity_map_integration_1.IdentityMapIntegration; } });

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export * from './decorators/entity.decorator';
+export * from './decorators/property.decorator';
+export * from './decorators/primary-key.decorator';
+export * from './decorators/one-many.decorator';
+export * from './decorators/index.decorator';
+export * from './decorators/unique.decorator';
+export * from './decorators/event-hook.decorator';
+export * from './decorators/enum.decorator';
+export * from './decorators/computed.decorator';
+export * from './orm';
+export * from './orm.service';
+export * from './domain/base-entity';
+export * from './domain/reference';
+export type { Ref } from './domain/reference';
+export { EntityStorage } from './domain/entities';
+export * from './driver/bun-pg.driver';
+export * from './driver/bun-mysql.driver';
+export * from './driver/bun-driver.base';
+export * from './utils';
+export * from './driver/driver.interface';
+export * from './entry';
+export * from './common/value-object';
+export * from './common/email.vo';
+export * from './common/uuid';
+export * from './repository/Repository';
+export { transactionContext } from './transaction/transaction-context';
+export { IdentityMapMiddleware } from './middleware/identity-map.middleware';
+export { identityMapContext } from './identity-map';