@tstdl/base 0.91.49 → 0.91.51

package/orm/query-converter.js

@@ -0,0 +1,114 @@
+import { and, eq, gt, gte, inArray, isNotNull, isNull, isSQLWrapper, lt, lte, ne, not, notInArray, or, SQL, sql } from 'drizzle-orm';
+import { NotSupportedError } from '../errors/not-supported.error.js';
+import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
+import { assertDefinedPass, isPrimitive, isRegExp, isString, isUndefined } from '../utils/type-guards.js';
+const sqlTrue = sql `true`;
+export function convertQuery(query, table, columnDefinitionsMap) {
+    if (query instanceof SQL) {
+        return query;
+    }
+    if (isSQLWrapper(query)) {
+        return sql `${query}`;
+    }
+    const queryEntries = objectEntries(query);
+    if (queryEntries.length == 0) {
+        return sqlTrue;
+    }
+    // eslint-disable-next-line no-unreachable-loop
+    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');
+            }
+            const andQuery = and(...query.$and.map((item) => convertQuery(item, table, columnDefinitionsMap)));
+            if (isUndefined(andQuery)) {
+                return sqlTrue;
+            }
+            return andQuery;
+        }
+        if (property == '$or') {
+            if (queryEntries.length > 1) {
+                throw new Error('only one logical operator per level allowed');
+            }
+            const orQuery = or(...query.$or.map((item) => convertQuery(item, table, columnDefinitionsMap)));
+            if (isUndefined(orQuery)) {
+                return sqlTrue;
+            }
+            return orQuery;
+        }
+        if (property == '$nor') {
+            if (queryEntries.length > 1) {
+                throw new Error('only one logical operator per level allowed');
+            }
+            const orQuery = or(...query.$nor.map((item) => convertQuery(item, table, columnDefinitionsMap)));
+            if (isUndefined(orQuery)) {
+                return sqlTrue;
+            }
+            return not(orQuery);
+        }
+        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.');
+        }
+        throw new Error(`Unsupported query type "${property}".`);
+    }
+    throw new Error('Unsupported query.');
+}

package/orm/query.d.ts

@@ -1,4 +1,5 @@
-import type { Flatten, Record } from '../types.js';
+import type { SQLWrapper } from 'drizzle-orm';
+import type { Flatten, Record, Untagged } from '../types.js';
 import type { Geometry } from '../types/geo-json.js';
 export type LogicalQuery<T = any> = LogicalAndQuery<T> | LogicalOrQuery<T> | LogicalNorQuery<T>;
 export type LogicalQueryTypes = keyof (LogicalAndQuery & LogicalOrQuery & LogicalNorQuery);
@@ -6,14 +7,15 @@ export declare const allLogicalQueryTypes: LogicalQueryTypes[];
 export type ComparisonQueryBody<T = any> = {
     [P in keyof T]?: ComparisonQueryOrValue<T[P]>;
 } & Record<ComparisonQueryOrValue>;
-export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | T | Flatten<T>;
+export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | ComparisonValue<T>;
 export type ComparisonQuery<T = any> = Partial<ComparisonNotQuery<T> & ComparisonEqualsQuery<T> & ComparisonNotEqualsQuery<T> & ComparisonExistsQuery & ComparisonItemQuery<T> & ComparisonInQuery<T> & ComparisonNotInQuery<T> & ComparisonAllQuery<T> & ComparisonGreaterThanQuery<T> & ComparisonGreaterThanOrEqualsQuery<T> & ComparisonLessThanQuery<T> & ComparisonLessThanOrEqualsQuery<T> & ComparisonRegexQuery & ComparisonTextQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
 export type ComparisonQueryTypes = keyof ComparisonQuery;
 export declare const allComparisonQueryTypes: ComparisonQueryTypes[];
 export type SpecialQuery<T = any> = Partial<TextSpanQuery<T>>;
 export type SpecialQueryTypes = keyof SpecialQuery;
 export declare const allSpecialQueryTypes: SpecialQueryTypes[];
-export type Query<T = any> = LogicalQuery<T> | (ComparisonQueryBody<T> & SpecialQuery<T>);
+export type Query<T = any> = SQLWrapper | QueryObject<T>;
+export type QueryObject<T> = LogicalQuery<T> | (ComparisonQueryBody<T> & SpecialQuery<T>);
 export type QueryTypes = LogicalQueryTypes | ComparisonQueryTypes | SpecialQueryTypes;
 export declare const allQueryTypes: ("$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$text" | "$geoShape" | "$geoDistance" | "$textSpan")[];
 export type Order = 'asc' | 'desc';
@@ -21,16 +23,16 @@ export declare const allOrders: Order[];
 export type Operator = 'and' | 'or';
 export declare const allOperators: Operator[];
 export type LogicalAndQuery<T = any> = {
-    $and: Query<T>[];
+    $and: readonly Query<T>[];
 };
 export type LogicalOrQuery<T = any> = {
-    $or: Query<T>[];
+    $or: readonly Query<T>[];
 };
 export type LogicalNorQuery<T = any> = {
-    $nor: Query<T>[];
+    $nor: readonly Query<T>[];
 };
-export type ComparisonValue<T> = T | Flatten<T>;
-export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends string[] ? ComparisonValue<(Flatten<T> | RegExp)[]> : (T | Flatten<T>);
+export type ComparisonValue<T> = Untagged<T | Flatten<T>>;
+export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends readonly string[] ? ComparisonValue<readonly (Flatten<T> | RegExp)[]> : (T | Flatten<T>);
 export type ComparisonNotQuery<T = any> = {
     $not: ComparisonQuery<T>;
 };
@@ -44,16 +46,16 @@ export type ComparisonExistsQuery = {
     $exists: ComparisonValue<boolean>;
 };
 export type ComparisonItemQuery<T = any> = {
-    $item: T extends (infer U)[] ? U extends Record<any, any> ? Query<U> : ComparisonQuery<U> : never;
+    $item: T extends readonly (infer U)[] ? U extends Record ? Query<U> : ComparisonQuery<U> : never;
 };
 export type ComparisonInQuery<T = any> = {
-    $in: ComparisonValueWithRegex<T>[];
+    $in: readonly ComparisonValueWithRegex<T>[];
 };
 export type ComparisonNotInQuery<T = any> = {
-    $nin: ComparisonValueWithRegex<T>[];
+    $nin: readonly ComparisonValueWithRegex<T>[];
 };
 export type ComparisonAllQuery<T = any> = {
-    $all: ComparisonValueWithRegex<T>[];
+    $all: readonly ComparisonValueWithRegex<T>[];
 };
 export type ComparisonGreaterThanQuery<T = any> = {
     $gt: ComparisonValue<T>;
@@ -104,7 +106,7 @@ export type TextSpanQueryMode = 'best' | 'most' | 'cross';
 export declare const allTextSpanQueryModes: TextSpanQueryMode[];
 export type TextSpanQuery<T = any> = {
     $textSpan: {
-        fields: (Extract<keyof T, string>)[];
+        fields: readonly (Extract<keyof T, string>)[];
         text: string;
         mode?: TextSpanQueryMode;
         operator?: Operator;

package/orm/repository.d.ts

@@ -1,53 +1,112 @@
-import type { Paths, TypedOmit } from '../types.js';
 import { SQL } from 'drizzle-orm';
-import type { Entity, EntityMetadata, EntityType, NewEntity } from './entity.js';
+import { PgTransaction as DrizzlePgTransaction, PgColumn, PgInsertValue, PgQueryResultHKT, PgUpdateSetSource } from 'drizzle-orm/pg-core';
+import { PartialDeep } from 'type-fest';
+import { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import type { DeepPartial, OneOrMany, Paths, Record, Type, TypedOmit, UntaggedDeep } from '../types.js';
+import { Database } from './database.js';
+import { ColumnDefinition, type PgTableFromType } from './drizzle/schema-converter.js';
+import type { Entity, EntityMetadata, EntityMetadataAttributes, EntityType, NewEntity } from './entity.js';
 import type { Query } from './query.js';
+import { Transaction, TransactionConfig } from './transaction.js';
+type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export declare const repositoryType: unique symbol;
 export type OrderOptions<T extends Entity> = {
-    order?: {
-        [P in Paths<T>]?: 1 | -1 | 'asc' | 'desc';
-    };
+    order?: Partial<Record<Paths<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 EntityMetadataUpdate = {
-    metadata?: Partial<EntityMetadata>;
-};
-export type EntityUpdate<T extends Entity> = Partial<TypedOmit<T, 'metadata'>> & EntityMetadataUpdate;
-export declare const entityType: import("../injector/token.js").InjectionToken<EntityType<any>, never>;
-export declare abstract class EntityRepository<T extends Entity = Entity> {
+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>> {
+    #private;
     readonly type: EntityType<T>;
-    readonly schema: import("./drizzle/schema-converter.js").PgTableFromType<"", EntityType<Entity>, string>;
-    readonly database: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>> & {
-        $client: import("drizzle-orm/node-postgres").NodePgClient;
-    };
+    readonly table: PgTableFromType<string, EntityType>;
+    readonly columnDefinitions: ColumnDefinition[];
+    readonly columnDefinitionsMap: Map<string, ColumnDefinition>;
+    readonly session: Database | PgTransaction;
+    readonly isInTransaction: boolean;
+    get tx(): PgTransaction;
+    readonly [resolveArgumentType]: EntityType<T>;
+    constructor(type?: EntityType<T>, table?: PgTableFromType<string, EntityType>, columnDefinitions?: ColumnDefinition[], columnDefinitionsMap?: Map<string, ColumnDefinition>, session?: Database | PgTransaction);
+    withOptionalTransaction(transaction: Transaction | undefined): EntityRepository<T>;
+    withTransaction(transaction: Transaction): EntityRepository<T>;
+    startTransaction(config?: TransactionConfig): Promise<Transaction>;
+    useTransaction<R>(transaction: Transaction | undefined, handler: TransactionHandler<T, R>): Promise<R>;
+    transaction<R>(handler: TransactionHandler<T, R>, config?: TransactionConfig): Promise<R>;
     load(id: string): Promise<T>;
     tryLoad(id: string): Promise<T | undefined>;
-    loadByQuery(query: Query<T> | SQL | undefined, options?: LoadOptions<T>): Promise<T>;
-    tryLoadByQuery(query: Query<T> | SQL | undefined, options?: LoadOptions<T>): Promise<T | undefined>;
+    loadByQuery(query: Query<T>, options?: LoadOptions<T>): Promise<T>;
+    tryLoadByQuery(query: Query<T>, options?: LoadOptions<T>): Promise<T | undefined>;
     loadMany(ids: string[], options?: LoadManyOptions<T>): Promise<T[]>;
     loadManyCursor(ids: string[], options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
-    loadManyByQuery(query: Query<T> | SQL | undefined, options?: LoadManyOptions<T>): Promise<T[]>;
-    loadManyByQueryCursor(query: Query<T> | SQL | undefined, options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    loadManyByQuery(query: Query<T>, options?: LoadManyOptions<T>): Promise<T[]>;
+    loadManyByQueryCursor(query: Query<T>, options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
     loadAll(options?: LoadManyOptions<T>): Promise<T[]>;
     loadAllCursor(options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
     count(): Promise<number>;
-    countByQuery(query: Query<T> | SQL): Promise<number>;
+    countByQuery(query: Query<T>): Promise<number>;
     has(id: string): Promise<boolean>;
-    hasByQuery(query: Query<T> | SQL): Promise<boolean>;
+    hasByQuery(query: Query<T>): Promise<boolean>;
     hasAll(ids: string[]): Promise<boolean>;
-    insert(_entity: NewEntity<T>): Promise<T>;
-    abstract insertMany(entities: NewEntity<T>[]): Promise<T[]>;
-    abstract update(id: string, update: EntityUpdate<T>): Promise<void>;
-    abstract updateByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<void>;
-    abstract updateMany(ids: string[], update: EntityUpdate<T>): Promise<void>;
-    abstract updateManyByQuery(filter: Query<T>, update: EntityUpdate<T>): Promise<void>;
-    abstract delete(id: string): Promise<boolean>;
-    abstract deleteMany(ids: string[]): Promise<number>;
-    abstract deleteByQuery(query: Query<T>): Promise<boolean>;
-    abstract deleteManyByQuery(query: Query<T>): Promise<number>;
+    insert(entity: NewEntity<T>): Promise<T>;
+    insertMany(entities: NewEntity<T>[]): Promise<T[]>;
+    upsert(target: OneOrMany<Extract<keyof T, string>>, entity: NewEntity<T>, update?: EntityUpdate<T>): Promise<T>;
+    upsertMany(target: OneOrMany<Extract<keyof T, string>>, 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>;
+    tryUpdateByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<T | undefined>;
+    updateMany(ids: string[], update: EntityUpdate<T>): Promise<T[]>;
+    updateManyByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<T[]>;
+    delete(id: string, metadataUpdate?: EntityMetadataUpdate): Promise<T>;
+    tryDelete(id: string, metadataUpdate?: EntityMetadataUpdate): Promise<T | undefined>;
+    deleteByQuery(query: Query<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T>;
+    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<boolean>;
+    hardDeleteMany(ids: string[]): Promise<number>;
+    hardDeleteManyByQuery(query: Query<T>): Promise<number>;
+    protected convertQuery(query: Query<T>): SQL;
+    protected mapToEntity(columns: this['table']['$inferSelect']): T;
+    protected mapToColumns(obj: DeepPartial<T> | NewEntity<T>): PgInsertValue<PgTableFromType<string, EntityType>>;
+    protected mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>): PgInsertValue<PgTableFromType<string, EntityType>>;
+    protected mapUpdate(update: EntityUpdate<T>): PgUpdateSetSource<PgTableFromType<string, EntityType>>;
+    protected getIdLimitQuery(query: Query<T>): import("drizzle-orm/pg-core").WithSubqueryWithSelection<{
+        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;
+        }, {}, {}>;
+    }, "id">;
+    protected getAttributesUpdate(attributes: EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
 }
+export declare function injectRepository<T extends Entity>(type: EntityType<T>): EntityRepository<T>;
+export declare function getRepository<T extends Entity>(type: EntityType<T>, config: EntityRepositoryConfig): Type<EntityRepository<T>>;
+export {};