@tstdl/base 0.92.142 → 0.92.144

package/orm/server/drizzle/schema-converter.js

@@ -1,5 +1,5 @@
 import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
-import { boolean, check, doublePrecision, index, integer, jsonb, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
 import { MultiKeyMap } from '../../../data-structures/multi-key-map.js';
 import { tryGetEnumName } from '../../../enumeration/enumeration.js';
 import { NotSupportedError } from '../../../errors/not-supported.error.js';
@@ -66,7 +66,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        let builder = indexFn(data.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
+        let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
         if (isDefined(data.options?.where)) {
             const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
             builder = builder.where(query.inlineParams());
@@ -94,9 +94,19 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             }
             return buildIndex(table, indexData, columnDefinition.name);
         }).filter(isDefined)),
+        ...tableReflectionDatas.flatMap((tableReflectionData) => {
+            return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
+                const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
+                return foreignKey({
+                    name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
+                    columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
+                    foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
+                });
+            }) ?? [];
+        }),
         ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
             const columns = data.columns?.map((column) => getColumn(table, column));
-            let constraint = unique(data.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
+            let constraint = unique(data.options?.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
             if (data.options?.nulls == 'not distinct') {
                 constraint = constraint.nullsNotDistinct();
             }
@@ -128,7 +138,7 @@ function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath
         const toDatabase = encrypted
             ? async (value, context) => {
                 const bytes = encodeUtf8(value);
-                return encryptBytes(bytes, context.encryptionKey);
+                return await encryptBytes(bytes, context.encryptionKey);
             }
             : (value) => value;
         const fromDatabase = encrypted
@@ -175,13 +185,18 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
         column = column.notNull();
     }
     if (isDefined(reflectionData.unique)) {
-        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);
+        column = column.unique(reflectionData.unique.options?.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();
     }
+    for (const { target, targetColumn } of reflectionData.references ?? []) {
+        column = column.references(() => {
+            const targetTable = getDrizzleTableFromType(target(), dbSchema.schemaName);
+            return targetTable[(targetColumn ?? 'id')];
+        });
+    }
     if (isDefined(reflectionData.references)) {
-        column = column.references(() => getDrizzleTableFromType(reflectionData.references(), dbSchema.schemaName).id);
     }
     return column;
 }
@@ -238,10 +253,11 @@ export function getPgEnum(schema, enumeration, context) {
     const dbSchema = isString(schema) ? getDbSchema(schema) : schema;
     const enumName = enumNames.get(enumeration) ?? tryGetEnumName(enumeration);
     if (isUndefined(enumName)) {
+        const errorMessage = 'Enum is not registered. Please register it using `databaseSchema.getEnum(MyEnum)` before use.';
         if (isDefined(context)) {
-            throw new Error(`Enum is not registered. (type: ${context.type.name}, property: ${context.property})`);
+            throw new Error(`${errorMessage} (type: ${context.type.name}, property: ${context.property})`);
         }
-        throw new Error('Enum is not registered.');
+        throw new Error(errorMessage);
     }
     const values = (isArray(enumeration) ? enumeration : enumValues(enumeration))
         .map((value) => value.toString());
@@ -255,13 +271,26 @@ 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`;
+    return getIdentifier(tableName, columns, 'pk', options);
 }
 function getIndexName(tableName, columns, options) {
-    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_idx`;
+    return getIdentifier(tableName, columns, 'idx', options);
 }
 function getUniqueName(tableName, columns, options) {
-    return `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_unique`;
+    return getIdentifier(tableName, columns, 'unique', options);
+}
+function getForeignKeyName(tableName, columns, options) {
+    return getIdentifier(tableName, columns, 'fkey', options);
+}
+function getIdentifier(tableName, columns, suffix, options) {
+    const identifier = `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_${suffix}`;
+    if (identifier.length > 63) {
+        if (options?.naming != 'abbreviated-table') {
+            return getIdentifier(tableName, columns, suffix, { naming: 'abbreviated-table' });
+        }
+        throw new Error(`Identifier "${identifier}" for table "${tableName}" is too long. Maximum length is 63 characters.`);
+    }
+    return identifier;
 }
 function getTablePrefix(tableName, naming) {
     return (naming == 'abbreviated-table') ? tableName.split('_').map((part) => part[0]).join('') : tableName;

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

@@ -10,11 +10,12 @@ import type { ColumnDefinition, PgTableFromType } from './types.js';
 /**
  * Converts a query object into a Drizzle SQL condition.
  * Recursively handles nested logical operators and maps property names to database columns.
+ * All top-level keys in the query object are implicitly joined with AND.
+ *
  * @param query The query object to convert. Can be a Drizzle SQL object, SQLWrapper, or a custom query object.
  * @param table The Drizzle table object.
  * @param columnDefinitionsMap A map from property names to column definitions.
  * @returns A Drizzle SQL condition representing the query.
- * @throws {Error} If multiple logical operators are used at the same level.
  * @throws {Error} If a property cannot be mapped to a column.
  * @throws {Error} If an unsupported query type is encountered.
  */

package/orm/server/query-converter.js

@@ -7,16 +7,17 @@
 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';
+import { assertDefinedPass, isDefined, isPrimitive, isRegExp, isString, isUndefined } from '../../utils/type-guards.js';
 const sqlTrue = sql `true`;
 /**
  * Converts a query object into a Drizzle SQL condition.
  * Recursively handles nested logical operators and maps property names to database columns.
+ * All top-level keys in the query object are implicitly joined with AND.
+ *
  * @param query The query object to convert. Can be a Drizzle SQL object, SQLWrapper, or a custom query object.
  * @param table The Drizzle table object.
  * @param columnDefinitionsMap A map from property names to column definitions.
  * @returns A Drizzle SQL condition representing the query.
- * @throws {Error} If multiple logical operators are used at the same level.
  * @throws {Error} If a property cannot be mapped to a column.
  * @throws {Error} If an unsupported query type is encountered.
  */
@@ -25,7 +26,7 @@ export function convertQuery(query, table, columnDefinitionsMap) {
         return query;
     }
     if (isSQLWrapper(query)) {
-        return sql `${query}`;
+        return query.getSQL();
     }
     const queryEntries = objectEntries(query);
     if (queryEntries.length == 0) {
@@ -33,42 +34,43 @@ export function convertQuery(query, table, columnDefinitionsMap) {
     }
     const conditions = [];
     for (const [property, value] of queryEntries) {
-        if (property == '$and') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
+        switch (property) {
+            case '$and': {
+                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap));
+                const andCondition = and(...subQueries);
+                if (isDefined(andCondition)) {
+                    conditions.push(andCondition);
+                }
+                break;
             }
-            const andQuery = and(...query.$and.map((item) => convertQuery(item, table, columnDefinitionsMap)));
-            if (isUndefined(andQuery)) {
-                return sqlTrue;
+            case '$or': {
+                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap));
+                const orCondition = or(...subQueries);
+                if (isDefined(orCondition)) {
+                    conditions.push(orCondition);
+                }
+                break;
             }
-            return andQuery;
-        }
-        if (property == '$or') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
+            case '$nor': {
+                const subQueries = value.map((item) => convertQuery(item, table, columnDefinitionsMap));
+                const orCondition = or(...subQueries);
+                if (isDefined(orCondition)) {
+                    const norCondition = not(orCondition);
+                    conditions.push(norCondition);
+                }
+                break;
             }
-            const orQuery = or(...query.$or.map((item) => convertQuery(item, table, columnDefinitionsMap)));
-            if (isUndefined(orQuery)) {
-                return sqlTrue;
+            default: {
+                const columnDef = assertDefinedPass(columnDefinitionsMap.get(property), `Could not map property ${property} to column.`);
+                const column = table[columnDef.name];
+                const condition = getCondition(property, value, column);
+                conditions.push(condition);
+                break;
             }
-            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];
-        const condition = getCondition(property, value, column);
-        conditions.push(condition);
     }
-    return and(...conditions);
+    // Combine all collected conditions with AND. Return `true` if no conditions were generated.
+    return and(...conditions) ?? sqlTrue;
 }
 /**
  * Generates a Drizzle SQL condition based on a property, its value, and the corresponding column.
@@ -89,6 +91,26 @@ function getCondition(property, value, column) {
         }
         return eq(column, queryValue);
     }
+    if (hasOwnProperty(value, '$and')) {
+        const innerQueries = value.$and.map((query) => getCondition(property, query, column)); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+        const andQuery = and(...innerQueries);
+        if (isUndefined(andQuery)) {
+            throw new Error(`No valid conditions in $and for property "${property}".`);
+        }
+        return andQuery;
+    }
+    if (hasOwnProperty(value, '$or')) {
+        const innerQueries = value.$or.map((query) => getCondition(property, query, column)); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+        const orQuery = or(...innerQueries);
+        if (isUndefined(orQuery)) {
+            throw new Error(`No valid conditions in $or for property "${property}".`);
+        }
+        return orQuery;
+    }
+    if (hasOwnProperty(value, '$not')) {
+        const innerQuery = getCondition(property, value.$not, column); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+        return not(innerQuery);
+    }
     if (hasOwnProperty(value, '$neq')) {
         const queryValue = value.$neq;
         if (queryValue === null) {
@@ -131,7 +153,8 @@ function getCondition(property, value, column) {
             : isRegExp(queryValue)
                 ? ({ flags: queryValue.flags, value: queryValue.source })
                 : ({ flags: queryValue.flags, value: queryValue.pattern });
-        return sql `regexp_like(${column}, ${regexp.value}, ${regexp.flags})`;
+        const operator = (regexp.flags?.includes('i') ?? false) ? sql.raw('~*') : sql.raw('~');
+        return sql `${column} ${operator} ${regexp.value}`;
     }
     if (hasOwnProperty(value, '$text')) {
         throw new NotSupportedError('$text is not supported.');

package/orm/server/repository.d.ts

@@ -1,12 +1,13 @@
 import { SQL } from 'drizzle-orm';
 import type { PgColumn, PgInsertValue, PgUpdateSetSource } from 'drizzle-orm/pg-core';
-import { type InjectOptions } from '../../injector/inject.js';
 import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { DeepPartial, OneOrMany, Paths, Type, TypedOmit } from '../../types.js';
+import type { DeepPartial, OneOrMany, Paths, Type } from '../../types.js';
 import type { UntaggedDeep } from '../../types/index.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, TargetColumnPaths } from '../repository.types.js';
+import type { Database } from './database.js';
+import type { PgTransaction } from './transaction.js';
 import { Transactional } from './transactional.js';
 import type { ColumnDefinition, PgTableFromType, TransformContext } from './types.js';
 export declare const repositoryType: unique symbol;
@@ -136,7 +137,7 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     /**
      * Checks if all entities with the given IDs exist.
      * @param ids An array of entity IDs to check.
-     * @returns A promise that resolves to `true` if all entities exist, `false` otherwise.
+     * @returns A promise that resolves to `true` if all entities exist, `false` otherwise. If `ids` is empty, returns `false`.
      */
     hasAll(ids: string[]): Promise<boolean>;
     /**
@@ -157,6 +158,20 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
      * @returns A promise that resolves to an array of the inserted entities.
      */
     insertMany(entities: NewEntity<T>[]): Promise<T[]>;
+    /**
+     * Inserts an entity if it does not already exist based on the target columns.
+     * @param target The column(s) to use for conflict detection.
+     * @param entity The entity to insert.
+     * @returns A promise that resolves to the inserted or existing entity.
+     */
+    insertIfNotExists(target: OneOrMany<Paths<UntaggedDeep<T>>>, entity: NewEntity<T>): Promise<T | undefined>;
+    /**
+     * Inserts many entities if they do not already exist based on the target columns.
+     * @param target The column(s) to use for conflict detection.
+     * @param entities The entities to insert.
+     * @returns A promise that resolves to the inserted or existing entities.
+     */
+    insertManyIfNotExists(target: OneOrMany<Paths<UntaggedDeep<T>>>, entities: NewEntity<T>[]): Promise<T[]>;
     /**
      * Inserts an entity or updates it if a conflict occurs based on the target columns.
      * @param target The column(s) to use for conflict detection.
@@ -430,45 +445,6 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     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 getTransformContext(): Promise<TransformContext>;
 }
 /**
@@ -477,7 +453,14 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
  * @param type The entity type.
  * @returns An EntityRepository instance for the specified type.
  */
-export declare function injectRepository<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>, options?: TypedOmit<InjectOptions<EntityRepository<T>, undefined>, 'optional'>): EntityRepository<T>;
+export declare function injectRepository<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>, session?: Database | PgTransaction | null): EntityRepository<T>;
+/**
+ * Injects an EntityRepository instance for the specified entity type.
+ * @template T The entity type.
+ * @param type The entity type.
+ * @returns An EntityRepository instance for the specified type.
+ */
+export declare function injectRepositoryAsync<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>, session?: Database | PgTransaction | null): Promise<EntityRepository<T>>;
 /**
  * Gets or creates a singleton EntityRepository class for the specified entity type.
  * @template T The entity type.