@tstdl/base 0.91.50 → 0.91.52

package/orm/database.d.ts

@@ -0,0 +1,6 @@
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
+import { DatabaseArgument } from './module.js';
+export declare class Database extends NodePgDatabase<any> implements Resolvable<DatabaseArgument> {
+    readonly [resolveArgumentType]?: DatabaseArgument;
+}

package/orm/database.js

@@ -0,0 +1,14 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { ReplaceClass } from '../injector/decorators.js';
+let Database = class Database extends NodePgDatabase {
+};
+Database = __decorate([
+    ReplaceClass(NodePgDatabase)
+], Database);
+export { Database };

package/orm/decorators.d.ts

@@ -1,27 +1,50 @@
+import type { PgIndexMethod } from 'drizzle-orm/pg-core';
+import type { AbstractConstructor, TypedOmit } from '../types.js';
+import type { EntityType } from './entity.js';
 export type OrmTableReflectionData = {
     name?: string;
     unique?: UniqueReflectionData[];
+    index?: IndexReflectionData[];
 };
 export type OrmColumnReflectionData = {
     name?: string;
     primaryKey?: boolean;
     unique?: UniqueReflectionData;
+    index?: IndexReflectionData;
     uuid?: {
         defaultRandom?: boolean;
     };
+    embedded?: {
+        type: AbstractConstructor;
+        prefix?: string | null;
+    };
+    references?: () => EntityType;
 };
-type UniqueReflectionData = {
+export type UniqueReflectionData = {
     name?: string;
     columns?: string[];
     options?: {
         nulls?: 'distinct' | 'not distinct';
     };
 };
+export type IndexReflectionData = {
+    name?: string;
+    columns?: (string | [string, 'asc' | 'desc'])[];
+    order?: 'asc' | 'desc';
+    options?: {
+        using?: PgIndexMethod;
+        unique?: boolean;
+        nulls?: 'first' | 'last';
+    };
+};
 export declare function createTableDecorator(data?: OrmTableReflectionData): ClassDecorator;
 export declare function createColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator;
 export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): ClassDecorator & PropertyDecorator;
 export declare function Column(options: OrmColumnReflectionData): PropertyDecorator;
 export declare function PrimaryKey(): PropertyDecorator;
+export declare function References(type: () => EntityType): PropertyDecorator;
+export declare function Embedded(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
 export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
 export declare function Unique(name: string | undefined, columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;
-export {};
+export declare function Index(name?: string, options?: IndexReflectionData['options']): PropertyDecorator;
+export declare function Index(name: string | undefined, columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;

package/orm/decorators.js

@@ -1,4 +1,5 @@
 import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/utils.js';
+import { Property } from '../schema/index.js';
 import { isArray } from '../utils/type-guards.js';
 export function createTableDecorator(data) {
     return createClassDecorator({ data: { orm: data }, mergeData: true });
@@ -15,9 +16,23 @@ export function Column(options) {
 export function PrimaryKey() {
     return createColumnDecorator({ primaryKey: true });
 }
+export function References(type) {
+    return createColumnDecorator({ references: type });
+}
+export function Embedded(type, options) {
+    return createPropertyDecorator({
+        include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })]
+    });
+}
 export function Unique(name, columnsOrOptions, options) {
     if (isArray(columnsOrOptions)) {
         return createTableDecorator({ unique: [{ name, columns: columnsOrOptions, options }] });
     }
     return createColumnDecorator({ unique: { name, options: columnsOrOptions ?? options } });
 }
+export function Index(name, columnsOrOptions, options) {
+    if (isArray(columnsOrOptions)) {
+        return createTableDecorator({ index: [{ name, columns: columnsOrOptions, options }] });
+    }
+    return createColumnDecorator({ index: { name, options: columnsOrOptions ?? options } });
+}

package/orm/drizzle/index.d.ts

@@ -0,0 +1 @@
+export * from './schema-converter.js';

package/orm/drizzle/index.js

@@ -0,0 +1 @@
+export * from './schema-converter.js';

package/orm/drizzle/schema-converter.d.ts

@@ -1,19 +1,48 @@
 import type { BuildColumns, NotNull } from 'drizzle-orm';
-import { type PgTableWithColumns } from 'drizzle-orm/pg-core';
-import type { SnakeCase } from 'type-fest';
-import type { Enumeration, Type } from '../../types.js';
+import { type PgColumnBuilder, type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
+import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
+import { JsonPath } from '../../json-path/json-path.js';
+import { type Record } from '../../schema/index.js';
+import type { AbstractConstructor, Enumeration } from '../../types.js';
+import type { OrmColumnReflectionData } from '../decorators.js';
 import type { EntityType } from '../entity.js';
-import type { ColumnBuilder } from '../types.js';
+import type { ColumnBuilder, embedded } from '../types.js';
 type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
+type ConverterContext = {
+    type: AbstractConstructor;
+    property: string;
+};
+export type ColumnDefinition = {
+    name: string;
+    objectPath: JsonPath;
+    type: PgColumnBuilder<any, any, any, any>;
+    reflectionData: OrmColumnReflectionData | undefined;
+    dereferenceObjectPath: (obj: Record) => any;
+};
 export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
-export type PgTableFromType<S extends string, T extends Type, TableName extends string = T extends EntityType ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
+export type ColumnPrefix<T> = T extends {
+    prefix: infer Prefix;
+} ? Prefix extends string ? Prefix : '' : '';
+export type PgTableFromType<S extends string, T extends AbstractConstructor, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
     name: TableName;
     schema: S;
     columns: BuildColumns<TableName, {
-        [P in keyof InstanceType<T>]: Column<Extract<P, string>, InstanceType<T>[P]>;
-    }, 'pg'>;
+        [P in Exclude<keyof InstanceType<T>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
+    } & {
+        [P in keyof EmbeddedProperties<InstanceType<T>>]: EmbeddedColumns<InstanceType<T>[P], ColumnPrefix<InstanceType<T>[P]>>;
+    }[keyof EmbeddedProperties<InstanceType<T>>], 'pg'>;
     dialect: 'pg';
 }>;
-export declare function _getDrizzleTableFromType<S extends string, T extends Type>(schemaName: S, type: T, tableName?: string): PgTableFromType<S, T>;
+export type EmbeddedProperties<T> = ConditionalPick<T, {
+    [embedded]: {
+        prefix: any;
+    };
+}>;
+export type EmbeddedColumns<T, Prefix extends string> = {
+    [P in keyof T as CamelCase<`${Prefix}${Extract<P, string>}`>]: Column<CamelCase<`${Prefix}${Extract<P, string>}`>, T[P]>;
+};
+export declare function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
+export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, schemaName: S, tableName?: string): PgTableFromType<S, T>;
 export declare function registerEnum(enumeration: Enumeration, name: string): void;
+export declare function getPgEnum(schema: string | PgSchema, enumeration: Enumeration, context?: ConverterContext): PgEnum<[string, ...string[]]>;
 export {};

package/orm/drizzle/schema-converter.js

@@ -1,50 +1,103 @@
-import { toSnakeCase } from 'drizzle-orm/casing';
-import { boolean, doublePrecision, integer, pgSchema, text, unique, uuid } from 'drizzle-orm/pg-core';
+import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
+import { boolean, date, doublePrecision, index, integer, jsonb, pgSchema, text, timestamp, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
 import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { JsonPath } from '../../json-path/json-path.js';
 import { reflectionRegistry } from '../../reflection/registry.js';
-import { ArraySchema, BooleanSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, OptionalSchema, StringSchema } from '../../schema/index.js';
+import { ArraySchema, BooleanSchema, DefaultSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema } from '../../schema/index.js';
+import { compareByValueSelectionToOrder, orderRest } from '../../utils/comparison.js';
 import { enumValues } from '../../utils/enum.js';
 import { memoize, memoizeSingle } from '../../utils/function/memoize.js';
+import { compileDereferencer } from '../../utils/object/dereference.js';
 import { fromEntries, objectEntries } from '../../utils/object/object.js';
-import { assertDefinedPass, assertStringPass, isArray, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { assertDefined, assertDefinedPass, isArray, isDefined, isNull, isString, isUndefined } from '../../utils/type-guards.js';
+import { JsonSchema } from '../schemas/json.js';
+import { NumericDateSchema } from '../schemas/numeric-date.js';
+import { TimestampSchema } from '../schemas/timestamp.js';
 import { UuidSchema } from '../schemas/uuid.js';
 const getDbSchema = memoizeSingle(pgSchema);
 export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
-export function _getDrizzleTableFromType(schemaName, type, tableName = getDefaultTableName(type)) {
+const columnDefinitionsSymbol = Symbol('columnDefinitions');
+export function getColumnDefinitions(table) {
+    return table[columnDefinitionsSymbol];
+}
+export function _getDrizzleTableFromType(type, schemaName, tableName = getDefaultTableName(type)) {
     const metadata = reflectionRegistry.getMetadata(type);
-    if (isUndefined(metadata)) {
-        throw new Error('Type does not have reflection metadata.');
-    }
+    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
     const dbSchema = getDbSchema(schemaName);
     const tableReflectionData = metadata.data.tryGet('orm');
-    const objectSchema = getObjectSchema(type);
-    const entries = objectEntries(objectSchema.properties).map(([property, schema]) => {
-        const columnReflectionData = metadata.properties.get(property)?.data.tryGet('orm');
-        const propertyName = columnReflectionData?.name ?? assertStringPass(toSnakeCase(property));
-        return [
-            property,
-            getPostgresColumn(tableName, propertyName, dbSchema, schema, columnReflectionData ?? {})
-        ];
-    });
+    const columnDefinitions = getPostgresColumnEntries(type, tableName, dbSchema);
     function getColumn(table, propertyName) {
         return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
     }
-    const drizzleSchema = dbSchema.table(tableName, fromEntries(entries), (table) => {
-        const uniqueEntries = tableReflectionData?.unique?.map((data, index) => {
+    function buildIndex(table, data, columnName) {
+        const columns = (data.columns ?? [columnName]).map((columnValue) => {
+            assertDefined(columnValue, 'Missing column name for index.');
+            const [columnName, columnOrder] = isString(columnValue) ? [columnValue] : columnValue;
+            const order = columnOrder ?? data.order ?? 'asc';
+            let column = getColumn(table, columnName);
+            column = column[order]();
+            if (data.options?.nulls == 'first') {
+                column = column.nullsFirst();
+            }
+            else if (data.options?.nulls == 'last') {
+                column = column.nullsLast();
+            }
+            return column;
+        });
+        const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
+        return indexFn().using(data.options?.using ?? 'btree', ...columns);
+    }
+    const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.type]);
+    const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (table) => [
+        ...(columnDefinitions.map((columnDefinition) => {
+            const indexData = columnDefinition.reflectionData?.index;
+            if (isUndefined(indexData)) {
+                return undefined;
+            }
+            return buildIndex(table, indexData, columnDefinition.name);
+        }).filter(isDefined)),
+        ...(tableReflectionData?.unique?.map((data) => {
             const columns = data.columns?.map((column) => getColumn(table, column));
             let constraint = unique(isDefined(data.name) ? toSnakeCase(data.name) : undefined).on(...columns);
             if (data.options?.nulls == 'not distinct') {
                 constraint = constraint.nullsNotDistinct();
             }
-            return [`unique_${index}`, constraint];
-        });
-        return {
-            ...isDefined(uniqueEntries) ? fromEntries(uniqueEntries) : undefined
-        };
-    });
+            return constraint;
+        }) ?? []),
+        ...(tableReflectionData?.index?.map((data) => buildIndex(table, data)) ?? [])
+    ]);
+    drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
     return drizzleSchema; // eslint-disable-line @typescript-eslint/no-unsafe-return
 }
-function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData) {
+function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath({ dollar: false }), prefix = '') {
+    const metadata = reflectionRegistry.getMetadata(type);
+    assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
+    const objectSchema = getObjectSchema(type);
+    const entries = objectEntries(objectSchema.properties).toSorted(compareByValueSelectionToOrder(['id', orderRest, 'metadata'], (item) => item[0])).flatMap(([property, schema]) => {
+        const columnReflectionData = metadata.properties.get(property)?.data.tryGet('orm');
+        const columnName = columnReflectionData?.name ?? toSnakeCase(property);
+        if ((schema instanceof ObjectSchema) && !(schema instanceof JsonSchema)) {
+            const propertyMetadata = reflectionRegistry.getMetadata(type)?.properties.get(property);
+            assertDefined(propertyMetadata, `Property "${property}" of type "${type.name}" does not have reflection metadata (path: ${path.toString()}).`);
+            const propertyPrefix = columnReflectionData?.embedded?.prefix;
+            const nestedPrefix = [prefix, isNull(propertyPrefix) ? '' : propertyPrefix ?? `${columnName}_`].join('');
+            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, tableName, dbSchema, path.add(property), nestedPrefix);
+        }
+        const objectPath = path.add(property);
+        return [
+            {
+                name: toCamelCase([prefix, columnName].join('')),
+                objectPath,
+                type: getPostgresColumn(columnName, dbSchema, schema, columnReflectionData ?? {}, { type, property }),
+                reflectionData: columnReflectionData,
+                dereferenceObjectPath: compileDereferencer(objectPath, { optional: true })
+            }
+        ];
+    });
+    return entries;
+}
+function getPostgresColumn(columnName, dbSchema, propertySchema, reflectionData, context) {
     let nullable = false;
     let array = false;
     let baseSchema = propertySchema;
@@ -61,7 +114,7 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
             break;
         }
     }
-    let column = getPostgresBaseColumn(tableName, columnName, dbSchema, baseSchema);
+    let column = getPostgresBaseColumn(columnName, dbSchema, baseSchema, context);
     if (array) {
         column = column.array();
     }
@@ -74,13 +127,15 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
     if (reflectionData.primaryKey == true) {
         column = column.primaryKey();
     }
+    if (isDefined(reflectionData.references)) {
+        column = column.references(() => getDrizzleTableFromType(reflectionData.references(), dbSchema.schemaName).id);
+    }
     return column;
 }
-function getPostgresBaseColumn(tableName, columnName, dbSchema, schema) {
-    if (schema instanceof NumberSchema) {
-        return schema.integer
-            ? integer(columnName)
-            : doublePrecision(columnName);
+function getPostgresBaseColumn(columnName, dbSchema, schema, context) {
+    if (schema instanceof DefaultSchema) {
+        const column = getPostgresBaseColumn(columnName, dbSchema, schema.schema, context);
+        return column.default(schema.defaultValue);
     }
     if (schema instanceof UuidSchema) {
         let column = uuid(columnName);
@@ -89,6 +144,17 @@ function getPostgresBaseColumn(tableName, columnName, dbSchema, schema) {
         }
         return column;
     }
+    if (schema instanceof TimestampSchema) {
+        return timestamp(columnName, { withTimezone: true });
+    }
+    if (schema instanceof NumericDateSchema) {
+        return date(columnName);
+    }
+    if (schema instanceof NumberSchema) {
+        return schema.integer
+            ? integer(columnName)
+            : doublePrecision(columnName);
+    }
     if (schema instanceof StringSchema) {
         return text(columnName);
     }
@@ -96,21 +162,36 @@ function getPostgresBaseColumn(tableName, columnName, dbSchema, schema) {
         return boolean(columnName);
     }
     if (schema instanceof EnumerationSchema) {
-        const pgEnum = getPgEnum(tableName, columnName, dbSchema, schema.enumeration);
+        const pgEnum = getPgEnum(dbSchema, schema.enumeration, context);
         return pgEnum(columnName);
     }
-    throw new NotSupportedError(`Schema ${schema.constructor.name} not supported`);
+    if (schema instanceof JsonSchema) {
+        return jsonb(columnName);
+    }
+    throw new NotSupportedError(`Schema "${schema.constructor.name}" not supported on type "${context.type.name}" for property "${context.property}"`);
 }
-const enums = new Map();
+const enumNames = new Map();
+const enums = new MultiKeyMap();
 export function registerEnum(enumeration, name) {
-    enums.set(enumeration, name);
+    enumNames.set(enumeration, toSnakeCase(name));
 }
-function getPgEnum(tableName, columnName, dbSchema, enumeration) {
+export function getPgEnum(schema, enumeration, context) {
+    const dbSchema = isString(schema) ? getDbSchema(schema) : schema;
+    const enumName = enumNames.get(enumeration);
+    if (isUndefined(enumName)) {
+        if (isDefined(context)) {
+            throw new Error(`Enum is not registered. (type: ${context.type.name}, property: ${context.property})`);
+        }
+        throw new Error('Enum is not registered.');
+    }
     const values = (isArray(enumeration) ? enumeration : enumValues(enumeration))
         .map((value) => value.toString());
-    const enumName = enums.get(enumeration) ?? `${tableName}_${columnName}_enum`;
-    return dbSchema.enum(enumName, values);
+    const dbEnum = dbSchema.enum(enumName, values);
+    if (enums.has([dbSchema.schemaName, enumeration])) {
+        enums.set([dbSchema.schemaName, enumeration], dbEnum);
+    }
+    return dbEnum;
 }
 function getDefaultTableName(type) {
-    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name);
+    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
 }

package/orm/entity.d.ts

@@ -1,20 +1,23 @@
-import type { Record, Type, TypedOmit } from '../types.js';
-import { type HasDefault, type IsPrimaryKey, Uuid } from './types.js';
+import { Record } from '../schema/index.js';
+import { Type, TypedOmit, UntaggedDeep } from '../types.js';
+import { Embedded, type HasDefault, type IsPrimaryKey, Json, Timestamp, Uuid } from './types.js';
 export interface EntityType<T extends Entity = Entity> extends Type<T> {
-    readonly entityName: string;
+    readonly entityName?: string;
+}
+export type NewEntity<T extends Entity> = UntaggedDeep<TypedOmit<T, 'id' | 'metadata'> & {
+    id?: string;
+    metadata?: Partial<Pick<EntityMetadata, 'attributes'>>;
+}>;
+export declare abstract class EntityMetadataAttributes implements Record {
 }
 export declare abstract class EntityMetadata {
     revision: number;
-    revisionTimestamp: number;
-    createTimestamp: number;
-    deleteTimestamp: number | null;
-    attributes: Record;
+    revisionTimestamp: Timestamp;
+    createTimestamp: Timestamp;
+    deleteTimestamp: Timestamp | null;
+    attributes: HasDefault<Json<EntityMetadataAttributes>>;
 }
 export declare abstract class Entity {
     id: IsPrimaryKey<HasDefault<Uuid>>;
-    metadata: EntityMetadata;
+    metadata: Embedded<EntityMetadata>;
 }
-export type NewEntity<T extends Entity> = TypedOmit<T, 'id' | 'metadata'> & {
-    id?: string;
-    metadata?: Partial<Pick<EntityMetadata, 'attributes'>>;
-};

package/orm/entity.js

@@ -7,39 +7,48 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { NumberProperty, Property, any, record } from '../schema/index.js';
-import { PrimaryKey } from './decorators.js';
-import { Uuid } from './types.js';
-export class EntityMetadata {
+import { Defaulted, Integer } from '../schema/index.js';
+import { Index, PrimaryKey } from './decorators.js';
+import { Embedded, Json, Timestamp, Uuid } from './types.js';
+let EntityMetadataAttributes = class EntityMetadataAttributes {
+}; // eslint-disable-line @typescript-eslint/no-extraneous-class
+EntityMetadataAttributes = __decorate([
+    Json()
+], EntityMetadataAttributes);
+export { EntityMetadataAttributes };
+let EntityMetadata = class EntityMetadata {
     revision;
     revisionTimestamp;
     createTimestamp;
     deleteTimestamp;
     attributes;
-}
+};
 __decorate([
-    NumberProperty(),
+    Integer(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revision", void 0);
 __decorate([
-    NumberProperty(),
+    Timestamp(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revisionTimestamp", void 0);
 __decorate([
-    NumberProperty(),
+    Timestamp(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "createTimestamp", void 0);
 __decorate([
-    NumberProperty({ nullable: true }),
+    Timestamp({ nullable: true }),
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "deleteTimestamp", void 0);
 __decorate([
-    Property(record(any(), any())),
+    Defaulted(EntityMetadataAttributes, {}),
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "attributes", void 0);
+EntityMetadata = __decorate([
+    Index(undefined, ['revision', 'revisionTimestamp'])
+], EntityMetadata);
+export { EntityMetadata };
 export class Entity {
     id;
-    // @Property(EntityMetadata)
     metadata;
 }
 __decorate([
@@ -47,3 +56,7 @@ __decorate([
     Uuid({ defaultRandom: true }),
     __metadata("design:type", Object)
 ], Entity.prototype, "id", void 0);
+__decorate([
+    Embedded(EntityMetadata, { prefix: null }),
+    __metadata("design:type", Object)
+], Entity.prototype, "metadata", void 0);

package/orm/index.d.ts

@@ -1,7 +1,8 @@
 export * from './database-schema.js';
-export * from './decorators.js';
-export * from './drizzle/schema-converter.js';
+export * from './database.js';
 export * from './entity.js';
+export * from './module.js';
 export * from './query.js';
 export * from './repository.js';
+export * from './transaction.js';
 export * from './types.js';

package/orm/index.js

@@ -1,7 +1,8 @@
 export * from './database-schema.js';
-export * from './decorators.js';
-export * from './drizzle/schema-converter.js';
+export * from './database.js';
 export * from './entity.js';
+export * from './module.js';
 export * from './query.js';
 export * from './repository.js';
+export * from './transaction.js';
 export * from './types.js';

package/orm/module.d.ts

@@ -0,0 +1,6 @@
+import type { PoolConfig } from 'pg';
+export type DatabaseConfig = {
+    connection: DatabaseArgument;
+};
+export type DatabaseArgument = string | PoolConfig;
+export declare const DATABASE_CONFIG: import("../injector/index.js").InjectionToken<DatabaseConfig, never>;

package/orm/module.js

@@ -0,0 +1,15 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { inject, injectionToken } from '../injector/index.js';
+import { Injector } from '../injector/injector.js';
+import { isUndefined } from '../utils/type-guards.js';
+import { Database } from './database.js';
+export const DATABASE_CONFIG = injectionToken('EntityRepositoryConfig');
+Injector.registerSingleton(Database, {
+    useFactory: (argument) => {
+        const connection = argument ?? inject(DATABASE_CONFIG, undefined, { optional: true })?.connection;
+        if (isUndefined(connection)) {
+            throw new Error('Missing postgres connection. Provide it either via injection argument or provider.');
+        }
+        return drizzle({ connection });
+    }
+});

package/orm/query-converter.d.ts

@@ -0,0 +1,5 @@
+import { SQL } from 'drizzle-orm';
+import type { ColumnDefinition, PgTableFromType } from './drizzle/schema-converter.js';
+import type { EntityType } from './entity.js';
+import type { Query } from './query.js';
+export declare function convertQuery(query: Query, table: PgTableFromType<string, EntityType>, columnDefinitionsMap: Map<string, ColumnDefinition>): SQL;