@tstdl/base 0.92.85 → 0.92.87

package/orm/server/repository.js

@@ -8,7 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { count, eq, inArray, sql } from 'drizzle-orm';
+import { asc, count, desc, eq, inArray, isSQLWrapper, SQL, sql } from 'drizzle-orm';
 import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
 import { createContextProvider } from '../../context/context.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
@@ -21,11 +21,14 @@ import { toArray } from '../../utils/array/array.js';
 import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { importSymmetricKey } from '../../utils/cryptography.js';
-import { fromDeepObjectEntries } from '../../utils/object/object.js';
-import { assertDefined, assertDefinedPass, assertNotNullPass, isNotNull, isUndefined } from '../../utils/type-guards.js';
+import { typeExtends } from '../../utils/index.js';
+import { fromDeepObjectEntries, fromEntries, objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, isArray, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { Entity } from '../entity.js';
 import { Database } from './database.js';
 import { getColumnDefinitions, getDrizzleTableFromType } from './drizzle/schema-converter.js';
 import { convertQuery } from './query-converter.js';
+import { TRANSACTION_TIMESTAMP } from './sqls.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
 import { DrizzleTransaction } from './transaction.js';
 export const repositoryType = Symbol('repositoryType');
@@ -33,30 +36,28 @@ export class EntityRepositoryConfig {
     schema;
 }
 const entityTypeToken = Symbol('EntityType');
-const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
 const { getCurrentEntityRepositoryContext, runInEntityRepositoryContext, isInEntityRepositoryContext } = createContextProvider('EntityRepository');
 let EntityRepository = class EntityRepository {
     #injector = inject(Injector);
     #repositoryConstructor;
     #withTransactionCache = new WeakMap();
     #encryptionSecret = isInEntityRepositoryContext() ? getCurrentEntityRepositoryContext()?.encryptionSecret : inject(ENCRYPTION_SECRET, undefined, { optional: true });
-    #transformContext;
-    type;
-    table;
-    columnDefinitions;
-    columnDefinitionsMap;
-    session;
-    isInTransaction;
+    #context = getCurrentEntityRepositoryContext() ?? {};
+    #transformContext = this.#context.transformContext;
+    type = this.#context.type ?? injectArgument(this, { optional: true }) ?? assertDefinedPass(this.constructor[entityTypeToken], 'Missing entity type.');
+    typeName = this.type.entityName ?? this.type.name;
+    #table = this.#context.table ?? getDrizzleTableFromType(this.type, inject(EntityRepositoryConfig).schema);
+    #tableWithMetadata = this.#table;
+    #columnDefinitions = this.#context.columnDefinitions ?? getColumnDefinitions(this.#table);
+    #columnDefinitionsMap = this.#context.columnDefinitionsMap ?? new Map(this.#columnDefinitions.map((column) => [column.objectPath.path, column]));
+    session = this.#context.session ?? inject(Database);
+    isInTransaction = this.session instanceof DrizzlePgTransaction;
+    hasMetadata = typeExtends(this.type, Entity);
+    get table() {
+        return this.#table;
+    }
     constructor() {
         this.#repositoryConstructor = new.target;
-        const { type, table, columnDefinitions, columnDefinitionsMap, session, transformContext } = getCurrentEntityRepositoryContext() ?? {};
-        this.type = type ?? injectArgument(this, { optional: true }) ?? assertDefinedPass(new.target[entityTypeToken], 'Missing entity type.');
-        this.table = table ?? getDrizzleTableFromType(this.type, inject(EntityRepositoryConfig).schema);
-        this.columnDefinitions = columnDefinitions ?? getColumnDefinitions(this.table);
-        this.columnDefinitionsMap = columnDefinitionsMap ?? new Map(this.columnDefinitions.map((column) => [column.objectPath.path, column]));
-        this.session = session ?? inject(Database);
-        this.isInTransaction = this.session instanceof DrizzlePgTransaction;
-        this.#transformContext = transformContext;
     }
     withOptionalTransaction(transaction) {
         if (isUndefined(transaction)) {
@@ -70,9 +71,9 @@ let EntityRepository = class EntityRepository {
         }
         const context = {
             type: this.type,
-            table: this.table,
-            columnDefinitions: this.columnDefinitions,
-            columnDefinitionsMap: this.columnDefinitionsMap,
+            table: this.#table,
+            columnDefinitions: this.#columnDefinitions,
+            columnDefinitionsMap: this.#columnDefinitionsMap,
             session: transaction.transaction,
             encryptionSecret: this.#encryptionSecret,
             transformContext: this.#transformContext
@@ -99,26 +100,30 @@ let EntityRepository = class EntityRepository {
     async load(id) {
         const entity = await this.tryLoad(id);
         if (isUndefined(entity)) {
-            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+            throw new NotFoundError(`${this.typeName} ${id} not found.`);
         }
         return entity;
     }
     async tryLoad(id) {
-        return this.tryLoadByQuery(eq(this.table.id, id));
+        return this.tryLoadByQuery(eq(this.#table.id, id));
     }
     async loadByQuery(query, options) {
         const entity = await this.tryLoadByQuery(query, options);
         if (isUndefined(entity)) {
-            throw new NotFoundError(`${this.type.entityName} not found.`);
+            throw new NotFoundError(`${this.typeName} not found.`);
         }
         return entity;
     }
     async tryLoadByQuery(query, options) {
-        const sqlQuery = this.convertQuery(query);
-        const dbQuery = this.session.select()
-            .from(this.table)
+        const sqlQuery = this.$convertQuery(query);
+        let dbQuery = this.session.select()
+            .from(this.#table)
             .where(sqlQuery)
-            .offset(options?.offset);
+            .offset(options?.offset)
+            .$dynamic();
+        if (isDefined(options?.order)) {
+            dbQuery = dbQuery.orderBy(...this.$convertOrderBy(options.order));
+        }
         const [row] = await dbQuery;
         if (isUndefined(row)) {
             return undefined;
@@ -127,19 +132,25 @@ let EntityRepository = class EntityRepository {
         return this.mapToEntity(row, transformContext);
     }
     async loadMany(ids, options) {
-        return this.loadManyByQuery(inArray(this.table.id, ids), options);
+        return this.loadManyByQuery(inArray(this.#table.id, ids), options);
     }
     async *loadManyCursor(ids, options) {
         const entities = await this.loadMany(ids, options);
         yield* entities;
     }
     async loadManyByQuery(query, options) {
-        const sqlQuery = this.convertQuery(query);
-        const rows = await this.session.select()
-            .from(this.table)
+        const sqlQuery = this.$convertQuery(query);
+        let dbQuery = this.session.select()
+            .from(this.#table)
             .where(sqlQuery)
+            .orderBy()
             .offset(options?.offset)
-            .limit(options?.limit);
+            .limit(options?.limit)
+            .$dynamic();
+        if (isDefined(options?.order)) {
+            dbQuery = dbQuery.orderBy(...this.$convertOrderBy(options.order));
+        }
+        const rows = await dbQuery;
         const transformContext = await this.getTransformContext();
         return this.mapManyToEntity(rows, transformContext);
     }
@@ -157,34 +168,34 @@ let EntityRepository = class EntityRepository {
     async count() {
         const dbQuery = this.session
             .select({ count: count() })
-            .from(this.table);
+            .from(this.#table);
         const [result] = await dbQuery;
         return assertDefinedPass(result).count;
     }
     async countByQuery(query) {
-        const sqlQuery = this.convertQuery(query);
+        const sqlQuery = this.$convertQuery(query);
         const dbQuery = this.session
             .select({ count: count() })
-            .from(this.table)
+            .from(this.#table)
             .where(sqlQuery);
         const [result] = await dbQuery;
         return assertDefinedPass(result).count;
     }
     async has(id) {
-        return this.hasByQuery(eq(this.table.id, id));
+        return this.hasByQuery(eq(this.#table.id, id));
     }
     async hasByQuery(query) {
-        const sqlQuery = this.convertQuery(query);
+        const sqlQuery = this.$convertQuery(query);
         const dbQuery = this.session
-            .select({ exists: sql `SELECT EXISTS(SELECT 1 FROM ${this.table} WHERE ${sqlQuery})` })
-            .from(this.table);
+            .select({ exists: sql `SELECT EXISTS(SELECT 1 FROM ${this.#table} WHERE ${sqlQuery})` })
+            .from(this.#table);
         const [result] = await dbQuery;
         return assertDefinedPass(result).exists;
     }
     async hasAll(ids) {
         const result = await this.session
-            .select({ contains: sql `array_agg(${this.table.id}) @> ${ids}`.as('contains') })
-            .from(this.table);
+            .select({ contains: sql `array_agg(${this.#table.id}) @> ${ids}`.as('contains') })
+            .from(this.#table);
         return assertDefinedPass(result[0]).contains;
     }
     /**
@@ -196,7 +207,7 @@ let EntityRepository = class EntityRepository {
         const transformContext = await this.getTransformContext();
         const columns = await this.mapToInsertColumns(entity, transformContext);
         const [row] = await this.session
-            .insert(this.table)
+            .insert(this.#table)
             .values(columns)
             .onConflictDoNothing()
             .returning();
@@ -209,7 +220,7 @@ let EntityRepository = class EntityRepository {
         const transformContext = await this.getTransformContext();
         const columns = await this.mapToInsertColumns(entity, transformContext);
         const [row] = await this.session
-            .insert(this.table)
+            .insert(this.#table)
             .values(columns)
             .returning();
         return this.mapToEntity(row, transformContext);
@@ -217,19 +228,16 @@ let EntityRepository = class EntityRepository {
     async insertMany(entities) {
         const transformContext = await this.getTransformContext();
         const columns = await this.mapManyToInsertColumns(entities, transformContext);
-        const rows = await this.session.insert(this.table).values(columns).returning();
+        const rows = await this.session.insert(this.#table).values(columns).returning();
         return this.mapManyToEntity(rows, transformContext);
     }
     async upsert(target, entity, update) {
         const transformContext = await this.getTransformContext();
-        const targetColumns = toArray(target).map((path) => {
-            const columnName = assertDefinedPass(this.columnDefinitionsMap.get(path), `Could not map ${path} to column.`).name;
-            return this.table[columnName];
-        });
+        const targetColumns = toArray(target).map((path) => this.$getColumn(path));
         const columns = await this.mapToInsertColumns(entity, transformContext);
         const mappedUpdate = await this.mapUpdate(update ?? entity, transformContext);
         const [row] = await this.session
-            .insert(this.table)
+            .insert(this.#table)
             .values(columns)
             .onConflictDoUpdate({
             target: targetColumns,
@@ -240,14 +248,16 @@ let EntityRepository = class EntityRepository {
     }
     async upsertMany(target, entities, update) {
         const transformContext = await this.getTransformContext();
-        const targetColumns = toArray(target).map((path) => {
-            const columnName = assertDefinedPass(this.columnDefinitionsMap.get(path), `Could not map ${path} to column.`).name;
-            return this.table[columnName];
-        });
-        const columns = await this.mapManyToColumns(entities, transformContext);
-        const mappedUpdate = await this.mapUpdate(update, transformContext);
+        const targetColumns = toArray(target).map((path) => this.$getColumn(path));
+        const columns = await this.mapManyToInsertColumns(entities, transformContext);
+        const mappedUpdate = isDefined(update)
+            ? await this.mapUpdate(update, transformContext)
+            : {
+                ...fromEntries(this.#columnDefinitions.map((column) => [column.name, sql `excluded.${sql.identifier(this.$getColumn(column).name)}`])),
+                ...this.getMetadataUpdate(update)
+            };
         const rows = await this.session
-            .insert(this.table)
+            .insert(this.#table)
             .values(columns)
             .onConflictDoUpdate({
             target: targetColumns,
@@ -259,7 +269,7 @@ let EntityRepository = class EntityRepository {
     async update(id, update) {
         const entity = await this.tryUpdate(id, update);
         if (isUndefined(entity)) {
-            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+            throw new NotFoundError(`${this.typeName} ${id} not found.`);
         }
         return entity;
     }
@@ -267,9 +277,9 @@ let EntityRepository = class EntityRepository {
         const transformContext = await this.getTransformContext();
         const mappedUpdate = await this.mapUpdate(update, transformContext);
         const [row] = await this.session
-            .update(this.table)
+            .update(this.#table)
             .set(mappedUpdate)
-            .where(eq(this.table.id, id))
+            .where(eq(this.#table.id, id))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -279,18 +289,18 @@ let EntityRepository = class EntityRepository {
     async updateByQuery(query, update) {
         const entity = await this.tryUpdateByQuery(query, update);
         if (isUndefined(entity)) {
-            throw new NotFoundError(`${this.type.entityName} not found.`);
+            throw new NotFoundError(`${this.typeName} not found.`);
         }
         return entity;
     }
     async tryUpdateByQuery(query, update) {
         const transformContext = await this.getTransformContext();
         const mappedUpdate = await this.mapUpdate(update, transformContext);
-        const idQuery = this.getIdLimitQuery(query);
+        const idQuery = this.getIdLimitSelect(query);
         const [row] = await this.session
-            .update(this.table)
+            .update(this.#table)
             .set(mappedUpdate)
-            .where(inArray(this.table.id, idQuery))
+            .where(inArray(this.#table.id, idQuery.for('update')))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -298,14 +308,14 @@ let EntityRepository = class EntityRepository {
         return this.mapToEntity(row, transformContext);
     }
     async updateMany(ids, update) {
-        return this.updateManyByQuery(inArray(this.table.id, ids), update);
+        return this.updateManyByQuery(inArray(this.#table.id, ids), update);
     }
     async updateManyByQuery(query, update) {
         const transformContext = await this.getTransformContext();
-        const sqlQuery = this.convertQuery(query);
+        const sqlQuery = this.$convertQuery(query);
         const mappedUpdate = await this.mapUpdate(update, transformContext);
         const rows = await this.session
-            .update(this.table)
+            .update(this.#table)
             .set(mappedUpdate)
             .where(sqlQuery)
             .returning();
@@ -314,18 +324,21 @@ let EntityRepository = class EntityRepository {
     async delete(id, metadataUpdate) {
         const entity = await this.tryDelete(id, metadataUpdate);
         if (isUndefined(entity)) {
-            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+            throw new NotFoundError(`${this.typeName} ${id} not found.`);
         }
         return entity;
     }
     async tryDelete(id, metadataUpdate) {
+        if (!this.hasMetadata) {
+            return this.tryHardDelete(id);
+        }
         const [row] = await this.session
-            .update(this.table)
+            .update(this.#tableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
             attributes: this.getAttributesUpdate(metadataUpdate?.attributes)
         })
-            .where(eq(this.table.id, id))
+            .where(eq(this.#table.id, id))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -336,19 +349,22 @@ let EntityRepository = class EntityRepository {
     async deleteByQuery(query, metadataUpdate) {
         const entity = await this.tryDeleteByQuery(query, metadataUpdate);
         if (isUndefined(entity)) {
-            throw new NotFoundError(`${this.type.entityName} not found.`);
+            throw new NotFoundError(`${this.typeName} not found.`);
         }
         return entity;
     }
     async tryDeleteByQuery(query, metadataUpdate) {
-        const idQuery = this.getIdLimitQuery(query);
+        if (!this.hasMetadata) {
+            return this.tryHardDeleteByQuery(query);
+        }
+        const idQuery = this.getIdLimitSelect(query);
         const [row] = await this.session
-            .update(this.table)
+            .update(this.#tableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
             attributes: this.getAttributesUpdate(metadataUpdate?.attributes)
         })
-            .where(inArray(this.table.id, idQuery))
+            .where(inArray(this.#table.id, idQuery.for('update')))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -357,12 +373,15 @@ let EntityRepository = class EntityRepository {
         return this.mapToEntity(row, transformContext);
     }
     async deleteMany(ids, metadataUpdate) {
-        return this.deleteManyByQuery(inArray(this.table.id, ids), metadataUpdate);
+        return this.deleteManyByQuery(inArray(this.#table.id, ids), metadataUpdate);
     }
     async deleteManyByQuery(query, metadataUpdate) {
-        const sqlQuery = this.convertQuery(query);
+        if (!this.hasMetadata) {
+            return this.hardDeleteManyByQuery(query);
+        }
+        const sqlQuery = this.$convertQuery(query);
         const rows = await this.session
-            .update(this.table)
+            .update(this.#tableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
             attributes: this.getAttributesUpdate(metadataUpdate?.attributes)
@@ -375,47 +394,118 @@ let EntityRepository = class EntityRepository {
     async hardDelete(id) {
         const result = await this.tryHardDelete(id);
         if (!result) {
-            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+            throw new NotFoundError(`${this.typeName} ${id} not found.`);
         }
+        return result;
     }
     async tryHardDelete(id) {
-        const result = await this.session
-            .delete(this.table)
-            .where(eq(this.table.id, id));
-        return isNotNull(result.rowCount) && (result.rowCount > 0);
+        const [row] = await this.session
+            .delete(this.#table)
+            .where(eq(this.#table.id, id))
+            .returning();
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        const transformContext = await this.getTransformContext();
+        return this.mapToEntity(row, transformContext);
     }
     async hardDeleteByQuery(query) {
         const result = await this.tryHardDeleteByQuery(query);
         if (!result) {
-            throw new NotFoundError(`${this.type.entityName} not found.`);
+            throw new NotFoundError(`${this.typeName} not found.`);
         }
+        return result;
     }
     async tryHardDeleteByQuery(query) {
-        const idQuery = this.getIdLimitQuery(query);
-        const result = await this.session
-            .delete(this.table)
-            .where(inArray(this.table.id, idQuery));
-        return isNotNull(result.rowCount) && (result.rowCount > 0);
+        const idQuery = this.getIdLimitSelect(query);
+        const [row] = await this.session
+            .delete(this.#table)
+            .where(inArray(this.#table.id, idQuery.for('update')))
+            .returning();
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        const transformContext = await this.getTransformContext();
+        return this.mapToEntity(row, transformContext);
     }
     async hardDeleteMany(ids) {
-        return this.hardDeleteManyByQuery(inArray(this.table.id, ids));
+        return this.hardDeleteManyByQuery(inArray(this.#table.id, ids));
     }
     async hardDeleteManyByQuery(query) {
-        const sqlQuery = this.convertQuery(query);
-        const result = await this.session
-            .delete(this.table)
-            .where(sqlQuery);
-        return assertNotNullPass(result.rowCount);
+        const sqlQuery = this.$convertQuery(query);
+        const rows = await this.session
+            .delete(this.#table)
+            .where(sqlQuery)
+            .returning();
+        const transformContext = await this.getTransformContext();
+        return this.mapManyToEntity(rows, transformContext);
     }
-    convertQuery(query) {
-        return convertQuery(query, this.table, this.columnDefinitionsMap);
+    $getColumn(pathOrColumn) {
+        if (isString(pathOrColumn)) {
+            const columnName = assertDefinedPass(this.#columnDefinitionsMap.get(pathOrColumn), `Could not map ${pathOrColumn} to column.`).name;
+            return this.#table[columnName];
+        }
+        return this.#table[pathOrColumn.name];
+    }
+    $convertOrderBy(orderBy) {
+        if (isArray(orderBy)) {
+            return orderBy.map((item) => {
+                const itemIsArray = isArray(item);
+                const target = itemIsArray ? item[0] : item;
+                const column = isSQLWrapper(target) ? target : this.$getColumn(target);
+                const direction = itemIsArray ? item[1] : 'asc';
+                return direction == 'asc' ? asc(column) : desc(column);
+            });
+        }
+        return objectEntries(orderBy)
+            .map(([path, direction]) => {
+            const column = this.$getColumn(path);
+            return direction == 'asc' ? asc(column) : desc(column);
+        });
+    }
+    $convertQuery(query) {
+        return convertQuery(query, this.#table, this.#columnDefinitionsMap);
+    }
+    async $mapManyToEntity(columns) {
+        const transformContext = await this.getTransformContext();
+        return this.mapManyToEntity(columns, transformContext);
+    }
+    async $mapToEntity(columns) {
+        const transformContext = await this.getTransformContext();
+        return this.mapToEntity(columns, transformContext);
+    }
+    async $mapManyToColumns(objects) {
+        const transformContext = await this.getTransformContext();
+        return this.mapManyToColumns(objects, transformContext);
+    }
+    async $mapToColumns(obj) {
+        const transformContext = await this.getTransformContext();
+        return this.mapToColumns(obj, transformContext);
+    }
+    async $mapManyToInsertColumns(objects) {
+        const transformContext = await this.getTransformContext();
+        return this.mapManyToInsertColumns(objects, transformContext);
+    }
+    async $mapToInsertColumns(obj) {
+        const transformContext = await this.getTransformContext();
+        return this.mapToInsertColumns(obj, transformContext);
+    }
+    async $mapUpdate(update) {
+        const transformContext = await this.getTransformContext();
+        return this.mapUpdate(update, transformContext);
+    }
+    $getIdLimitQuery(query) {
+        return this.getIdLimitSelect(query);
+    }
+    $getAttributesUpdate(attributes) {
+        return this.getAttributesUpdate(attributes);
     }
     async mapManyToEntity(columns, transformContext) {
         return toArrayAsync(mapAsync(columns, async (column) => this.mapToEntity(column, transformContext)));
     }
     async mapToEntity(columns, transformContext) {
         const entries = [];
-        for (const def of this.columnDefinitions) {
+        for (const def of this.#columnDefinitions) {
             const rawValue = columns[def.name];
             const transformed = await def.fromDatabase(rawValue, transformContext);
             entries.push([def.objectPath, transformed]); // eslint-disable-line @typescript-eslint/no-unsafe-argument
@@ -428,7 +518,7 @@ let EntityRepository = class EntityRepository {
     }
     async mapToColumns(obj, transformContext) {
         const columns = {};
-        for (const def of this.columnDefinitions) {
+        for (const def of this.#columnDefinitions) {
             const rawValue = def.dereferenceObjectPath(obj);
             columns[def.name] = await def.toDatabase(rawValue, transformContext);
         }
@@ -441,14 +531,18 @@ let EntityRepository = class EntityRepository {
         const mapped = await this.mapToColumns(obj, transformContext);
         return {
             ...mapped,
-            revision: 1,
-            revisionTimestamp: TRANSACTION_TIMESTAMP,
-            createTimestamp: TRANSACTION_TIMESTAMP
+            ...(this.hasMetadata
+                ? {
+                    revision: 1,
+                    revisionTimestamp: TRANSACTION_TIMESTAMP,
+                    createTimestamp: TRANSACTION_TIMESTAMP
+                }
+                : undefined)
         };
     }
     async mapUpdate(update, transformContext) {
         const mappedUpdate = {};
-        for (const column of this.columnDefinitions) {
+        for (const column of this.#columnDefinitions) {
             const value = column.dereferenceObjectPath(update);
             if (isUndefined(value)) {
                 continue;
@@ -457,15 +551,22 @@ let EntityRepository = class EntityRepository {
         }
         return {
             ...mappedUpdate,
-            attributes: this.getAttributesUpdate(update.metadata?.attributes),
-            revision: sql `${this.table.revision} + 1`,
-            revisionTimestamp: TRANSACTION_TIMESTAMP
+            ...this.getMetadataUpdate(update)
         };
     }
-    getIdLimitQuery(query) {
-        const sqlQuery = this.convertQuery(query);
-        return this.session.select({ id: this.table.id })
-            .from(this.table)
+    getMetadataUpdate(update) {
+        return this.hasMetadata
+            ? {
+                attributes: this.getAttributesUpdate(update?.metadata?.attributes),
+                revision: sql `${this.#tableWithMetadata.revision} + 1`,
+                revisionTimestamp: TRANSACTION_TIMESTAMP
+            }
+            : undefined;
+    }
+    getIdLimitSelect(query) {
+        const sqlQuery = this.$convertQuery(query);
+        return this.session.select({ id: this.#table.id })
+            .from(this.#table)
             .where(sqlQuery)
             .limit(1);
     }
@@ -473,11 +574,17 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(attributes)) {
             return undefined;
         }
-        return sql `${this.table.attributes} || ${JSON.stringify(attributes)}::jsonb`;
+        if (attributes instanceof SQL) {
+            return attributes;
+        }
+        return sql `${this.#tableWithMetadata.attributes} || ${JSON.stringify(attributes)}::jsonb`;
     }
     async getTransformContext() {
         if (isUndefined(this.#transformContext)) {
-            assertDefined(this.#encryptionSecret, 'Missing database encryption secret');
+            if (isUndefined(this.#encryptionSecret)) {
+                this.#transformContext = {};
+                return this.#transformContext;
+            }
             this.#transformContext = importSymmetricKey('AES-GCM', 256, this.#encryptionSecret, false).then((encryptionKey) => ({ encryptionKey }));
             const transformContext = await this.#transformContext;
             this.#transformContext = transformContext;

package/orm/server/sqls.d.ts

@@ -0,0 +1,15 @@
+import { type Column, type SQL } from 'drizzle-orm';
+import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
+import type { Uuid } from '../types.js';
+export declare const TRANSACTION_TIMESTAMP: SQL<Date>;
+export declare const RANDOM_UUID: SQL<Uuid>;
+type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
+export declare function interval(value: number, unit: IntervalUnit): SQL;
+export declare function arrayAgg<T extends Column>(column: T): SQL<SelectResultField<T>[]>;
+export declare function jsonAgg<T extends TableLike>(tableOrColumn: T): SQL<SelectResultField<GetSelectTableSelection<T>>[]>;
+export declare namespace jsonAgg {
+    var withNull: <T extends TableLike>(tableOrColumn: T) => SQL<(SelectResultField<GetSelectTableSelection<T>> | null)[]>;
+}
+export declare function coalesce<T extends (Column | SQL)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
+export declare function toJsonb<T extends (Column | SQL)>(column: T): SQL<SelectResultField<T>>;
+export {};

package/orm/server/sqls.js

@@ -0,0 +1,19 @@
+import { sql } from 'drizzle-orm';
+export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
+export const RANDOM_UUID = sql `gen_random_uuid()`;
+export function interval(value, unit) {
+    return sql `(${value} ||' ${sql.raw(unit)}')::interval`;
+}
+export function arrayAgg(column) {
+    return sql `array_agg(${column})`;
+}
+export function jsonAgg(tableOrColumn) {
+    return sql `json_agg(${tableOrColumn})`;
+}
+jsonAgg.withNull = jsonAgg;
+export function coalesce(...columns) {
+    return sql `coalesce(${sql.join(columns, sql.raw(', '))})`;
+}
+export function toJsonb(column) {
+    return sql `to_jsonb(${column})`;
+}