@tstdl/base 0.92.85 → 0.92.87

package/orm/query.js

@@ -2,6 +2,5 @@ export const allLogicalQueryTypes = ['$and', '$or', '$nor'];
 export const allComparisonQueryTypes = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$text', '$geoDistance', '$geoShape'];
 export const allSpecialQueryTypes = ['$textSpan'];
 export const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];
-export const allOrders = ['asc', 'desc'];
 export const allOperators = ['and', 'or'];
 export const allTextSpanQueryModes = ['best', 'most', 'cross'];

package/orm/repository.types.d.ts

@@ -0,0 +1,32 @@
+import type { Paths, Record, TypedOmit } from '../types.js';
+import type { UntaggedDeep } from '../types/tagged.js';
+import type { SQL, SQLWrapper } from 'drizzle-orm';
+import type { PartialDeep } from 'type-fest';
+import type { Entity, EntityMetadata, EntityWithoutMetadata } from './entity.js';
+type WithSql<T> = {
+    [P in keyof T]: T[P] extends Record ? WithSql<T[P]> : (T[P] | SQL);
+};
+export type OrderDirection = 'asc' | 'desc';
+export type OrderTarget<T extends EntityWithoutMetadata> = Paths<UntaggedDeep<T>> | SQLWrapper;
+export type Order<T extends EntityWithoutMetadata> = OrderTarget<T> | (OrderTarget<T> | [OrderTarget<T>, OrderDirection])[] | Partial<Record<Exclude<OrderTarget<T>, SQLWrapper>, OrderDirection>>;
+export type OrderOptions<T extends EntityWithoutMetadata> = {
+    order?: Order<T>;
+};
+export type LoadOptions<T extends EntityWithoutMetadata> = OrderOptions<T> & {
+    offset?: number;
+};
+export type LoadManyOptions<T extends EntityWithoutMetadata> = LoadOptions<T> & {
+    limit?: number;
+};
+export type UpdateOptions<T extends EntityWithoutMetadata> = LoadOptions<T>;
+export type EntityMetadataUpdate = WithSql<Partial<UntaggedDeep<Pick<EntityMetadata, 'attributes'>>>>;
+export type NewEntity<T extends Entity | EntityWithoutMetadata> = T extends Entity ? WithSql<UntaggedDeep<TypedOmit<T, 'id' | 'metadata'> & {
+    id?: string;
+    metadata?: Partial<Pick<EntityMetadata, 'attributes'>>;
+}>> : WithSql<UntaggedDeep<TypedOmit<T, 'id'> & {
+    id?: string;
+}>>;
+export type EntityUpdate<T extends EntityWithoutMetadata> = T extends Entity ? WithSql<PartialDeep<UntaggedDeep<TypedOmit<T, 'metadata'>>>> & {
+    metadata?: EntityMetadataUpdate;
+} : WithSql<PartialDeep<UntaggedDeep<T>>>;
+export {};

package/orm/repository.types.js

@@ -0,0 +1 @@
+export {};

package/orm/server/database-schema.d.ts

@@ -2,10 +2,10 @@ import type { PgEnum } from 'drizzle-orm/pg-core';
 import type { Enumeration, EnumerationValue, UnionToTuple } from '../../types.js';
 import type { EntityType } from '../entity.js';
 import type { PgTableFromType } from './types.js';
-export declare class DatabaseSchema<Name extends string> {
-    readonly name: Name;
-    constructor(name: Name);
-    getTable<T extends EntityType>(type: T): PgTableFromType<Name, T>;
+export declare class DatabaseSchema<SchemaName extends string> {
+    readonly name: SchemaName;
+    constructor(name: SchemaName);
+    getTable<T extends EntityType>(type: T): PgTableFromType<T, SchemaName>;
     getEnum<T extends Enumeration>(enumeration: T, name?: string): PgEnum<UnionToTuple<`${EnumerationValue<T>}`> extends [string, ...string[]] ? UnionToTuple<`${EnumerationValue<T>}`> : never>;
 }
 export declare function databaseSchema<Name extends string>(name: Name): DatabaseSchema<Name>;

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

@@ -8,7 +8,7 @@ type ConverterContext = {
 };
 export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
 export declare function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
-export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, schemaName?: S): PgTableFromType<S, T>;
+export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, schemaName?: S): PgTableFromType<T, S>;
 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/server/drizzle/schema-converter.js

@@ -12,12 +12,12 @@ 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 { assertDefined, assertDefinedPass, isArray, isDefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { bytea, numericDate, timestamp } from '../../data-types/index.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';
-import { bytea, numericDate, timestamp } from '../data-types/index.js';
 import { decryptBytes, encryptBytes } from '../encryption.js';
 const getDbSchema = memoizeSingle(pgSchema);
 export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
@@ -28,11 +28,18 @@ export function getColumnDefinitions(table) {
 export function _getDrizzleTableFromType(type, schemaName) {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-    const tableReflectionData = metadata.data.tryGet('orm');
+    const tableReflectionDatas = [];
+    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
+        const tableReflectionData = currentMetadata.data.tryGet('orm');
+        if (isDefined(tableReflectionData)) {
+            tableReflectionDatas.push(tableReflectionData);
+        }
+    }
+    const tableReflectionData = tableReflectionDatas[0];
     const schema = assertDefinedPass(schemaName ?? tableReflectionData?.schema, 'Table schema not provided');
     const tableName = tableReflectionData?.name ?? getDefaultTableName(type);
     const dbSchema = getDbSchema(schema);
-    const columnDefinitions = getPostgresColumnEntries(type, tableName, dbSchema);
+    const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
     function getColumn(table, propertyName) {
         return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
     }
@@ -52,14 +59,21 @@ export function _getDrizzleTableFromType(type, schemaName) {
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        return indexFn(data.name).using(data.options?.using ?? 'btree', ...columns);
+        return indexFn(data.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
     }
-    const primaryKeyColumns = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
-    const skipPrimaryKey = primaryKeyColumns.length > 1;
+    function buildPrimaryKey(table) {
+        const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
+        return primaryKey({
+            name: tableReflectionData?.compundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: tableReflectionData?.compundPrimaryKeyNaming }),
+            columns
+        });
+    }
+    const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
+    const skipPrimaryKey = primaryKeyColumnDefinitions.length > 1;
     const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.buildType({ skipPrimaryKey })]);
     const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (table) => [
-        ...((primaryKeyColumns.length > 1)
-            ? [primaryKey({ columns: primaryKeyColumns.map((columnDefinition) => getColumn(table, columnDefinition.name)) })]
+        ...((primaryKeyColumnDefinitions.length > 1)
+            ? [buildPrimaryKey(table)]
             : []),
         ...(columnDefinitions.map((columnDefinition) => {
             const indexData = columnDefinition.reflectionData?.index;
@@ -68,21 +82,21 @@ export function _getDrizzleTableFromType(type, schemaName) {
             }
             return buildIndex(table, indexData, columnDefinition.name);
         }).filter(isDefined)),
-        ...(tableReflectionData?.unique?.map((data) => {
+        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
             const columns = data.columns?.map((column) => getColumn(table, column));
-            let constraint = unique(isDefined(data.name) ? toSnakeCase(data.name) : undefined).on(...columns);
+            let constraint = unique(data.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
             if (data.options?.nulls == 'not distinct') {
                 constraint = constraint.nullsNotDistinct();
             }
             return constraint;
-        }) ?? []),
-        ...(tableReflectionData?.index?.map((data) => buildIndex(table, data)) ?? []),
-        ...(tableReflectionData?.checks?.map((data) => check(data.name, data.builder(table))) ?? [])
+        }),
+        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(table, data)),
+        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table)))
     ]);
     drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
     return drizzleSchema;
 }
-function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath({ dollar: false }), prefix = '') {
+function getPostgresColumnEntries(type, dbSchema, tableName, 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);
@@ -94,7 +108,7 @@ function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath
             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);
+            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, dbSchema, tableName, path.add(property), nestedPrefix);
         }
         const objectPath = path.add(property);
         const encrypted = columnReflectionData?.encrypted == true;
@@ -115,7 +129,7 @@ function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath
                 name: toCamelCase(prefixedColumnName),
                 objectPath,
                 reflectionData: columnReflectionData,
-                buildType: (options) => getPostgresColumn(toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
+                buildType: (options) => getPostgresColumn(tableName, toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
                 dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
                 toDatabase,
                 fromDatabase
@@ -123,7 +137,7 @@ function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath
     });
     return entries;
 }
-function getPostgresColumn(columnName, dbSchema, propertySchema, reflectionData, options, context) {
+function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData, options, context) {
     let nullable = false;
     let array = false;
     let baseSchema = propertySchema;
@@ -148,7 +162,7 @@ function getPostgresColumn(columnName, dbSchema, propertySchema, reflectionData,
         column = column.notNull();
     }
     if (isDefined(reflectionData.unique)) {
-        column = column.unique(reflectionData.unique.name, isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
+        column = column.unique(reflectionData.unique.name ?? getUniqueName(tableName, [columnName], { naming: reflectionData.unique.options?.naming }), isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
     }
     if ((reflectionData.primaryKey == true) && (options.skipPrimaryKey != true)) {
         column = column.primaryKey();
@@ -227,3 +241,18 @@ export function getPgEnum(schema, enumeration, context) {
 function getDefaultTableName(type) {
     return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
 }
+function getPrimaryKeyName(tableName, columns, options) {
+    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_pk`;
+}
+function getIndexName(tableName, columns, options) {
+    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_idx`;
+}
+function getUniqueName(tableName, columns, options) {
+    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_unique`;
+}
+function getTablePrefix(tableName, naming) {
+    return (naming == 'abbreviated-table') ? tableName.split('_').map((part) => part[0]).join('') : tableName;
+}
+function getColumnNames(columns) {
+    return columns.map((column) => isString(column) ? column : column.name);
+}

package/orm/server/index.d.ts

@@ -3,4 +3,5 @@ export * from './database.js';
 export * from './module.js';
 export * from './query-converter.js';
 export * from './repository.js';
+export * from './sqls.js';
 export * from './transaction.js';

package/orm/server/index.js

@@ -3,4 +3,5 @@ export * from './database.js';
 export * from './module.js';
 export * from './query-converter.js';
 export * from './repository.js';
+export * from './sqls.js';
 export * from './transaction.js';

package/orm/server/query-converter.d.ts

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

package/orm/server/query-converter.js

@@ -14,8 +14,8 @@ export function convertQuery(query, table, columnDefinitionsMap) {
     if (queryEntries.length == 0) {
         return sqlTrue;
     }
+    const conditions = [];
     for (const [property, value] of queryEntries) {
-        const isPrimitiveValue = isPrimitive(value);
         if (property == '$and') {
             if (queryEntries.length > 1) {
                 throw new Error('only one logical operator per level allowed');
@@ -48,66 +48,71 @@ export function convertQuery(query, table, columnDefinitionsMap) {
         }
         const columnDef = assertDefinedPass(columnDefinitionsMap.get(property), `Could not map property ${property} to column.`);
         const column = table[columnDef.name];
-        if (isPrimitiveValue || hasOwnProperty(value, '$eq')) {
-            const queryValue = isPrimitiveValue ? value : value.$eq;
-            if (queryValue === null) {
-                return isNull(column);
-            }
-            return eq(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$neq')) {
-            const queryValue = value.$neq;
-            if (queryValue === null) {
-                return isNotNull(column);
-            }
-            return ne(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$exists')) {
-            throw new NotSupportedError('$exists is not supported.');
-        }
-        if (hasOwnProperty(value, '$in')) {
-            const queryValue = value.$in;
-            return inArray(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$nin')) {
-            const queryValue = value.$nin;
-            return notInArray(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$lt')) {
-            const queryValue = value.$lt;
-            return lt(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$lte')) {
-            const queryValue = value.$lte;
-            return lte(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$gt')) {
-            const queryValue = value.$gt;
-            return gt(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$gte')) {
-            const queryValue = value.$gte;
-            return gte(column, queryValue);
-        }
-        if (hasOwnProperty(value, '$regex')) {
-            const queryValue = value.$regex;
-            const regexp = isString(queryValue)
-                ? ({ value: queryValue })
-                : isRegExp(queryValue)
-                    ? ({ flags: queryValue.flags, value: queryValue.source })
-                    : ({ flags: queryValue.flags, value: queryValue.pattern });
-            return sql `regexp_like(${column}, ${regexp.value}, ${regexp.flags})`;
-        }
-        if (hasOwnProperty(value, '$text')) {
-            throw new NotSupportedError('$text is not supported.');
-        }
-        if (hasOwnProperty(value, '$geoShape')) {
-            throw new NotSupportedError('$geoShape is not supported.');
-        }
-        if (hasOwnProperty(value, '$geoDistance')) {
-            throw new NotSupportedError('$geoDistance is not supported.');
+        const condition = getCondition(property, value, column);
+        conditions.push(condition);
+    }
+    return and(...conditions);
+}
+function getCondition(property, value, column) {
+    const isPrimitiveValue = isPrimitive(value);
+    if (isPrimitiveValue || hasOwnProperty(value, '$eq')) {
+        const queryValue = isPrimitiveValue ? value : value.$eq;
+        if (queryValue === null) {
+            return isNull(column);
+        }
+        return eq(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$neq')) {
+        const queryValue = value.$neq;
+        if (queryValue === null) {
+            return isNotNull(column);
         }
-        throw new Error(`Unsupported query type "${property}".`);
+        return ne(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$exists')) {
+        throw new NotSupportedError('$exists is not supported.');
+    }
+    if (hasOwnProperty(value, '$in')) {
+        const queryValue = value.$in;
+        return inArray(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$nin')) {
+        const queryValue = value.$nin;
+        return notInArray(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$lt')) {
+        const queryValue = value.$lt;
+        return lt(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$lte')) {
+        const queryValue = value.$lte;
+        return lte(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$gt')) {
+        const queryValue = value.$gt;
+        return gt(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$gte')) {
+        const queryValue = value.$gte;
+        return gte(column, queryValue);
+    }
+    if (hasOwnProperty(value, '$regex')) {
+        const queryValue = value.$regex;
+        const regexp = isString(queryValue)
+            ? ({ value: queryValue })
+            : isRegExp(queryValue)
+                ? ({ flags: queryValue.flags, value: queryValue.source })
+                : ({ flags: queryValue.flags, value: queryValue.pattern });
+        return sql `regexp_like(${column}, ${regexp.value}, ${regexp.flags})`;
+    }
+    if (hasOwnProperty(value, '$text')) {
+        throw new NotSupportedError('$text is not supported.');
+    }
+    if (hasOwnProperty(value, '$geoShape')) {
+        throw new NotSupportedError('$geoShape is not supported.');
+    }
+    if (hasOwnProperty(value, '$geoDistance')) {
+        throw new NotSupportedError('$geoDistance is not supported.');
     }
-    throw new Error('Unsupported query.');
+    throw new Error(`Unsupported query type "${property}".`);
 }

package/orm/server/repository.d.ts

@@ -1,44 +1,31 @@
-import { type SQL } from 'drizzle-orm';
+import { SQL } from 'drizzle-orm';
 import { PgTransaction as DrizzlePgTransaction, type PgColumn, type PgInsertValue, type PgQueryResultHKT, type PgUpdateSetSource } from 'drizzle-orm/pg-core';
-import type { PartialDeep } from 'type-fest';
 import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { DeepPartial, OneOrMany, Paths, Record, Type, TypedOmit } from '../../types.js';
+import type { DeepPartial, OneOrMany, Paths, Record, Type } from '../../types.js';
 import type { UntaggedDeep } from '../../types/index.js';
-import type { Entity, EntityMetadata, EntityMetadataAttributes, EntityType, NewEntity } from '../entity.js';
+import { Entity, type EntityMetadataAttributes, type EntityType, type EntityWithoutMetadata } from '../entity.js';
 import type { Query } from '../query.js';
+import type { EntityMetadataUpdate, EntityUpdate, LoadManyOptions, LoadOptions, NewEntity, Order } from '../repository.types.js';
 import { Database } from './database.js';
 import { type Transaction, type TransactionConfig } from './transaction.js';
 import type { ColumnDefinition, PgTableFromType, TransformContext } from './types.js';
 type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export declare const repositoryType: unique symbol;
-export type OrderOptions<T extends Entity> = {
-    order?: Partial<Record<Paths<UntaggedDeep<T>>, 1 | -1 | 'asc' | 'desc'>>;
-};
-export type LoadOptions<T extends Entity> = OrderOptions<T> & {
-    offset?: number;
-    withDeleted?: boolean;
-};
-export type LoadManyOptions<T extends Entity> = LoadOptions<T> & {
-    limit?: number;
-};
-export type UpdateOptions<T extends Entity> = LoadOptions<T>;
-export type EntityMetadataUpdate = Partial<UntaggedDeep<Pick<EntityMetadata, 'attributes'>>>;
-export type EntityUpdate<T extends Entity> = PartialDeep<UntaggedDeep<TypedOmit<T, 'metadata'> & {
-    metadata: EntityMetadataUpdate;
-}>>;
 export declare class EntityRepositoryConfig {
     schema: string;
 }
-export type TransactionHandler<T extends Entity, R> = (repository: EntityRepository<T>, transaction: Transaction) => Promise<R>;
-export declare class EntityRepository<T extends Entity = Entity> implements Resolvable<EntityType<T>> {
+export type TransactionHandler<T extends EntityWithoutMetadata, R> = (repository: EntityRepository<T>, transaction: Transaction) => Promise<R>;
+export declare class EntityRepository<T extends Entity | EntityWithoutMetadata = EntityWithoutMetadata> implements Resolvable<EntityType<T>> {
     #private;
     readonly type: EntityType<T>;
-    readonly table: PgTableFromType<string, EntityType>;
-    readonly columnDefinitions: ColumnDefinition[];
-    readonly columnDefinitionsMap: Map<string, ColumnDefinition>;
+    readonly typeName: string;
     readonly session: Database | PgTransaction;
     readonly isInTransaction: boolean;
+    readonly hasMetadata: boolean;
+    get table(): PgTableFromType<EntityType<T>>;
     readonly [resolveArgumentType]: EntityType<T>;
+    readonly _anyInferSelect: PgTableFromType<EntityType<Entity>>['$inferSelect'];
+    readonly _inferSelect: PgTableFromType<EntityType<T>>['$inferSelect'];
     constructor();
     withOptionalTransaction(transaction: Transaction | undefined): EntityRepository<T>;
     withTransaction(transaction: Transaction): EntityRepository<T>;
@@ -69,7 +56,7 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
     insert(entity: NewEntity<T>): Promise<T>;
     insertMany(entities: NewEntity<T>[]): Promise<T[]>;
     upsert(target: OneOrMany<Paths<UntaggedDeep<T>>>, entity: NewEntity<T>, update?: EntityUpdate<T>): Promise<T>;
-    upsertMany(target: OneOrMany<Paths<UntaggedDeep<T>>>, entities: NewEntity<T>[], update: EntityUpdate<T>): Promise<T[]>;
+    upsertMany(target: OneOrMany<Paths<UntaggedDeep<T>>>, entities: NewEntity<T>[], update?: EntityUpdate<T>): Promise<T[]>;
     update(id: string, update: EntityUpdate<T>): Promise<T>;
     tryUpdate(id: string, update: EntityUpdate<T>): Promise<T | undefined>;
     updateByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<T>;
@@ -82,21 +69,23 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
     tryDeleteByQuery(query: Query<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T | undefined>;
     deleteMany(ids: string[], metadataUpdate?: EntityMetadataUpdate): Promise<T[]>;
     deleteManyByQuery(query: Query<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T[]>;
-    hardDelete(id: string): Promise<void>;
-    tryHardDelete(id: string): Promise<boolean>;
-    hardDeleteByQuery(query: Query<T>): Promise<void>;
-    tryHardDeleteByQuery(query: Query<T>): Promise<boolean>;
-    hardDeleteMany(ids: string[]): Promise<number>;
-    hardDeleteManyByQuery(query: Query<T>): Promise<number>;
-    protected convertQuery(query: Query<T>): SQL;
-    protected mapManyToEntity(columns: this['table']['$inferSelect'][], transformContext: TransformContext): Promise<T[]>;
-    protected mapToEntity(columns: this['table']['$inferSelect'], transformContext: TransformContext): Promise<T>;
-    protected mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>[]>;
-    protected mapToColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>>;
-    protected mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>[]>;
-    protected mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>>;
-    protected mapUpdate(update: EntityUpdate<T>, transformContext: TransformContext): Promise<PgUpdateSetSource<PgTableFromType<string, EntityType>>>;
-    protected getIdLimitQuery(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
+    hardDelete(id: string): Promise<T>;
+    tryHardDelete(id: string): Promise<T | undefined>;
+    hardDeleteByQuery(query: Query<T>): Promise<T>;
+    tryHardDeleteByQuery(query: Query<T>): Promise<T | undefined>;
+    hardDeleteMany(ids: string[]): Promise<T[]>;
+    hardDeleteManyByQuery(query: Query<T>): Promise<T[]>;
+    $getColumn(pathOrColumn: Paths<UntaggedDeep<T>> | ColumnDefinition): PgColumn;
+    $convertOrderBy(orderBy: Order<T>): SQL<unknown>[];
+    $convertQuery(query: Query<T>): SQL;
+    $mapManyToEntity(columns: this['_inferSelect'][]): Promise<T[]>;
+    $mapToEntity(columns: this['_inferSelect']): Promise<T>;
+    $mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[]): Promise<PgInsertValue<PgTableFromType>[]>;
+    $mapToColumns(obj: DeepPartial<T> | NewEntity<T>): Promise<PgInsertValue<PgTableFromType>>;
+    $mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[]): Promise<PgInsertValue<PgTableFromType>[]>;
+    $mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>): Promise<PgInsertValue<PgTableFromType>>;
+    $mapUpdate(update: EntityUpdate<T>): Promise<PgUpdateSetSource<PgTableFromType>>;
+    $getIdLimitQuery(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
         id: PgColumn<{
             name: string;
             tableName: string;
@@ -135,9 +124,57 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
             generated: undefined;
         }, {}, {}>;
     }>, "where" | "limit">;
-    protected getAttributesUpdate(attributes: EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
+    $getAttributesUpdate(attributes: SQL | EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
+    protected mapManyToEntity(columns: this['_anyInferSelect'][], transformContext: TransformContext): Promise<T[]>;
+    protected mapToEntity(columns: this['_anyInferSelect'], transformContext: TransformContext): Promise<T>;
+    protected mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>[]>;
+    protected mapToColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
+    protected mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>[]>;
+    protected mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
+    protected mapUpdate(update: EntityUpdate<T>, transformContext: TransformContext): Promise<PgUpdateSetSource<PgTableFromType>>;
+    protected getMetadataUpdate(update?: EntityUpdate<T>): PgUpdateSetSource<PgTableFromType<EntityType<Entity>>> | undefined;
+    protected getIdLimitSelect(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
+        id: PgColumn<{
+            name: string;
+            tableName: string;
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }, "partial", globalThis.Record<string, "not-null">, false, "where" | "limit", {
+        id: string;
+    }[], {
+        id: PgColumn<{
+            name: string;
+            tableName: string;
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    }>, "where" | "limit">;
+    protected getAttributesUpdate(attributes: SQL | EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
     protected getTransformContext(): Promise<TransformContext>;
 }
-export declare function injectRepository<T extends Entity>(type: EntityType<T>): EntityRepository<T>;
-export declare function getRepository<T extends Entity>(type: EntityType<T>): Type<EntityRepository<T>>;
+export declare function injectRepository<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>): EntityRepository<T>;
+export declare function getRepository<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>): Type<EntityRepository<T>>;
 export {};