@tstdl/base 0.92.85 → 0.92.86

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, objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, isArray, isDefined, 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,11 @@ 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 targetColumns = toArray(target).map((path) => this.$getColumn(path));
         const columns = await this.mapManyToColumns(entities, transformContext);
         const mappedUpdate = await this.mapUpdate(update, transformContext);
         const rows = await this.session
-            .insert(this.table)
+            .insert(this.#table)
             .values(columns)
             .onConflictDoUpdate({
             target: targetColumns,
@@ -259,7 +264,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 +272,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,7 +284,7 @@ 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;
     }
@@ -288,9 +293,9 @@ let EntityRepository = class EntityRepository {
         const mappedUpdate = await this.mapUpdate(update, transformContext);
         const idQuery = this.getIdLimitQuery(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))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -298,14 +303,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 +319,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 +344,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) {
+        if (!this.hasMetadata) {
+            return this.tryHardDeleteByQuery(query);
+        }
         const idQuery = this.getIdLimitQuery(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))
             .returning();
         if (isUndefined(row)) {
             return undefined;
@@ -357,12 +368,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 +389,115 @@ 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 [row] = await this.session
+            .delete(this.#table)
+            .where(inArray(this.#table.id, idQuery))
+            .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);
+    }
+    $getColumn(path) {
+        const columnName = assertDefinedPass(this.#columnDefinitionsMap.get(path), `Could not map ${path} to column.`).name;
+        return this.#table[columnName];
+    }
+    $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);
     }
-    convertQuery(query) {
-        return convertQuery(query, this.table, this.columnDefinitionsMap);
+    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.getIdLimitQuery(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 +510,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 +523,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 +543,19 @@ let EntityRepository = class EntityRepository {
         }
         return {
             ...mappedUpdate,
-            attributes: this.getAttributesUpdate(update.metadata?.attributes),
-            revision: sql `${this.table.revision} + 1`,
-            revisionTimestamp: TRANSACTION_TIMESTAMP
+            ...(this.hasMetadata
+                ? {
+                    attributes: this.getAttributesUpdate(update?.metadata?.attributes),
+                    revision: sql `${this.#tableWithMetadata.revision} + 1`,
+                    revisionTimestamp: TRANSACTION_TIMESTAMP
+                }
+                : undefined)
         };
     }
     getIdLimitQuery(query) {
-        const sqlQuery = this.convertQuery(query);
-        return this.session.select({ id: this.table.id })
-            .from(this.table)
+        const sqlQuery = this.$convertQuery(query);
+        return this.session.select({ id: this.#table.id })
+            .from(this.#table)
             .where(sqlQuery)
             .limit(1);
     }
@@ -473,11 +563,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,7 @@
+import { type SQL } from 'drizzle-orm';
+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 {};

package/orm/server/sqls.js

@@ -0,0 +1,6 @@
+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`;
+}

package/orm/server/types.d.ts

@@ -3,7 +3,7 @@ import type { PgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
 import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { Record } from '../../schema/index.js';
-import type { AbstractConstructor, UnionToIntersection } from '../../types.js';
+import type { UnionToIntersection } from '../../types.js';
 import type { Tagged } from '../../types/index.js';
 import type { OrmColumnReflectionData } from '../decorators.js';
 import type { EntityType } from '../entity.js';
@@ -23,11 +23,11 @@ export type ColumnDefinition = {
 export type TransformContext = {
     encryptionKey?: CryptoKey;
 };
-type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
+type Column<Name extends string, T> = null extends T ? ColumnBuilder<Exclude<T, null>, Name> : NotNull<ColumnBuilder<T, Name>>;
 export type ColumnPrefix<T> = T extends Tagged<unknown, EmbeddedConfigTag, {
     prefix: infer Prefix;
 }> ? Prefix extends string ? Prefix : '' : '';
-export type PgTableFromType<S extends string, T extends AbstractConstructor, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
+export type PgTableFromType<T extends EntityType = EntityType, S extends string = string, TableName extends string = T extends Required<EntityType> ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
     name: TableName;
     schema: S;
     columns: BuildColumns<TableName, {

package/orm/types.d.ts

@@ -16,7 +16,7 @@ export type Embedded<T = AbstractConstructor, P extends string = ''> = Tagged<T,
     prefix: P;
 }>;
 export type Array<T extends Tagged<ObjectLiteral, ColumnTypeTag, PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], ColumnTypeTag, ReturnType<GetTagMetadata<T, ColumnTypeTag>['array']>>;
-export type Json<T extends ObjectLiteral = ObjectLiteral> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
+export type Json<T> = Tagged<T, ColumnTypeTag, $Type<ReturnType<typeof jsonb>, T>>;
 export type Enum<T extends EnumerationObject> = Tagged<EnumerationValue<T>, ColumnTypeTag, EnumColumn<T>>;
 export type Text = Tagged<string, ColumnTypeTag, ReturnType<typeof text<string, [string, ...string[]]>>>;
 export type Uuid = Tagged<string, ColumnTypeTag, ReturnType<typeof uuid>>;