@tstdl/base 0.92.54 → 0.92.56

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.54",
+  "version": "0.92.56",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -17,12 +17,14 @@
     "pub": "npm run build:production && rm -vf dist/test* && rm -vrf dist/tools/ && npm publish dist/",
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
-    "generate:orm": "npm run generate:drizzle:document-management && npm run generate:drizzle:authentication",
+    "generate:orm": "npm run generate:drizzle:document-management && npm run generate:drizzle:authentication && npm run generate:drizzle:mail",
     "generate:drizzle:document-management": "drizzle-kit generate --config dist/document-management/server/drizzle.config.js",
     "generate:drizzle:authentication": "drizzle-kit generate --config dist/authentication/server/drizzle.config.js",
-    "copy:orm": "npm run copy:document-management && npm run copy:authentication",
+    "generate:drizzle:mail": "drizzle-kit generate --config dist/mail/drizzle.config.js",
+    "copy:orm": "npm run copy:document-management && npm run copy:authentication && npm run copy:mail",
     "copy:document-management": "rm -rf ./dist/document-management/server/drizzle && cp -r ./source/document-management/server/drizzle ./dist/document-management/server/",
-    "copy:authentication": "rm -rf ./dist/authentication/server/drizzle && cp -r ./source/authentication/server/drizzle ./dist/authentication/server/"
+    "copy:authentication": "rm -rf ./dist/authentication/server/drizzle && cp -r ./source/authentication/server/drizzle ./dist/authentication/server/",
+    "copy:mail": "rm -rf ./dist/mail/drizzle && cp -r ./source/mail/drizzle ./dist/mail/"
   },
   "exports": {
     "./tsconfig.json": "./tsconfig.json",

package/mail/repositories/index.d.ts

@@ -1,2 +0,0 @@
-export * from './mail-log.repository.js';
-export * from './mongo/index.js';

package/mail/repositories/index.js

@@ -1,2 +0,0 @@
-export * from './mail-log.repository.js';
-export * from './mongo/index.js';

package/mail/repositories/mail-log.repository.d.ts

@@ -1,4 +0,0 @@
-import { EntityRepository } from '../../database/index.js';
-import type { MailLog } from '../models/mail-log.model.js';
-export declare abstract class MailLogRepository extends EntityRepository<MailLog> {
-}

package/mail/repositories/mail-log.repository.js

@@ -1,3 +0,0 @@
-import { EntityRepository } from '../../database/index.js';
-export class MailLogRepository extends EntityRepository {
-}

package/mail/repositories/mongo/index.d.ts

@@ -1 +0,0 @@
-export * from './mongo-mail-log.repository.js';

package/mail/repositories/mongo/index.js

@@ -1 +0,0 @@
-export * from './mongo-mail-log.repository.js';

package/mail/repositories/mongo/mongo-mail-log.repository.d.ts

@@ -1,16 +0,0 @@
-import type { CollectionArgument } from '../../../database/mongo/index.js';
-import { Collection, MongoEntityRepository } from '../../../database/mongo/index.js';
-import { resolveArgumentType } from '../../../injector/index.js';
-import type { Resolvable } from '../../../injector/interfaces.js';
-import { Logger } from '../../../logger/index.js';
-import type { MailLog } from '../../models/mail-log.model.js';
-export type MongoMailLogRepositoryConfig = {
-    config?: MongoMailLogRepositoryArgument;
-};
-export type MongoMailLogRepositoryArgument = CollectionArgument<MailLog>;
-export declare const mongoMailLogRepositoryConfig: MongoMailLogRepositoryConfig;
-export declare class MongoMailLogRepository extends MongoEntityRepository<MailLog> implements Resolvable<MongoMailLogRepositoryArgument> {
-    readonly [resolveArgumentType]: MongoMailLogRepositoryArgument;
-    constructor(collection: Collection<MailLog>, logger: Logger);
-}
-export declare function configureMongoMailLogRepository(config?: Partial<MongoMailLogRepositoryConfig>): void;

package/mail/repositories/mongo/mongo-mail-log.repository.js

@@ -1,33 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { Collection, MongoEntityRepository, noopTransformer } from '../../../database/mongo/index.js';
-import { ForwardArg, Singleton, resolveArgumentType } from '../../../injector/index.js';
-import { Logger } from '../../../logger/index.js';
-export const mongoMailLogRepositoryConfig = {};
-const indexes = [];
-let MongoMailLogRepository = class MongoMailLogRepository extends MongoEntityRepository {
-    constructor(collection, logger) {
-        super(collection, noopTransformer, { logger, indexes });
-    }
-};
-MongoMailLogRepository = __decorate([
-    Singleton({
-        defaultArgumentProvider: () => mongoMailLogRepositoryConfig.config
-    }),
-    __param(0, ForwardArg()),
-    __metadata("design:paramtypes", [Collection, Logger])
-], MongoMailLogRepository);
-export { MongoMailLogRepository };
-export function configureMongoMailLogRepository(config = {}) {
-    mongoMailLogRepositoryConfig.config = config.config ?? mongoMailLogRepositoryConfig.config;
-}