@tstdl/base 0.92.85 → 0.92.86

package/document-management/server/services/document-management.service.js

@@ -4,6 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { AiService } from '../../../ai/ai.service.js';
 import { getEntityMap } from '../../../database/index.js';
 import { Enumerable } from '../../../enumerable/index.js';
 import { BadRequestError } from '../../../errors/index.js';
@@ -11,13 +12,15 @@ import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
 import { Singleton, inject, injectArgument, provide, resolveArgumentType } from '../../../injector/index.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
 import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../../orm/server/index.js';
+import { array, enumeration, integer, nullable, object, string } from '../../../schema/index.js';
 import { toArray } from '../../../utils/array/index.js';
-import { assertDefinedPass, compareByValueSelectionToOrder, currentTimestamp, digest, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, millisecondsPerMinute } from '../../../utils/index.js';
+import { assertDefinedPass, assertStringPass, compareByValueSelectionToOrder, currentTimestamp, digest, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, millisecondsPerMinute } from '../../../utils/index.js';
 import { groupToMap } from '../../../utils/iterable-helpers/index.js';
 import { readBinaryStream } from '../../../utils/stream/index.js';
 import { Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, DocumentProperty, DocumentPropertyBooleanValue, DocumentPropertyDataType, DocumentPropertyDecimalValue, DocumentPropertyIntegerValue, DocumentPropertyTextValue, DocumentRequest, DocumentRequestCollection, DocumentRequestFile, DocumentRequestTemplate, DocumentRequestsTemplate, DocumentType, DocumentTypeProperty } from '../../models/index.js';
 import { DocumentManagementConfig } from '../module.js';
 let DocumentManagementService = class DocumentManagementService {
+    #aiService = inject(AiService);
     documentService = injectRepository(Document);
     documentFileService = injectRepository(DocumentFile);
     documentCollectionService = injectRepository(DocumentCollection);
@@ -42,8 +45,8 @@ let DocumentManagementService = class DocumentManagementService {
                 this.documentCollectionService.withTransaction(transaction).loadMany(collectionIds),
                 this.documentCollectionDocumentService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
                 this.documentRequestCollectionService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
-                this.documentCategoryService.withTransaction(transaction).loadManyByQuery({}, { order: { label: 1 } }),
-                this.documentTypeService.withTransaction(transaction).loadManyByQuery({}, { order: { label: 1 } })
+                this.documentCategoryService.withTransaction(transaction).loadManyByQuery({}, { order: 'label' }),
+                this.documentTypeService.withTransaction(transaction).loadManyByQuery({}, { order: 'label' })
             ]);
             const documentIds = collectionDocuments.map((document) => document.documentId);
             const requestIds = requestCollections.map((requestCollection) => requestCollection.requestId);
@@ -88,7 +91,7 @@ let DocumentManagementService = class DocumentManagementService {
     }
     async loadDocumentRequestsTemplateData() {
         const [requestsTemplates, requestTemplates] = await Promise.all([
-            this.documentRequestsTemplateService.loadManyByQuery({}, { order: { label: 'asc' } }),
+            this.documentRequestsTemplateService.loadManyByQuery({}, { order: 'label' }),
             this.documentRequestTemplateService.loadManyByQuery({})
         ]);
         const templates = requestsTemplates.map((requestsTemplate) => ({
@@ -99,8 +102,8 @@ let DocumentManagementService = class DocumentManagementService {
     }
     async loadCategoriesAndTypes() {
         const [categories, types] = await Promise.all([
-            this.documentCategoryService.loadManyByQuery({}, { order: { label: 1 } }),
-            this.documentTypeService.loadManyByQuery({}, { order: { label: 1 } })
+            this.documentCategoryService.loadManyByQuery({}, { order: 'label' }),
+            this.documentTypeService.loadManyByQuery({}, { order: 'label' })
         ]);
         return { categories, types };
     }
@@ -169,14 +172,12 @@ let DocumentManagementService = class DocumentManagementService {
     async deleteDocumentRequestTemplate(parameters) {
         return this.documentRequestTemplateService.delete(parameters.id);
     }
-    async createDocument({ typeId, addition, date, expiration, originalFileName, collectionIds, properties, metadata }, content) {
+    async createDocument({ typeId, title, date, expiration, originalFileName, collectionIds, properties, metadata }, content) {
         return this.documentService.transaction(async (_, transaction) => {
             const documentFile = await this.createDocumentFile(content, originalFileName, transaction);
-            const document = await this.documentService.withTransaction(transaction).insert({ fileId: documentFile.id, typeId, addition, date, expiration, metadata });
-            if (isDefined(collectionIds)) {
-                for (const collectionId of toArray(collectionIds)) {
-                    await this.documentCollectionDocumentService.withTransaction(transaction).insert({ collectionId, documentId: document.id, archiveTimestamp: null });
-                }
+            const document = await this.documentService.withTransaction(transaction).insert({ fileId: documentFile.id, typeId, title, date, expiration, metadata });
+            for (const collectionId of toArray(collectionIds)) {
+                await this.documentCollectionDocumentService.withTransaction(transaction).insert({ collectionId, documentId: document.id, archiveTimestamp: null });
             }
             if (isDefined(properties)) {
                 const mappedProperties = properties.map((property) => ({ ...property, documentId: document.id }));
@@ -196,7 +197,7 @@ let DocumentManagementService = class DocumentManagementService {
             const document = await this.documentService.withTransaction(transaction).insert({
                 fileId: requestFile.fileId,
                 typeId: request.typeId,
-                addition: requestFile.addition,
+                title: requestFile.title,
                 date: null,
                 expiration: null,
                 metadata: documentMetadata
@@ -217,8 +218,8 @@ let DocumentManagementService = class DocumentManagementService {
             await this.documentRequestFileService.withTransaction(transaction).update(id, { approval: false, approvalComment, approvalTimestamp: currentTimestamp(), metadata });
         });
     }
-    async updateDocumentRequestFile({ id, addition, approvalComment, metadata }) {
-        return this.documentRequestFileService.update(id, { addition, approvalComment, metadata });
+    async updateDocumentRequestFile({ id, title, approvalComment, metadata }) {
+        return this.documentRequestFileService.update(id, { title, approvalComment, metadata });
     }
     async deleteDocumentRequestFile({ id, metadata }) {
         const requestFile = await this.documentRequestFileService.load(id);
@@ -243,7 +244,7 @@ let DocumentManagementService = class DocumentManagementService {
             return documentFile;
         });
     }
-    async createDocumentRequestFile({ requestId, addition, originalFileName, metadata }, content) {
+    async createDocumentRequestFile({ requestId, title, originalFileName, metadata }, content) {
         return this.documentRequestFileService.transaction(async (_, transaction) => {
             const [request, existingRequestFiles] = await Promise.all([
                 this.documentRequestService.withTransaction(transaction).load(requestId),
@@ -254,7 +255,7 @@ let DocumentManagementService = class DocumentManagementService {
                 throw new BadRequestError('Maximum amount of allowed files reached.');
             }
             const file = await this.createDocumentFile(content, originalFileName, transaction);
-            return this.documentRequestFileService.withTransaction(transaction).insert({ requestId, fileId: file.id, addition, createdDocumentId: null, approval: null, approvalComment: null, approvalTimestamp: null, metadata });
+            return this.documentRequestFileService.withTransaction(transaction).insert({ requestId, fileId: file.id, title, createdDocumentId: null, approval: null, approvalComment: null, approvalTimestamp: null, metadata });
         });
     }
     async createDocumentRequest(parameters, transaction) {
@@ -325,6 +326,53 @@ let DocumentManagementService = class DocumentManagementService {
     async assignPropertyToType(parameters) {
         await this.documentTypePropertyService.insert(parameters);
     }
+    async extractDocumentInformation() {
+        const file = await this.#aiService.processFile({ path: '', mimeType: '' });
+        const types = await this.documentTypeService.loadAll();
+        const typeLabels = types.map((type) => type.label);
+        const generationSchema = object({
+            documentTitle: string(),
+            documentSubtitle: nullable(string()),
+            documentTypes: array(enumeration(typeLabels)),
+            documentSummary: string(),
+            documentTags: array(string()),
+            documentDate: nullable(object({ year: integer(), month: integer(), day: integer() }))
+        });
+        const generation = await this.#aiService.generate({
+            model: 'gemini-2.0-flash',
+            generationOptions: {
+                maxOutputTokens: 2048,
+                temperature: 0.2,
+                topP: 0.2
+            },
+            generationSchema,
+            contents: [
+                {
+                    role: 'user', parts: [
+                        { file: file.file },
+                        {
+                            text: `Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
+
+Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen (ohne konkrete Werte).
+Erstelle bis zu 7 möglichst spezifische Tags ohne allgemeinen Worte.
+Antworte auf deutsch.`
+                        }
+                    ]
+                }
+            ]
+        });
+        const resultJson = JSON.parse(assertStringPass(generation.text, 'No text generated.'));
+        const result = generationSchema.parse(resultJson);
+        result.documentTags = result.documentTags.filter((tag) => (tag != result.documentTitle) && (tag != result.documentSubtitle));
+        return {
+            title: result.documentTitle,
+            subtitle: result.documentSubtitle,
+            types: result.documentTypes.map((typeLabel) => types.find((type) => type.label == typeLabel)).filter(isDefined),
+            summary: result.documentSummary,
+            tags: result.documentTags,
+            date: result.documentDate
+        };
+    }
     getDocumentPropertyValueService(dataType) {
         switch (dataType) {
             case DocumentPropertyDataType.Text:

package/examples/orm/schemas.d.ts

@@ -1,3 +1,3 @@
 import { User } from './user.model.js';
 export declare const mySchema: import("../../orm/server/database-schema.js").DatabaseSchema<"my_application">;
-export declare const user: import("../../orm/server/types.js").PgTableFromType<"my_application", typeof User>;
+export declare const user: import("../../orm/server/types.js").PgTableFromType<typeof User, "my_application">;

package/mail/drizzle.config.js

@@ -5,7 +5,7 @@ export default defineConfig({
     out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
     schema: resolve(__dirname, './models/schemas.js'),
     migrations: {
-        schema: 'authentication',
+        schema: 'mail',
         table: '_migrations'
     }
 });

package/mail/models/schemas.d.ts

@@ -1,3 +1,3 @@
 import { MailLog } from './mail-log.model.js';
 export declare const mailSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"mail">;
-export declare const mailLog: import("../../orm/server/types.js").PgTableFromType<"mail", typeof MailLog>;
+export declare const mailLog: import("../../orm/server/types.js").PgTableFromType<typeof MailLog, "mail">;

package/orm/decorators.d.ts

@@ -4,7 +4,7 @@ import type { AbstractConstructor, TypedOmit } from '../types.js';
 import type { Entity, EntityType } from './entity.js';
 import type { PgTableFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
-export type CheckBuilder<T extends Entity = any> = (table: PgTableFromType<string, EntityType<T>>) => SQL;
+export type CheckBuilder<T extends Entity = any> = (table: PgTableFromType<EntityType<T>>) => SQL;
 export type OrmTableReflectionData = {
     name?: string;
     schema?: string;
@@ -60,9 +60,9 @@ type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
 export declare function Table(name?: string, options?: TypedOmit<TableOptions, 'schema'>): ClassDecorator;
 export declare function Table(options?: TableOptions): ClassDecorator;
 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 declare function Unique(columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique<T>(name: string | undefined, columns: [Extract<keyof T, string>, ...Extract<keyof T, string>[]], options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique<T>(columns: [Extract<keyof T, string>, ...Extract<keyof T, string>[]], options?: UniqueReflectionData['options']): ClassDecorator;
 export declare function Index(name?: string, options?: IndexReflectionData['options']): PropertyDecorator;
-export declare function Index(name: string | undefined, columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
+export declare function Index(name: string, columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
 export declare function Index(columns: [string, ...string[]], options?: IndexReflectionData['options']): ClassDecorator;
 export {};

package/orm/entity.d.ts

@@ -1,13 +1,8 @@
-import type { Type, TypedOmit } from '../types.js';
-import type { UntaggedDeep } from '../types/index.js';
+import type { Type } 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> {
+export interface EntityType<T extends Entity | EntityWithoutMetadata = Entity | EntityWithoutMetadata> extends Type<T> {
     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 {
     [key: string]: unknown;
 }
@@ -22,3 +17,6 @@ export declare abstract class Entity {
     id: IsPrimaryKey<HasDefault<Uuid>>;
     metadata: Embedded<EntityMetadata>;
 }
+export declare abstract class EntityWithoutMetadata {
+    id: IsPrimaryKey<HasDefault<Uuid>>;
+}

package/orm/entity.js

@@ -44,7 +44,7 @@ __decorate([
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "attributes", void 0);
 EntityMetadata = __decorate([
-    Index(undefined, ['revision', 'revisionTimestamp'])
+    Index(['revision', 'revisionTimestamp'])
 ], EntityMetadata);
 export { EntityMetadata };
 export class Entity {
@@ -60,3 +60,11 @@ __decorate([
     Embedded(EntityMetadata, { prefix: null }),
     __metadata("design:type", Object)
 ], Entity.prototype, "metadata", void 0);
+export class EntityWithoutMetadata {
+    id;
+}
+__decorate([
+    PrimaryKey(),
+    Uuid({ defaultRandom: true }),
+    __metadata("design:type", Object)
+], EntityWithoutMetadata.prototype, "id", void 0);

package/orm/index.d.ts

@@ -1,3 +1,4 @@
 export * from './entity.js';
 export * from './query.js';
+export * from './repository.types.js';
 export * from './types.js';

package/orm/index.js

@@ -1,3 +1,4 @@
 export * from './entity.js';
 export * from './query.js';
+export * from './repository.types.js';
 export * from './types.js';

package/orm/query.d.ts

@@ -19,8 +19,6 @@ 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';
-export declare const allOrders: Order[];
 export type Operator = 'and' | 'or';
 export declare const allOperators: Operator[];
 export type LogicalAndQuery<T = any> = {
@@ -32,7 +30,7 @@ export type LogicalOrQuery<T = any> = {
 export type LogicalNorQuery<T = any> = {
     $nor: readonly Query<T>[];
 };
-export type ComparisonValue<T> = Untagged<T | Flatten<T>>;
+export type ComparisonValue<T> = Untagged<T | Flatten<T>> | SQLWrapper;
 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>;

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/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}".`);
 }