@tstdl/base 0.92.142 → 0.92.143

package/key-value-store/postgres/key-value-store.service.js

@@ -0,0 +1,65 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { Singleton, injectArgument, provide } from '../../injector/index.js';
+import { DatabaseConfig, Transactional } from '../../orm/server/index.js';
+import { EntityRepositoryConfig, injectRepository } from '../../orm/server/repository.js';
+import { objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, isDefined, isUndefined } from '../../utils/type-guards.js';
+import { KeyValueStore } from '../key-value.store.js';
+import { KeyValue } from './models/index.js';
+import { PostgresKeyValueStoreModuleConfig } from './module.js';
+let PostgresKeyValueStore = class PostgresKeyValueStore extends Transactional {
+    #keyValueRepository = injectRepository(KeyValue);
+    module = assertDefinedPass(injectArgument(this), 'KeyValueStore module must be passed as argument.');
+    async get(key, defaultValue) {
+        const result = await this.#keyValueRepository.tryLoadByQuery({ module: this.module, key: key });
+        if (isUndefined(result)) {
+            return defaultValue;
+        }
+        return result.value;
+    }
+    async set(key, value) {
+        await this.#keyValueRepository.upsert(['module', 'key'], { module: this.module, key: key, value });
+    }
+    async getOrSet(key, value) {
+        const keyValue = await this.#keyValueRepository.transaction(async (tx) => {
+            const keyValue = await this.#keyValueRepository.withTransaction(tx).insertIfNotExists(['module', 'key'], { module: this.module, key: key, value });
+            if (isDefined(keyValue)) {
+                return keyValue;
+            }
+            return await this.#keyValueRepository.withTransaction(tx).loadByQuery({ module: this.module, key: key });
+        });
+        return keyValue.value;
+    }
+    async setMany(keyValues) {
+        const entries = objectEntries(keyValues).map(([key, value]) => ({
+            module: this.module,
+            key: key,
+            value,
+        }));
+        await this.#keyValueRepository.upsertMany(['module', 'key'], entries);
+    }
+    async delete(key) {
+        const result = await this.#keyValueRepository.tryDeleteByQuery({ module: this.module, key: key });
+        return isDefined(result);
+    }
+    async deleteMany(keys) {
+        await this.#keyValueRepository.deleteManyByQuery({ module: this.module, key: { $in: keys } });
+    }
+    async clear() {
+        await this.#keyValueRepository.hardDeleteManyByQuery({ module: this.module });
+    }
+};
+PostgresKeyValueStore = __decorate([
+    Singleton({
+        providers: [
+            provide(EntityRepositoryConfig, { useValue: { schema: 'key_value_store' } }),
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(PostgresKeyValueStoreModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
+        ],
+    })
+], PostgresKeyValueStore);
+export { PostgresKeyValueStore };

package/key-value-store/postgres/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './key-value.model.js';
+export * from './schemas.js';

package/key-value-store/postgres/models/index.js

@@ -0,0 +1,2 @@
+export * from './key-value.model.js';
+export * from './schemas.js';

package/key-value-store/postgres/models/key-value.model.d.ts

@@ -0,0 +1,7 @@
+import { Entity } from '../../../orm/entity.js';
+import { Json } from '../../../orm/types.js';
+export declare class KeyValue extends Entity {
+    module: string;
+    key: string;
+    value: Json<unknown>;
+}

package/key-value-store/postgres/models/key-value.model.js

@@ -0,0 +1,35 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Table } from '../../../orm/decorators.js';
+import { Entity } from '../../../orm/entity.js';
+import { Json, Unique } from '../../../orm/types.js';
+import { any, StringProperty } from '../../../schema/index.js';
+let KeyValue = class KeyValue extends Entity {
+    module;
+    key;
+    value;
+};
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], KeyValue.prototype, "module", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], KeyValue.prototype, "key", void 0);
+__decorate([
+    Json({ schema: any() }),
+    __metadata("design:type", Object)
+], KeyValue.prototype, "value", void 0);
+KeyValue = __decorate([
+    Table('key_value'),
+    Unique(['module', 'key'])
+], KeyValue);
+export { KeyValue };

package/key-value-store/postgres/models/schemas.d.ts

@@ -0,0 +1,3 @@
+import { KeyValue } from './key-value.model.js';
+export declare const keyValueSchema: import("../../../orm/server/database-schema.js").DatabaseSchema<"key_value_store">;
+export declare const keyValue: import("../../../orm/server/types.js").PgTableFromType<typeof KeyValue, "key_value_store">;

package/key-value-store/postgres/models/schemas.js

@@ -0,0 +1,4 @@
+import { databaseSchema } from '../../../orm/server/database-schema.js';
+import { KeyValue } from './key-value.model.js';
+export const keyValueSchema = databaseSchema('key_value_store');
+export const keyValue = keyValueSchema.getTable(KeyValue);

package/key-value-store/postgres/module.d.ts

@@ -0,0 +1,6 @@
+import { type DatabaseConfig } from '../../orm/server/index.js';
+export declare class PostgresKeyValueStoreModuleConfig {
+    database?: DatabaseConfig;
+}
+export declare function configurePostgresKeyValueStore(config?: PostgresKeyValueStoreModuleConfig): void;
+export declare function migratePostgresKeyValueStoreSchema(): Promise<void>;

package/key-value-store/postgres/module.js

@@ -0,0 +1,23 @@
+import { inject, Injector } from '../../injector/index.js';
+import { Database, migrate } from '../../orm/server/index.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { KeyValueStore } from '../key-value.store.js';
+import { PostgresKeyValueStore } from './key-value-store.service.js';
+export class PostgresKeyValueStoreModuleConfig {
+    database;
+}
+export function configurePostgresKeyValueStore(config) {
+    if (isDefined(config)) {
+        Injector.register(PostgresKeyValueStoreModuleConfig, { useValue: config });
+    }
+    Injector.registerSingleton(KeyValueStore, { useToken: PostgresKeyValueStore });
+}
+export async function migratePostgresKeyValueStoreSchema() {
+    const connection = inject(PostgresKeyValueStoreModuleConfig, undefined, { optional: true })?.database?.connection;
+    const database = inject(Database, connection);
+    await migrate(database, {
+        migrationsSchema: 'key_value_store',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
+    });
+}

package/lock/web/web-lock.d.ts

@@ -1,7 +1,6 @@
 import type { AcquireResult, LockedFunction, UsingResult } from '../lock.js';
 import { Lock } from '../lock.js';
 export declare class WebLock extends Lock {
-    constructor(resource: string);
     acquire<Throw extends boolean>(timeout: number | undefined, throwOnFail: Throw): Promise<AcquireResult<Throw>>;
     use<Throw extends boolean, R>(timeout: number | undefined, throwOnFail: Throw, func: LockedFunction<R>): Promise<UsingResult<Throw, R>>;
     exists(): Promise<boolean>;

package/lock/web/web-lock.js

@@ -4,20 +4,14 @@ 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;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
+import { map, timer } from 'rxjs';
 import { CancellationToken } from '../../cancellation/index.js';
 import { Injectable } from '../../injector/index.js';
 import { DeferredPromise } from '../../promise/deferred-promise.js';
 import { assertStringPass, isDefined, isNull, isObject } from '../../utils/type-guards.js';
-import { map, timer } from 'rxjs';
 import { Lock } from '../lock.js';
 import { WebLockProvider } from './web-lock.provider.js';
 let WebLock = class WebLock extends Lock {
-    constructor(resource) {
-        super(resource);
-    }
     async acquire(timeout, throwOnFail) {
         const acquirePromise = new DeferredPromise();
         const releasePromise = new DeferredPromise();
@@ -25,12 +19,12 @@ let WebLock = class WebLock extends Lock {
             lost: false,
             release() {
                 releasePromise.resolve();
-            }
+            },
         };
         const timeoutToken = (isDefined(timeout) && (timeout > 0)) ? CancellationToken.from(timer(timeout).pipe(map(() => true))) : undefined;
         void navigator.locks.request(this.resource, {
             signal: isDefined(timeoutToken) ? timeoutToken.asAbortSignal() : undefined,
-            ifAvailable: isDefined(timeout) && (timeout <= 0)
+            ifAvailable: isDefined(timeout) && (timeout <= 0),
         }, async (lock) => {
             if (isNull(lock)) {
                 acquirePromise.resolve(false);
@@ -81,9 +75,8 @@ WebLock = __decorate([
                 const resource = assertStringPass(isObject(arg) ? arg.resource : arg, 'invalid lock argument');
                 const provider = context.resolve(WebLockProvider, prefix);
                 return provider.get(resource);
-            }
-        }
-    }),
-    __metadata("design:paramtypes", [String])
+            },
+        },
+    })
 ], WebLock);
 export { WebLock };

package/orm/data-types/timestamp.js

@@ -17,5 +17,5 @@ export const timestamp = customType({
     },
     fromDriver(value) {
         return new Date(value).getTime();
-    }
+    },
 });

package/orm/decorators.d.ts

@@ -5,8 +5,9 @@
 import type { SQL } from 'drizzle-orm';
 import type { LiteralUnion } from 'type-fest';
 import type { AbstractConstructor, TypedOmit } from '../types.js';
-import type { Entity, EntityType, EntityWithoutMetadata } from './entity.js';
+import type { AnyEntity, Entity, EntityType, EntityWithoutMetadata } from './entity.js';
 import type { Query } from './query.js';
+import type { TargetColumnPaths } from './repository.types.js';
 import type { PgTableFromType } from './server/types.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
 type NamingStrategy = 'abbreviated-table';
@@ -34,6 +35,7 @@ export type OrmTableReflectionData = {
     unique?: UniqueReflectionData[];
     index?: IndexReflectionData[];
     checks?: CheckReflectionData[];
+    foreignKeys?: ForeignKeyReflectionData[];
 };
 /**
  * Reflection data stored for ORM column decorators.
@@ -50,18 +52,21 @@ export type OrmColumnReflectionData = {
         type: AbstractConstructor;
         prefix?: string | null;
     };
-    references?: () => EntityType;
+    references?: {
+        target: () => EntityType;
+        targetColumn?: TargetColumnPaths<any>;
+    }[];
     encrypted?: boolean;
 };
 /**
  * Reflection data for unique constraints.
  */
 export type UniqueReflectionData = {
-    name?: string;
     columns?: string[];
     options?: {
-        nulls?: 'distinct' | 'not distinct';
+        name?: string;
         naming?: NamingStrategy;
+        nulls?: 'distinct' | 'not distinct';
     };
 };
 /**
@@ -69,15 +74,15 @@ export type UniqueReflectionData = {
  * @template T - The entity type.
  */
 export type IndexReflectionData<T extends Entity | EntityWithoutMetadata = any> = {
-    name?: string;
     columns?: (string | [string, 'asc' | 'desc'])[];
     order?: 'asc' | 'desc';
     options?: {
+        name?: string;
+        naming?: NamingStrategy;
         using?: IndexMethod;
         unique?: boolean;
         where?: WhereBuilder<T>;
         nulls?: 'first' | 'last';
-        naming?: NamingStrategy;
     };
 };
 type CheckReflectionData = {
@@ -87,6 +92,15 @@ type CheckReflectionData = {
         naming?: NamingStrategy;
     };
 };
+export type ForeignKeyReflectionData = {
+    target: () => EntityType;
+    columns: TargetColumnPaths<any>[];
+    foreignColumns: TargetColumnPaths<any>[];
+    options?: {
+        name?: string;
+        naming?: NamingStrategy;
+    };
+};
 /**
  * Factory function to create a class decorator for ORM table configuration.
  * Merges provided data with existing ORM reflection data on the class metadata.
@@ -124,7 +138,8 @@ export declare function PrimaryKey(): PropertyDecorator;
  * @param type - A function returning the referenced entity type.
  * @returns A property decorator.
  */
-export declare function References(type: () => EntityType): PropertyDecorator;
+export declare function References(target: () => EntityType): PropertyDecorator;
+export declare function References<T extends AnyEntity>(target: () => EntityType<T>, targetColumn?: TargetColumnPaths<T>): PropertyDecorator;
 /**
  * Decorator to define a table check constraint.
  * @template T - The entity type.
@@ -146,7 +161,7 @@ export declare function Encrypted(): PropertyDecorator;
  * @returns A property decorator.
  */
 export declare function Embedded(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
-type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
+export type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
 /**
  * Decorator to specify the database table name and optionally the schema.
  * @param name - The table name.
@@ -161,21 +176,23 @@ export declare function Table(name?: string, options?: TypedOmit<TableOptions, '
  */
 export declare function Table(options?: TableOptions): ClassDecorator;
 /**
- * Decorator to define a unique constraint on a single column.
- * @param name - Optional name for the unique constraint.
- * @param options - Additional unique constraint options.
+ * Decorator to define a foreign key relationship.
+ * @param target - A function returning the referenced entity type.
+ * @param columns - The columns in the current entity that form the foreign key.
+ * @param foreignColumns - The columns in the referenced entity that the foreign key points to.
+ * @param options - Additional foreign key options (e.g., name, naming strategy).
+ * @template TThis - The entity type of the current entity.
+ * @template TTarget - The entity type of the referenced entity.
  * @returns A property decorator.
  */
-export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
+export declare function ForeignKey<TThis extends AnyEntity, TTarget extends AnyEntity>(target: () => EntityType<TTarget>, columns: Columns<TThis>, foreignColumns: Columns<TTarget>, options?: ForeignKeyReflectionData['options']): ClassDecorator;
 /**
- * Decorator to define a composite unique constraint on multiple columns.
- * @template T - The entity type.
- * @param name - The name of the unique constraint.
- * @param columns - An array of property names included in the constraint.
+ * Decorator to define a unique constraint on a single column.
+ * @param name - Optional name for the unique constraint.
  * @param options - Additional unique constraint options.
- * @returns A class decorator.
+ * @returns A property decorator.
  */
-export declare function Unique<T>(name: string | undefined, columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique(options?: UniqueReflectionData['options']): PropertyDecorator;
 /**
  * Decorator to define a composite unique constraint on multiple columns.
  * @template T - The entity type.
@@ -183,7 +200,7 @@ export declare function Unique<T>(name: string | undefined, columns: Columns<T>,
  * @param options - Additional unique constraint options.
  * @returns A class decorator.
  */
-export declare function Unique<T>(columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
+export declare function Unique<T extends AnyEntity>(columns: Columns<T>, options?: UniqueReflectionData['options']): ClassDecorator;
 /**
  * Decorator to define an index on a single column.
  * @template T - The entity type.
@@ -191,16 +208,7 @@ export declare function Unique<T>(columns: Columns<T>, options?: UniqueReflectio
  * @param options - Additional index options (e.g., method, uniqueness, conditions).
  * @returns A property decorator.
  */
-export declare function Index<T extends Entity | EntityWithoutMetadata = any>(name?: string, options?: IndexReflectionData<T>['options']): PropertyDecorator;
-/**
- * Decorator to define a composite index on multiple columns.
- * @template T - The entity type.
- * @param name - The name of the index.
- * @param columns - An array of property names (or tuples with direction) included in the index.
- * @param options - Additional index options.
- * @returns A class decorator.
- */
-export declare function Index<T extends Entity | EntityWithoutMetadata = any>(name: string, columns: Columns<T>, options?: IndexReflectionData<T>['options']): ClassDecorator;
+export declare function Index<T extends Entity | EntityWithoutMetadata = any>(options?: IndexReflectionData<T>['options']): PropertyDecorator;
 /**
  * Decorator to define a composite index on multiple columns.
  * @template T - The entity type.

package/orm/decorators.js

@@ -1,7 +1,7 @@
 import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/index.js';
 import { Property } from '../schema/index.js';
 import { filterUndefinedObjectProperties, objectEntries } from '../utils/object/object.js';
-import { assertNotArrayPass, isArray, isString, isUndefined } from '../utils/type-guards.js';
+import { isArray, isString, isUndefined } from '../utils/type-guards.js';
 /**
  * Factory function to create a class decorator for ORM table configuration.
  * Merges provided data with existing ORM reflection data on the class metadata.
@@ -26,7 +26,7 @@ export function createTableDecorator(data = {}) {
                 }
             }
             metadata.data.set('orm', reflectionData, true);
-        }
+        },
     });
 }
 /**
@@ -35,8 +35,26 @@ export function createTableDecorator(data = {}) {
  * @param data - The ORM column reflection data to add.
  * @returns A property decorator.
  */
-export function createColumnDecorator(data) {
-    return createPropertyDecorator({ data: { orm: data }, mergeData: true });
+export function createColumnDecorator(data = {}) {
+    return createPropertyDecorator({
+        handler: (_, metadata) => {
+            const reflectionData = metadata.data.tryGet('orm') ?? {};
+            const dataEntries = objectEntries(data);
+            if (dataEntries.length == 0) {
+                return;
+            }
+            for (const [key, value] of dataEntries) {
+                const existingValue = reflectionData[key];
+                if (isArray(existingValue)) {
+                    reflectionData[key] = [...existingValue, ...value];
+                }
+                else {
+                    reflectionData[key] = value;
+                }
+            }
+            metadata.data.set('orm', reflectionData, true);
+        },
+    });
 }
 /**
  * Factory function to create a decorator applicable to both classes and properties for ORM configuration.
@@ -62,13 +80,8 @@ export function Column(options) {
 export function PrimaryKey() {
     return createColumnDecorator({ primaryKey: true });
 }
-/**
- * Decorator to define a foreign key relationship.
- * @param type - A function returning the referenced entity type.
- * @returns A property decorator.
- */
-export function References(type) {
-    return createColumnDecorator({ references: type });
+export function References(target, targetColumn) {
+    return createColumnDecorator({ references: [{ target, targetColumn }] });
 }
 /**
  * Decorator to define a table check constraint.
@@ -96,7 +109,7 @@ export function Encrypted() {
  */
 export function Embedded(type, options) {
     return createPropertyDecorator({
-        include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })]
+        include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })],
     });
 }
 export function Table(nameOrOptions, optionsOrNothing) {
@@ -107,21 +120,28 @@ export function Table(nameOrOptions, optionsOrNothing) {
         : filterUndefinedObjectProperties({ name, schema });
     return createTableDecorator(data);
 }
-export function Unique(nameOrColumns, columnsOrOptions, options) {
-    if (isArray(nameOrColumns)) {
-        return createTableDecorator({ unique: [{ columns: nameOrColumns, options: assertNotArrayPass(columnsOrOptions) }] });
-    }
+/**
+ * Decorator to define a foreign key relationship.
+ * @param target - A function returning the referenced entity type.
+ * @param columns - The columns in the current entity that form the foreign key.
+ * @param foreignColumns - The columns in the referenced entity that the foreign key points to.
+ * @param options - Additional foreign key options (e.g., name, naming strategy).
+ * @template TThis - The entity type of the current entity.
+ * @template TTarget - The entity type of the referenced entity.
+ * @returns A property decorator.
+ */
+export function ForeignKey(target, columns, foreignColumns, options) {
+    return createTableDecorator({ foreignKeys: [{ target, columns, foreignColumns, options }] });
+}
+export function Unique(columnsOrOptions, options) {
     if (isArray(columnsOrOptions)) {
-        return createTableDecorator({ unique: [{ name: nameOrColumns, columns: columnsOrOptions, options }] });
+        return createTableDecorator({ unique: [{ columns: columnsOrOptions, options }] });
     }
-    return createColumnDecorator({ unique: { name: nameOrColumns, options: columnsOrOptions } });
+    return createColumnDecorator({ unique: { options: columnsOrOptions } });
 }
-export function Index(nameOrColumns, columnsOrOptions, options) {
-    if (isArray(nameOrColumns)) {
-        return createTableDecorator({ index: [{ columns: nameOrColumns, options: assertNotArrayPass(columnsOrOptions) }] });
-    }
+export function Index(columnsOrOptions, options) {
     if (isArray(columnsOrOptions)) {
-        return createTableDecorator({ index: [{ name: nameOrColumns, columns: columnsOrOptions, options }] });
+        return createTableDecorator({ index: [{ columns: columnsOrOptions, options }] });
     }
-    return createColumnDecorator({ index: { name: nameOrColumns, options: columnsOrOptions ?? options } });
+    return createColumnDecorator({ index: { options: columnsOrOptions } });
 }

package/orm/entity.d.ts

@@ -7,6 +7,7 @@ import { Embedded, type HasDefault, type IsPrimaryKey, Json, Timestamp, Uuid } f
 export interface EntityType<T extends Entity | EntityWithoutMetadata = Entity | EntityWithoutMetadata> extends Type<T> {
     readonly entityName?: string;
 }
+export type AnyEntity = Entity | EntityWithoutMetadata;
 /**
  * Base class for extensible metadata attributes associated with an entity.
  * Allows storing arbitrary key-value pairs.

package/orm/query.d.ts

@@ -20,7 +20,7 @@ export type ComparisonQueryBody<T = any> = {
 /** Represents either a full comparison query object or a direct value for equality comparison. */
 export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | ComparisonValue<T>;
 /** Represents a comparison query using various operators like $eq, $ne, $gt, $in, etc. */
-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 ComparisonQuery<T = any> = Partial<ComparisonAndQuery<T> & ComparisonOrQuery<T> & 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>;
 /** Union of keys representing comparison query operators. */
 export type ComparisonQueryTypes = keyof ComparisonQuery;
 /** Array containing all valid comparison query operator keys. */
@@ -63,9 +63,17 @@ export type LogicalNorQuery<T = any> = {
 export type ComparisonValue<T> = T | Flatten<T> | SQLWrapper;
 /** Represents a comparison value that can also include a RegExp for string comparisons. */
 export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends readonly string[] ? ComparisonValue<readonly (Flatten<T> | RegExp)[]> : (T | Flatten<T>);
+/** Represents a logical AND query. All sub-queries must be true. */
+export type ComparisonAndQuery<T = any> = {
+    $and: readonly ComparisonQueryOrValue<T>[];
+};
+/** Represents a logical OR query. At least one sub-query must be true. */
+export type ComparisonOrQuery<T = any> = {
+    $or: readonly ComparisonQueryOrValue<T>[];
+};
 /** Represents a NOT comparison query. Inverts the result of the nested comparison. */
 export type ComparisonNotQuery<T = any> = {
-    $not: ComparisonQuery<T>;
+    $not: ComparisonQueryOrValue<T>;
 };
 /** Represents an equality comparison query ($eq). */
 export type ComparisonEqualsQuery<T = any> = {

package/orm/repository.types.d.ts

@@ -60,6 +60,7 @@ export type LoadManyOptions<T extends EntityWithoutMetadata> = LoadOptions<T> &
 export type UpdateOptions<T extends EntityWithoutMetadata> = LoadOptions<T>;
 /** Type definition for updating entity metadata attributes, allowing partial updates and SQL expressions. */
 export type EntityMetadataUpdate = WithSql<Partial<UntaggedDeep<Pick<EntityMetadata, 'attributes'>>>>;
+export type EntityMetadataInsert = Partial<Pick<EntityMetadata, 'attributes'>>;
 /**
  * Represents the data structure for creating a new entity.
  * Excludes 'id' and 'metadata' by default, but allows providing an optional 'id' and partial 'metadata.attributes'.
@@ -68,7 +69,7 @@ export type EntityMetadataUpdate = WithSql<Partial<UntaggedDeep<Pick<EntityMetad
  */
 export type NewEntity<T extends Entity | EntityWithoutMetadata> = T extends Entity ? WithSql<UntaggedDeep<TypedOmit<T, 'id' | 'metadata'> & {
     id?: string;
-    metadata?: Partial<Pick<EntityMetadata, 'attributes'>>;
+    metadata?: EntityMetadataInsert;
 }>> : WithSql<UntaggedDeep<TypedOmit<T, 'id'> & {
     id?: string;
 }>>;

package/orm/schemas/json.d.ts

@@ -1,9 +1,15 @@
+import type { JsonPath } from '../../json-path/json-path.js';
 import { type Decorator } from '../../reflection/index.js';
-import { ObjectSchema, type ObjectSchemaOptions, type SchemaDecoratorOptions } from '../../schema/index.js';
-export type JsonSchemaOptions = Pick<ObjectSchemaOptions, 'factory'>;
-export declare class JsonSchema extends ObjectSchema {
+import { Schema, type SchemaDecoratorOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../../schema/index.js';
+import type { TypedOmit } from '../../types.js';
+export type JsonSchemaOptions<T> = {
+    schema?: SchemaTestable<T>;
+};
+export declare class JsonSchema<T> extends Schema<T> {
     readonly name = "Json";
-    constructor(options?: JsonSchemaOptions);
+    readonly innerSchema: Schema<T>;
+    constructor(options?: JsonSchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
 }
-export declare function json(options?: JsonSchemaOptions): JsonSchema;
-export declare function Json(options?: JsonSchemaOptions & SchemaDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;
+export declare function json<T>(options?: JsonSchemaOptions<T>): JsonSchema<T>;
+export declare function Json(options?: JsonSchemaOptions<any> & TypedOmit<SchemaDecoratorOptions, 'schema'>): Decorator<'class' | 'property' | 'accessor'>;

package/orm/schemas/json.js

@@ -1,19 +1,26 @@
 import { createDecorator } from '../../reflection/index.js';
-import { any, Class, ObjectSchema, Property } from '../../schema/index.js';
-export class JsonSchema extends ObjectSchema {
+import { any, Class, object, Property, Schema, schemaTestableToSchema } from '../../schema/index.js';
+import { isDefined } from '../../utils/type-guards.js';
+export class JsonSchema extends Schema {
     name = 'Json';
+    innerSchema;
     constructor(options) {
-        super({}, { ...options, unknownPropertiesKey: any(), unknownProperties: any() });
+        super();
+        this.innerSchema = isDefined(options?.schema) ? schemaTestableToSchema(options.schema) : any();
+    }
+    _test(value, path, options) {
+        return this.innerSchema._test(value, path, options);
     }
 }
 export function json(options) {
     return new JsonSchema(options);
 }
 export function Json(options) {
+    const { schema, ...optionsRest } = options ?? {};
     return createDecorator({ class: true, property: true, accessor: true }, (data, metadata, args) => {
         if (data.type == 'class') {
-            return Class({ schema: json({ factory: { type: data.constructor } }) })(args[0]);
+            return Class({ schema: json({ schema: schema ?? object({}, { unknownPropertiesKey: any(), unknownProperties: any(), factory: { type: data.constructor } }) }) })(args[0]);
         }
-        return Property(json({ factory: { type: metadata.type } }), options)(args[0], args[1], args[2]);
+        return Property(json({ schema: schema ?? object({}, { unknownPropertiesKey: any(), unknownProperties: any(), factory: { type: metadata.type } }) }), optionsRest)(args[0], args[1], args[2]);
     });
 }

package/orm/server/database.js

@@ -32,8 +32,11 @@ Injector.registerSingleton(Database, {
         if (isUndefined(connection)) {
             throw new Error('Missing postgres connection. Provide it either via injection argument or a provider for DatabaseConfig.');
         }
-        const pool = new Pool(connection);
-        context.addDisposeHandler(async () => pool.end());
+        const pool = new Pool({
+            idle_in_transaction_session_timeout: 10000,
+            ...connection,
+        });
+        context.addDisposeHandler(async () => await pool.end());
         return drizzle(pool);
     },
 });