@tstdl/base 0.92.84 → 0.92.86

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';
+import type { 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>;
@@ -82,20 +69,69 @@ 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>>>;
+    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(path: Paths<UntaggedDeep<T>>): 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;
+            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">;
+    $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 getIdLimitQuery(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
         id: PgColumn<{
             name: string;
@@ -135,9 +171,9 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
             generated: undefined;
         }, {}, {}>;
     }>, "where" | "limit">;
-    protected getAttributesUpdate(attributes: EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
+    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 {};