@tstdl/base 0.92.55 → 0.92.56

package/authentication/models/schemas.d.ts

@@ -1,5 +1,5 @@
 import { AuthenticationCredentials } from './authentication-credentials.model.js';
 import { AuthenticationSession } from './authentication-session.model.js';
 export declare const authenticationSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"authentication">;
-export declare const authenticationCredentials: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"authentication", typeof AuthenticationCredentials>;
-export declare const authenticationSession: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"authentication", typeof AuthenticationSession>;
+export declare const authenticationCredentials: import("../../orm/server/types.js").PgTableFromType<"authentication", typeof AuthenticationCredentials>;
+export declare const authenticationSession: import("../../orm/server/types.js").PgTableFromType<"authentication", typeof AuthenticationSession>;

package/document-management/models/schemas.d.ts

@@ -14,20 +14,20 @@ import { DocumentType } from './document-type.model.js';
 import { Document } from './document.model.js';
 export declare const documentManagementSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"document_management">;
 export declare const dataType: import("drizzle-orm/pg-core").PgEnum<["boolean", "decimal", "text", "integer"]>;
-export declare const documentCategory: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentCategory>;
-export declare const documentCollectionDocument: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentCollectionDocument>;
-export declare const documentCollection: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentCollection>;
-export declare const documentFile: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentFile>;
-export declare const documentPropertyTextValue: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentPropertyTextValue>;
-export declare const documentPropertyIntegerValue: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentPropertyIntegerValue>;
-export declare const documentPropertyDecimalValue: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentPropertyDecimalValue>;
-export declare const documentPropertyBooleanValue: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentPropertyBooleanValue>;
-export declare const documentProperty: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentProperty>;
-export declare const documentRequestCollection: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentRequestCollection>;
-export declare const documentRequestFile: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentRequestFile>;
-export declare const documentRequestTemplate: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentRequestTemplate>;
-export declare const documentRequest: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentRequest>;
-export declare const documentRequestsTemplate: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentRequestsTemplate>;
-export declare const documentTypeProperty: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentTypeProperty>;
-export declare const documentType: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof DocumentType>;
-export declare const document: import("../../orm/server/drizzle/schema-converter.js").PgTableFromType<"document_management", typeof Document>;
+export declare const documentCategory: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentCategory>;
+export declare const documentCollectionDocument: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentCollectionDocument>;
+export declare const documentCollection: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentCollection>;
+export declare const documentFile: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentFile>;
+export declare const documentPropertyTextValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyTextValue>;
+export declare const documentPropertyIntegerValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyIntegerValue>;
+export declare const documentPropertyDecimalValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyDecimalValue>;
+export declare const documentPropertyBooleanValue: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentPropertyBooleanValue>;
+export declare const documentProperty: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentProperty>;
+export declare const documentRequestCollection: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestCollection>;
+export declare const documentRequestFile: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestFile>;
+export declare const documentRequestTemplate: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestTemplate>;
+export declare const documentRequest: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequest>;
+export declare const documentRequestsTemplate: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentRequestsTemplate>;
+export declare const documentTypeProperty: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentTypeProperty>;
+export declare const documentType: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof DocumentType>;
+export declare const document: import("../../orm/server/types.js").PgTableFromType<"document_management", typeof Document>;

package/examples/orm/schemas.d.ts

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

package/mail/models/schemas.d.ts

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

package/orm/decorators.d.ts

@@ -20,6 +20,7 @@ export type OrmColumnReflectionData = {
         prefix?: string | null;
     };
     references?: () => EntityType;
+    encrypted?: boolean;
 };
 export type UniqueReflectionData = {
     name?: string;
@@ -44,6 +45,7 @@ export declare function createTableAndColumnDecorator(data?: OrmColumnReflection
 export declare function Column(options: OrmColumnReflectionData): PropertyDecorator;
 export declare function PrimaryKey(): PropertyDecorator;
 export declare function References(type: () => EntityType): PropertyDecorator;
+export declare function Encrypted(): PropertyDecorator;
 export declare function Embedded(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
 export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
 export declare function Unique(name: string | undefined, columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;

package/orm/decorators.js

@@ -19,6 +19,9 @@ export function PrimaryKey() {
 export function References(type) {
     return createColumnDecorator({ references: type });
 }
+export function Encrypted() {
+    return createColumnDecorator({ encrypted: true });
+}
 export function Embedded(type, options) {
     return createPropertyDecorator({
         include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })]

package/orm/server/database-schema.d.ts

@@ -1,7 +1,7 @@
 import type { PgEnum } from 'drizzle-orm/pg-core';
 import type { Enumeration, EnumerationValue, UnionToTuple } from '../../types.js';
 import type { EntityType } from '../entity.js';
-import { type PgTableFromType } from './drizzle/schema-converter.js';
+import type { PgTableFromType } from './types.js';
 export declare class DatabaseSchema<Name extends string> {
     readonly name: Name;
     constructor(name: Name);

package/orm/server/drizzle/schema-converter.d.ts

@@ -1,45 +1,12 @@
-import type { BuildColumns, NotNull } from 'drizzle-orm';
-import { type PgColumnBuilder, type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
-import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
-import { JsonPath } from '../../../json-path/json-path.js';
-import { type Record } from '../../../schema/index.js';
-import type { AbstractConstructor, Enumeration, UnionToIntersection } from '../../../types.js';
-import type { Tagged } from '../../../types/index.js';
-import type { OrmColumnReflectionData } from '../../decorators.js';
+import { type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
+import type { AbstractConstructor, Enumeration } from '../../../types.js';
 import type { EntityType } from '../../entity.js';
-import type { ColumnBuilder, EmbeddedConfigTag } from '../../types.js';
-type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
+import type { ColumnDefinition, PgTableFromType } from '../types.js';
 type ConverterContext = {
     type: AbstractConstructor;
     property: string;
 };
-export type ColumnDefinition = {
-    name: string;
-    objectPath: JsonPath;
-    type: PgColumnBuilder<any, any, any, any>;
-    reflectionData: OrmColumnReflectionData | undefined;
-    dereferenceObjectPath: (obj: Record) => any;
-};
 export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
-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<{
-    name: TableName;
-    schema: S;
-    columns: BuildColumns<TableName, {
-        [P in Exclude<keyof InstanceType<T>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
-    } & UnionToIntersection<{
-        [P in keyof EmbeddedProperties<InstanceType<T>>]: EmbeddedColumns<InstanceType<T>[P], ColumnPrefix<InstanceType<T>[P]>>;
-    }[keyof EmbeddedProperties<InstanceType<T>>]>, 'pg'>;
-    dialect: 'pg';
-}>;
-export type EmbeddedProperties<T> = ConditionalPick<T, Tagged<unknown, EmbeddedConfigTag, {
-    prefix: any;
-}>>;
-export type EmbeddedColumns<T, Prefix extends string> = {
-    [P in keyof T as CamelCase<`${Prefix}${Extract<P, string>}`>]: Column<CamelCase<`${Prefix}${Extract<P, string>}`>, T[P]>;
-};
 export declare function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
 export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, schemaName: S, tableName?: string): PgTableFromType<S, T>;
 export declare function registerEnum(enumeration: Enumeration, name: string): void;

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

@@ -6,6 +6,7 @@ import { JsonPath } from '../../../json-path/json-path.js';
 import { reflectionRegistry } from '../../../reflection/registry.js';
 import { ArraySchema, BooleanSchema, DefaultSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema, Uint8ArraySchema } from '../../../schema/index.js';
 import { compareByValueSelectionToOrder, orderRest } from '../../../utils/comparison.js';
+import { decodeText, encodeUtf8 } from '../../../utils/encoding.js';
 import { enumValues } from '../../../utils/enum.js';
 import { memoize, memoizeSingle } from '../../../utils/function/memoize.js';
 import { compileDereferencer } from '../../../utils/object/dereference.js';
@@ -16,6 +17,7 @@ import { NumericDateSchema } from '../../schemas/numeric-date.js';
 import { TimestampSchema } from '../../schemas/timestamp.js';
 import { UuidSchema } from '../../schemas/uuid.js';
 import { bytea } from '../data-types/bytea.js';
+import { decryptBytes, encryptBytes } from '../encryption.js';
 const getDbSchema = memoizeSingle(pgSchema);
 export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
 const columnDefinitionsSymbol = Symbol('columnDefinitions');
@@ -86,13 +88,28 @@ function getPostgresColumnEntries(type, tableName, dbSchema, path = new JsonPath
             return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, tableName, dbSchema, path.add(property), nestedPrefix);
         }
         const objectPath = path.add(property);
+        const encrypted = columnReflectionData?.encrypted == true;
+        const toDatabase = encrypted
+            ? async (value, context) => {
+                const bytes = encodeUtf8(value);
+                return encryptBytes(bytes, context.encryptionKey);
+            }
+            : (value) => value;
+        const fromDatabase = encrypted
+            ? async (value, context) => {
+                const decrypted = await decryptBytes(value, context.encryptionKey);
+                return decodeText(decrypted);
+            }
+            : (value) => value;
         return [
             {
                 name: toCamelCase([prefix, columnName].join('')),
                 objectPath,
                 type: getPostgresColumn(columnName, dbSchema, schema, columnReflectionData ?? {}, { type, property }),
                 reflectionData: columnReflectionData,
-                dereferenceObjectPath: compileDereferencer(objectPath, { optional: true })
+                dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
+                toDatabase,
+                fromDatabase
             }
         ];
     });

package/orm/server/encryption.d.ts

@@ -0,0 +1,2 @@
+export declare function encryptBytes(bytes: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+export declare function decryptBytes(bytes: Uint8Array, key: CryptoKey): Promise<Uint8Array>;

package/orm/server/encryption.js

@@ -0,0 +1,30 @@
+import { DetailsError } from '../../errors/index.js';
+import { decrypt, encrypt } from '../../utils/cryptography.js';
+import { getRandomBytes } from '../../utils/random.js';
+import { assert } from '../../utils/type-guards.js';
+const encryptionVersion = 1;
+const encryptionVersionBytes = 2;
+const ivBytes = 12;
+export async function encryptBytes(bytes, key) {
+    const iv = getRandomBytes(ivBytes);
+    const encrypted = await encrypt({ name: 'AES-GCM', iv }, key, bytes).toBuffer();
+    const result = new Uint8Array(encryptionVersionBytes + ivBytes + encrypted.byteLength);
+    const resultView = new DataView(result.buffer);
+    resultView.setUint16(0, encryptionVersion);
+    result.set(iv, encryptionVersionBytes);
+    result.set(new Uint8Array(encrypted), encryptionVersionBytes + ivBytes);
+    return result;
+}
+export async function decryptBytes(bytes, key) {
+    const bytesView = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+    const version = bytesView.getUint16(0);
+    const iv = bytes.slice(encryptionVersionBytes, encryptionVersionBytes + ivBytes);
+    assert(version == encryptionVersion, 'Invalid encryption version.');
+    try {
+        const decrypted = await decrypt({ name: 'AES-GCM', iv }, key, bytes.slice(encryptionVersionBytes + ivBytes)).toBuffer();
+        return new Uint8Array(decrypted);
+    }
+    catch (error) {
+        throw new DetailsError('Decrypt error', error);
+    }
+}

package/orm/server/module.d.ts

@@ -7,4 +7,6 @@ export type OrmModuleOptions = {
     connection?: string | PoolConfig;
     repositoryConfig?: EntityRepositoryConfig;
 };
-export declare function configureOrm(options: OrmModuleOptions): void;
+export declare function configureOrm(options: OrmModuleOptions & {
+    encryptionSecret?: Uint8Array;
+}): void;

package/orm/server/module.js

@@ -1,6 +1,7 @@
 import { Injector } from '../../injector/injector.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { EntityRepositoryConfig } from './repository.js';
+import { ENCRYPTION_SECRET } from './tokens.js';
 export class DatabaseConfig {
     connection;
 }
@@ -11,4 +12,7 @@ export function configureOrm(options) {
     if (isDefined(options.repositoryConfig)) {
         Injector.register(EntityRepositoryConfig, { useValue: options.repositoryConfig });
     }
+    if (isDefined(options.encryptionSecret)) {
+        Injector.register(ENCRYPTION_SECRET, { useValue: options.encryptionSecret });
+    }
 }

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

@@ -1,5 +1,5 @@
 import { SQL } from 'drizzle-orm';
-import type { ColumnDefinition, PgTableFromType } from './drizzle/schema-converter.js';
 import type { EntityType } from '../entity.js';
 import type { Query } from '../query.js';
+import type { ColumnDefinition, PgTableFromType } from './types.js';
 export declare function convertQuery(query: Query, table: PgTableFromType<string, EntityType>, columnDefinitionsMap: Map<string, ColumnDefinition>): SQL;

package/orm/server/query-converter.js

@@ -14,7 +14,6 @@ export function convertQuery(query, table, columnDefinitionsMap) {
     if (queryEntries.length == 0) {
         return sqlTrue;
     }
-    // eslint-disable-next-line no-unreachable-loop
     for (const [property, value] of queryEntries) {
         const isPrimitiveValue = isPrimitive(value);
         if (property == '$and') {

package/orm/server/repository.d.ts

@@ -7,8 +7,8 @@ import type { UntaggedDeep } from '../../types/index.js';
 import type { Entity, EntityMetadata, EntityMetadataAttributes, EntityType, NewEntity } from '../entity.js';
 import type { Query } from '../query.js';
 import { Database } from './database.js';
-import { type ColumnDefinition, type PgTableFromType } from './drizzle/schema-converter.js';
 import { type Transaction, type TransactionConfig } from './transaction.js';
+import type { ColumnDefinition, PgTableFromType, TransformContext } from './types.js';
 type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export declare const repositoryType: unique symbol;
 export type OrderOptions<T extends Entity> = {
@@ -83,10 +83,13 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
     hardDeleteMany(ids: string[]): Promise<number>;
     hardDeleteManyByQuery(query: Query<T>): Promise<number>;
     protected convertQuery(query: Query<T>): SQL;
-    protected mapToEntity(columns: this['table']['$inferSelect']): T;
-    protected mapToColumns(obj: DeepPartial<T> | NewEntity<T>): PgInsertValue<PgTableFromType<string, EntityType>>;
-    protected mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>): PgInsertValue<PgTableFromType<string, EntityType>>;
-    protected mapUpdate(update: EntityUpdate<T>): PgUpdateSetSource<PgTableFromType<string, EntityType>>;
+    protected mapManyToEntity(columns: this['table']['$inferSelect'][], transformContext: TransformContext): Promise<T[]>;
+    protected mapToEntity(columns: this['table']['$inferSelect'], transformContext: TransformContext): Promise<T>;
+    protected mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>[]>;
+    protected mapToColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>>;
+    protected mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>[]>;
+    protected mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType<string, EntityType>>>;
+    protected mapUpdate(update: EntityUpdate<T>, transformContext: TransformContext): Promise<PgUpdateSetSource<PgTableFromType<string, EntityType>>>;
     protected getIdLimitQuery(query: Query<T>): import("drizzle-orm/pg-core").WithSubqueryWithSelection<{
         id: PgColumn<{
             name: string;
@@ -107,6 +110,7 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
         }, {}, {}>;
     }, "id">;
     protected getAttributesUpdate(attributes: EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
+    protected getTransformContext(): Promise<TransformContext>;
 }
 export declare function injectRepository<T extends Entity>(type: EntityType<T>): EntityRepository<T>;
 export declare function getRepository<T extends Entity>(type: EntityType<T>, config?: EntityRepositoryConfig): Type<EntityRepository<T>>;

package/orm/server/repository.js

@@ -17,11 +17,15 @@ import { resolveArgumentType } from '../../injector/interfaces.js';
 import { injectionToken } from '../../injector/token.js';
 import { Schema } from '../../schema/schema.js';
 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 { assertDefinedPass, assertNotNullPass, isNotNull, isUndefined } from '../../utils/type-guards.js';
+import { assertDefined, assertDefinedPass, assertNotNullPass, isNotNull, isUndefined } from '../../utils/type-guards.js';
 import { Database } from './database.js';
 import { getColumnDefinitions, getDrizzleTableFromType } from './drizzle/schema-converter.js';
 import { convertQuery } from './query-converter.js';
+import { ENCRYPTION_SECRET } from './tokens.js';
 import { DrizzleTransaction } from './transaction.js';
 export const repositoryType = Symbol('repositoryType');
 export class EntityRepositoryConfig {
@@ -32,6 +36,8 @@ const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
 let EntityRepository = class EntityRepository {
     #repositoryConstructor;
     #withTransactionCache = new WeakMap();
+    #encryptionSecret = inject(ENCRYPTION_SECRET, undefined, { optional: true });
+    #transformContext;
     type;
     table;
     columnDefinitions;
@@ -103,7 +109,8 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        const transformContext = await this.getTransformContext();
+        return this.mapToEntity(row, transformContext);
     }
     async loadMany(ids, options) {
         return this.loadManyByQuery(inArray(this.table.id, ids), options);
@@ -119,7 +126,8 @@ let EntityRepository = class EntityRepository {
             .where(sqlQuery)
             .offset(options?.offset)
             .limit(options?.limit);
-        return rows.map((entity) => this.mapToEntity(entity));
+        const transformContext = await this.getTransformContext();
+        return this.mapManyToEntity(rows, transformContext);
     }
     async *loadManyByQueryCursor(query, options) {
         const entities = await this.loadManyByQuery(query, options);
@@ -166,25 +174,28 @@ let EntityRepository = class EntityRepository {
         return assertDefinedPass(result[0]).contains;
     }
     async insert(entity) {
-        const columns = this.mapToInsertColumns(entity);
+        const transformContext = await this.getTransformContext();
+        const columns = await this.mapToInsertColumns(entity, transformContext);
         const [row] = await this.session
             .insert(this.table)
             .values(columns)
             .returning();
-        return this.mapToEntity(row);
+        return this.mapToEntity(row, transformContext);
     }
     async insertMany(entities) {
-        const columns = entities.map((entity) => this.mapToInsertColumns(entity));
+        const transformContext = await this.getTransformContext();
+        const columns = await this.mapManyToInsertColumns(entities, transformContext);
         const rows = await this.session.insert(this.table).values(columns).returning();
-        return rows.map((row) => this.mapToEntity(row));
+        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 columns = this.mapToInsertColumns(entity);
-        const mappedUpdate = this.mapUpdate(update ?? entity);
+        const columns = await this.mapToInsertColumns(entity, transformContext);
+        const mappedUpdate = await this.mapUpdate(update ?? entity, transformContext);
         const [row] = await this.session
             .insert(this.table)
             .values(columns)
@@ -193,15 +204,16 @@ let EntityRepository = class EntityRepository {
             set: mappedUpdate
         })
             .returning();
-        return this.mapToEntity(row);
+        return this.mapToEntity(row, transformContext);
     }
     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 = entities.map((entity) => this.mapToColumns(entity));
-        const mappedUpdate = this.mapUpdate(update);
+        const columns = await this.mapManyToColumns(entities, transformContext);
+        const mappedUpdate = await this.mapUpdate(update, transformContext);
         const rows = await this.session
             .insert(this.table)
             .values(columns)
@@ -210,7 +222,7 @@ let EntityRepository = class EntityRepository {
             set: mappedUpdate
         })
             .returning();
-        return rows.map((row) => this.mapToEntity(row));
+        return this.mapManyToEntity(rows, transformContext);
     }
     async update(id, update) {
         const entity = await this.tryUpdate(id, update);
@@ -220,7 +232,8 @@ let EntityRepository = class EntityRepository {
         return entity;
     }
     async tryUpdate(id, update) {
-        const mappedUpdate = this.mapUpdate(update);
+        const transformContext = await this.getTransformContext();
+        const mappedUpdate = await this.mapUpdate(update, transformContext);
         const [row] = await this.session
             .update(this.table)
             .set(mappedUpdate)
@@ -229,7 +242,7 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return this.mapToEntity(row, transformContext);
     }
     async updateByQuery(query, update) {
         const entity = await this.tryUpdateByQuery(query, update);
@@ -239,7 +252,8 @@ let EntityRepository = class EntityRepository {
         return entity;
     }
     async tryUpdateByQuery(query, update) {
-        const mappedUpdate = this.mapUpdate(update);
+        const transformContext = await this.getTransformContext();
+        const mappedUpdate = await this.mapUpdate(update, transformContext);
         const idQuery = this.getIdLimitQuery(query);
         const [row] = await this.session
             .with(idQuery)
@@ -250,20 +264,21 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        return this.mapToEntity(row, transformContext);
     }
     async updateMany(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 mappedUpdate = this.mapUpdate(update);
+        const mappedUpdate = await this.mapUpdate(update, transformContext);
         const rows = await this.session
             .update(this.table)
             .set(mappedUpdate)
             .where(sqlQuery)
             .returning();
-        return rows.map((entity) => this.mapToEntity(entity));
+        return this.mapManyToEntity(rows, transformContext);
     }
     async delete(id, metadataUpdate) {
         const entity = await this.tryDelete(id, metadataUpdate);
@@ -284,7 +299,8 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        const transformContext = await this.getTransformContext();
+        return this.mapToEntity(row, transformContext);
     }
     async deleteByQuery(query, metadataUpdate) {
         const entity = await this.tryDeleteByQuery(query, metadataUpdate);
@@ -306,7 +322,8 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row);
+        const transformContext = await this.getTransformContext();
+        return this.mapToEntity(row, transformContext);
     }
     async deleteMany(ids, metadataUpdate) {
         return this.deleteManyByQuery(inArray(this.table.id, ids), metadataUpdate);
@@ -321,7 +338,8 @@ let EntityRepository = class EntityRepository {
         })
             .where(sqlQuery)
             .returning();
-        return rows.map((row) => this.mapToEntity(row));
+        const transformContext = await this.getTransformContext();
+        return this.mapManyToEntity(rows, transformContext);
     }
     async hardDelete(id) {
         const result = await this.tryHardDelete(id);
@@ -355,20 +373,35 @@ let EntityRepository = class EntityRepository {
     convertQuery(query) {
         return convertQuery(query, this.table, this.columnDefinitionsMap);
     }
-    mapToEntity(columns) {
-        const entries = this.columnDefinitions.map((def) => [def.objectPath, columns[def.name]]);
+    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) {
+            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
+        }
         const obj = fromDeepObjectEntries(entries);
         return Schema.parse(this.type, obj);
     }
-    mapToColumns(obj) {
+    async mapManyToColumns(objects, transformContext) {
+        return toArrayAsync(mapAsync(objects, async (obj) => this.mapToColumns(obj, transformContext)));
+    }
+    async mapToColumns(obj, transformContext) {
         const columns = {};
         for (const def of this.columnDefinitions) {
-            columns[def.name] = def.dereferenceObjectPath(obj);
+            const rawValue = def.dereferenceObjectPath(obj);
+            columns[def.name] = await def.toDatabase(rawValue, transformContext);
         }
         return columns;
     }
-    mapToInsertColumns(obj) {
-        const mapped = this.mapToColumns(obj);
+    async mapManyToInsertColumns(objects, transformContext) {
+        return toArrayAsync(mapAsync(objects, async (obj) => this.mapToInsertColumns(obj, transformContext)));
+    }
+    async mapToInsertColumns(obj, transformContext) {
+        const mapped = await this.mapToColumns(obj, transformContext);
         return {
             ...mapped,
             revision: 1,
@@ -376,14 +409,14 @@ let EntityRepository = class EntityRepository {
             createTimestamp: TRANSACTION_TIMESTAMP
         };
     }
-    mapUpdate(update) {
+    async mapUpdate(update, transformContext) {
         const mappedUpdate = {};
         for (const column of this.columnDefinitions) {
             const value = column.dereferenceObjectPath(update);
             if (isUndefined(value)) {
                 continue;
             }
-            mappedUpdate[column.name] = value;
+            mappedUpdate[column.name] = await column.toDatabase(value, transformContext);
         }
         return {
             ...mappedUpdate,
@@ -405,6 +438,15 @@ let EntityRepository = class EntityRepository {
         }
         return sql `${this.table.attributes} || '${JSON.stringify(attributes)}'::jsonb`;
     }
+    async getTransformContext() {
+        if (isUndefined(this.#transformContext)) {
+            assertDefined(this.#encryptionSecret, 'Missing database encryption secret');
+            this.#transformContext = importSymmetricKey('AES-GCM', 256, this.#encryptionSecret, false).then((encryptionKey) => ({ encryptionKey }));
+            const transformContext = await this.#transformContext;
+            this.#transformContext = transformContext;
+        }
+        return this.#transformContext;
+    }
 };
 EntityRepository = __decorate([
     Singleton({

package/orm/server/tokens.d.ts

@@ -0,0 +1 @@
+export declare const ENCRYPTION_SECRET: import("../../injector/token.js").InjectionToken<Uint8Array<ArrayBufferLike>, never>;

package/orm/server/tokens.js

@@ -0,0 +1,2 @@
+import { injectionToken } from '../../injector/token.js';
+export const ENCRYPTION_SECRET = injectionToken('EncryptionSecret');

package/orm/server/types.d.ts

@@ -0,0 +1,43 @@
+import type { BuildColumns, NotNull } from 'drizzle-orm';
+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 { Tagged } from '../../types/index.js';
+import type { OrmColumnReflectionData } from '../decorators.js';
+import type { EntityType } from '../entity.js';
+import type { ColumnBuilder, EmbeddedConfigTag } from '../types.js';
+export type ColumnDefinition = {
+    name: string;
+    objectPath: JsonPath;
+    type: PgColumnBuilder<any, any, any, any>;
+    reflectionData: OrmColumnReflectionData | undefined;
+    dereferenceObjectPath: (obj: Record) => any;
+    toDatabase: (value: unknown, context: TransformContext) => any;
+    fromDatabase: (value: unknown, context: TransformContext) => any;
+};
+export type TransformContext = {
+    encryptionKey?: CryptoKey;
+};
+type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, 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<{
+    name: TableName;
+    schema: S;
+    columns: BuildColumns<TableName, {
+        [P in Exclude<keyof InstanceType<T>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
+    } & UnionToIntersection<{
+        [P in keyof EmbeddedProperties<InstanceType<T>>]: EmbeddedColumns<InstanceType<T>[P], ColumnPrefix<InstanceType<T>[P]>>;
+    }[keyof EmbeddedProperties<InstanceType<T>>]>, 'pg'>;
+    dialect: 'pg';
+}>;
+export type EmbeddedProperties<T> = ConditionalPick<T, Tagged<unknown, EmbeddedConfigTag, {
+    prefix: any;
+}>>;
+export type EmbeddedColumns<T, Prefix extends string> = {
+    [P in keyof T as CamelCase<`${Prefix}${Extract<P, string>}`>]: Column<CamelCase<`${Prefix}${Extract<P, string>}`>, T[P]>;
+};
+export {};

package/orm/server/types.js

@@ -0,0 +1 @@
+export {};

package/orm/types.d.ts

@@ -25,5 +25,6 @@ export type DoublePrecision = Tagged<number, ColumnTypeTag, ReturnType<typeof do
 export type Boolean = Tagged<number, ColumnTypeTag, ReturnType<typeof boolean>>;
 export type NumericDate = Tagged<number, ColumnTypeTag, ReturnType<typeof date>>;
 export type Timestamp = Tagged<number, ColumnTypeTag, ReturnType<typeof timestamp>>;
-export type Bytea = Tagged<number, ColumnTypeTag, ReturnType<typeof bytea>>;
+export type Bytea = Tagged<Uint8Array, ColumnTypeTag, ReturnType<typeof bytea>>;
+export type Encrypted<T> = Tagged<T, ColumnTypeTag, ReturnType<typeof bytea>>;
 export { Array, Column, Embedded, Index, Integer, Json, NumericDate, PrimaryKey, References, Timestamp, Unique, Uuid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.55",
+  "version": "0.92.56",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"