@tstdl/base 0.93.1 → 0.93.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.1",
+  "version": "0.93.3",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -19,29 +19,18 @@
     "tsc:watch": "tsc --watch",
     "tsc-alias:watch": "tsc-alias --watch",
     "cleanup:dist": "rm -vf dist/test* && rm -vrf dist/tools/",
-    "generate:migration": "npm run generate:migration:document-management && npm run generate:migration:authentication && npm run generate:migration:mail && npm run generate:migration:queue && npm run generate:migration:key-value-store && npm run generate:migration:lock",
-    "generate:migration:document-management": "drizzle-kit generate --config dist/document-management/server/drizzle.config.js",
-    "generate:migration:authentication": "drizzle-kit generate --config dist/authentication/server/drizzle.config.js",
-    "generate:migration:mail": "drizzle-kit generate --config dist/mail/drizzle.config.js",
-    "generate:migration:queue": "drizzle-kit generate --config dist/queue/postgres/drizzle.config.js",
-    "generate:migration:key-value-store": "drizzle-kit generate --config dist/key-value-store/postgres/drizzle.config.js",
-    "generate:migration:lock": "drizzle-kit generate --config dist/lock/postgres/drizzle.config.js",
+    "generate:migration": "./scripts/manage-orm.sh generate",
     "generate:readmes": "deno run --allow-run=code2prompt --allow-read --allow-write=source --allow-net=generativelanguage.googleapis.com --allow-env=GEMINI_API_KEY generate-readmes.ts",
     "generate:readmes:new-only": "npm run generate:readmes -- --skip-existing",
     "generate:llms.md": "npm run build:dts && npm run cleanup:dist && ./scripts/generate-llms-docs.sh",
     "generate:context7-docs": "npm run build:dts && npm run cleanup:dist && ./scripts/generate-context7-docs.sh",
-    "copy:orm": "npm run copy:orm:document-management && npm run copy:orm:authentication && npm run copy:orm:mail && npm run copy:orm:queue && npm run copy:orm:key-value-store && npm run copy:orm:lock",
-    "copy:orm:document-management": "rm -rf ./dist/document-management/server/drizzle && cp -r ./source/document-management/server/drizzle ./dist/document-management/server/",
-    "copy:orm:authentication": "rm -rf ./dist/authentication/server/drizzle && cp -r ./source/authentication/server/drizzle ./dist/authentication/server/",
-    "copy:orm:mail": "rm -rf ./dist/mail/drizzle && cp -r ./source/mail/drizzle ./dist/mail/",
-    "copy:orm:queue": "rm -rf ./dist/queue/postgres/drizzle && cp -r ./source/queue/postgres/drizzle ./dist/queue/postgres/",
-    "copy:orm:key-value-store": "rm -rf ./dist/key-value-store/postgres/drizzle && cp -r ./source/key-value-store/postgres/drizzle ./dist/key-value-store/postgres/",
-    "copy:orm:lock": "rm -rf ./dist/lock/postgres/drizzle && cp -r ./source/lock/postgres/drizzle ./dist/lock/postgres/"
+    "copy:orm": "./scripts/manage-orm.sh copy"
   },
   "exports": {
     "./tsconfig.json": "./tsconfig.json",
     "./eslint.config.js": "./eslint.config.js",
     ".": "./index.js",
+    "./constants": "./constants.js",
     "./environment": "./environment.js",
     "./interfaces": "./interfaces.js",
     "./polyfills": "./polyfills.js",
@@ -52,6 +41,7 @@
     "./api/client": "./api/client/index.js",
     "./api/server": "./api/server/index.js",
     "./application": "./application/index.js",
+    "./audit": "./audit/index.js",
     "./authentication": "./authentication/index.js",
     "./authentication/server": "./authentication/server/index.js",
     "./browser": "./browser/index.js",
@@ -94,6 +84,8 @@
     "./object-storage": "./object-storage/index.js",
     "./openid-connect": "./openid-connect/index.js",
     "./orm": "./orm/index.js",
+    "./orm/schemas": "./orm/schemas/index.js",
+    "./orm/data-types": "./orm/data-types/index.js",
     "./orm/server": "./orm/server/index.js",
     "./password": "./password/index.js",
     "./pdf": "./pdf/index.js",
@@ -140,12 +132,12 @@
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
     "ts-pattern": "^5.8",
-    "type-fest": "4.37"
+    "type-fest": "^5.0"
   },
   "peerDependencies": {
     "@google-cloud/storage": "^7.17",
-    "@google/genai": "^1.19",
-    "@tstdl/angular": "^0.92",
+    "@google/genai": "^1.22",
+    "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",
@@ -154,7 +146,7 @@
     "file-type": "^21.0",
     "handlebars": "^4.7",
     "minio": "^8.0",
-    "mjml": "^4.15",
+    "mjml": "^4.16",
     "nodemailer": "^7.0",
     "pg": "^8.16",
     "playwright": "^1.55",
@@ -170,24 +162,23 @@
     }
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin": "5.3",
+    "@stylistic/eslint-plugin": "5.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.7",
-    "@types/minio": "7.1",
     "@types/mjml": "4.7",
     "@types/node": "24",
     "@types/nodemailer": "7.0",
     "@types/pg": "8.15",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",
-    "eslint": "9.35",
+    "eslint": "9.37",
     "globals": "16.4",
     "tsc-alias": "1.8",
     "typedoc-github-wiki-theme": "2.1",
-    "typedoc-plugin-markdown": "4.8",
+    "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.43"
+    "typescript-eslint": "8.45"
   },
   "overrides": {
     "drizzle-kit": {

package/queue/postgres/job.model.d.ts

@@ -1,12 +1,12 @@
-import { EntityWithoutMetadata, Integer, Json, Timestamp } from '../../orm/index.js';
+import { EntityWithoutMetadata, type Json, type Timestamp } from '../../orm/index.js';
 import type { ObjectLiteral } from '../../types/index.js';
 import type { Job } from '../queue.js';
 export declare class PostgresJob<T extends ObjectLiteral = ObjectLiteral> extends EntityWithoutMetadata implements Job<T> {
     queue: string;
     tag: string | null;
-    priority: Integer;
+    priority: number;
     enqueueTimestamp: Timestamp;
-    tries: Integer;
+    tries: number;
     lastDequeueTimestamp: Timestamp | null;
     data: Json<T>;
 }

package/queue/postgres/job.model.js

@@ -7,9 +7,8 @@ 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 { Index, Table } from '../../orm/decorators.js';
-import { EntityWithoutMetadata, Integer, Json, Timestamp } from '../../orm/index.js';
-import { StringProperty } from '../../schema/index.js';
+import { EntityWithoutMetadata, Index, JsonProperty, Table, TimestampProperty } from '../../orm/index.js';
+import { Integer, StringProperty } from '../../schema/index.js';
 let PostgresJob = class PostgresJob extends EntityWithoutMetadata {
     queue;
     tag;
@@ -32,7 +31,7 @@ __decorate([
     __metadata("design:type", Number)
 ], PostgresJob.prototype, "priority", void 0);
 __decorate([
-    Timestamp(),
+    TimestampProperty(),
     __metadata("design:type", Number)
 ], PostgresJob.prototype, "enqueueTimestamp", void 0);
 __decorate([
@@ -40,11 +39,11 @@ __decorate([
     __metadata("design:type", Number)
 ], PostgresJob.prototype, "tries", void 0);
 __decorate([
-    Timestamp({ nullable: true }),
+    TimestampProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], PostgresJob.prototype, "lastDequeueTimestamp", void 0);
 __decorate([
-    Json(),
+    JsonProperty(),
     __metadata("design:type", Object)
 ], PostgresJob.prototype, "data", void 0);
 PostgresJob = __decorate([

package/queue/postgres/queue.js

@@ -9,7 +9,7 @@ import { merge } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/index.js';
 import { inject, injectArgument, provide, Singleton } from '../../injector/index.js';
 import { MessageBus } from '../../message-bus/index.js';
-import { interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { interval, RANDOM_UUID_V4, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
 import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../orm/server/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
@@ -27,7 +27,7 @@ let PostgresQueue = class PostgresQueue extends Queue {
     processTimeout = (isString(this.#config) ? undefined : this.#config.processTimeout) ?? defaultQueueConfig.processTimeout;
     maxTries = (isString(this.#config) ? undefined : this.#config.maxTries) ?? defaultQueueConfig.maxTries;
     #takeNewUpdate = {
-        id: RANDOM_UUID,
+        id: RANDOM_UUID_V4,
         queue: this.#queueName,
         priority: sql `excluded.priority`,
         tag: sql `excluded.tag`,

package/queue/postgres/schemas.d.ts

@@ -1,3 +1,3 @@
 import { PostgresJob } from './job.model.js';
-export declare const queueSchema: import("../../orm/server/database-schema.js").DatabaseSchema<"queue">;
+export declare const queueSchema: import("../../orm/server/index.js").DatabaseSchema<"queue">;
 export declare const job: import("../../orm/server/types.js").PgTableFromType<typeof PostgresJob, "queue">;

package/queue/postgres/schemas.js

@@ -1,4 +1,4 @@
-import { databaseSchema } from '../../orm/server/database-schema.js';
+import { databaseSchema } from '../../orm/server/index.js';
 import { PostgresJob } from './job.model.js';
 export const queueSchema = databaseSchema('queue');
 export const job = queueSchema.getTable(PostgresJob);

package/supports.d.ts

@@ -4,3 +4,4 @@ export declare const supportsBuffer: boolean;
 export declare const supportsStructuredClone: boolean;
 export declare const supportsNotification: boolean;
 export declare const supportsColoredStdout: boolean;
+export declare const supportsColoredStderr: boolean;

package/supports.js

@@ -3,4 +3,5 @@ export const supportsBlob = (typeof Blob == 'function');
 export const supportsBuffer = (typeof Buffer == 'function');
 export const supportsStructuredClone = (typeof structuredClone == 'function');
 export const supportsNotification = (typeof Notification == 'function');
-export const supportsColoredStdout = (typeof process == 'object' && process.stdout.hasColors());
+export const supportsColoredStdout = (typeof process == 'object' && (process.stdout.hasColors?.() ?? false));
+export const supportsColoredStderr = (typeof process == 'object' && (process.stderr.hasColors?.() ?? false));

package/types/types.d.ts

@@ -117,7 +117,18 @@ export type OmitBy<T, V> = Omit<T, {
 /**
  * Normalize properties of a type that allow `undefined` to make them optional.
  */
-export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
+export type Optionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & Partial<PickBy<T, undefined>>>;
+export type OptionalizeDeep<T> = T extends BuiltIn ? T : T extends (infer U)[] ? OptionalizeDeep<U>[] : T extends readonly (infer U)[] ? readonly OptionalizeDeep<U>[] : Optionalize<{
+    [P in keyof T]: OptionalizeDeep<T[P]>;
+}>;
+export type OptionalizeNull<T extends object> = SimplifyObject<OmitBy<T, null> & Partial<PickBy<T, null>>>;
+export type OptionalizeNullDeep<T> = T extends BuiltIn ? T : T extends (infer U)[] ? OptionalizeNullDeep<U>[] : T extends readonly (infer U)[] ? readonly OptionalizeNullDeep<U>[] : OptionalizeNull<{
+    [P in keyof T]: OptionalizeNullDeep<T[P]>;
+}>;
+export type OptionalizeNullable<T extends object> = SimplifyObject<OmitBy<T, null | undefined> & Partial<PickBy<T, null | undefined>>>;
+export type OptionalizeNullableDeep<T> = T extends BuiltIn ? T : T extends readonly (infer U)[] ? OptionalizeNullableDeep<U>[] : T extends (infer U)[] ? OptionalizeNullableDeep<U>[] : OptionalizeNullable<{
+    [P in keyof T]: OptionalizeNullableDeep<T[P]>;
+}>;
 export type Unoptionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & {
     [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
 }>;

package/utils/object/object.d.ts

@@ -1,5 +1,5 @@
 import { type JsonPathInput } from '../../json-path/json-path.js';
-import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types/index.js';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, OptionalizeNull, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types/index.js';
 export declare function hasOwnProperty<T extends Record, K extends keyof UnionToIntersection<T>>(obj: T, key: K): obj is Extract<T, Partial<Record<K>>>;
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
@@ -22,7 +22,9 @@ export declare function filterObject<T extends ObjectLiteral, U extends T[keyof
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
 export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
 export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, undefined>>;
+export declare function filterNullishFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, null | undefined>>;
 export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<Optionalize<T>>;
+export declare function filterNullishObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<OptionalizeNull<Optionalize<T>>>;
 export declare function copyObjectProperties<T extends ObjectLiteral>(source: T, target: T): void;
 export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: U, bind: boolean): () => T[U];
 export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];

package/utils/object/object.js

@@ -2,7 +2,7 @@ import { JsonPath } from '../../json-path/json-path.js';
 import { filterAsync } from '../async-iterable-helpers/filter.js';
 import { mapAsync } from '../async-iterable-helpers/map.js';
 import { toArrayAsync } from '../async-iterable-helpers/to-array.js';
-import { isArray, isDefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
+import { isArray, isDefined, isNotNullOrUndefined, isObject, isSymbol, isUndefined } from '../type-guards.js';
 export function hasOwnProperty(obj, key) {
     return Object.hasOwn(obj, key);
 }
@@ -55,9 +55,15 @@ export async function filterObjectAsync(object, predicate) {
 export function filterUndefinedFromRecord(record) {
     return filterObject(record, isDefined);
 }
+export function filterNullishFromRecord(record) {
+    return filterObject(record, isNotNullOrUndefined);
+}
 export function filterUndefinedObjectProperties(object) {
     return filterObject(object, isDefined);
 }
+export function filterNullishObjectProperties(object) {
+    return filterObject(object, isNotNullOrUndefined);
+}
 export function copyObjectProperties(source, target) {
     for (const key of objectKeys(source)) {
         target[key] = source[key];

package/orm/server/drizzle/index.js

@@ -1 +0,0 @@
-export * from './schema-converter.js';

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

@@ -1,15 +0,0 @@
-import { type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
-import type { AbstractConstructor, Enumeration } from '../../../types/index.js';
-import type { EntityType } from '../../entity.js';
-import type { ColumnDefinition, ColumnDefinitionsMap, PgTableFromType } from '../types.js';
-type ConverterContext = {
-    type: AbstractConstructor;
-    property: string;
-};
-export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
-export declare function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
-export declare function getColumnDefinitionsMap(table: PgTableWithColumns<any>): ColumnDefinitionsMap;
-export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, fallbackSchemaName?: S): PgTableFromType<T, S>;
-export declare function registerEnum(enumeration: Enumeration, name: string): void;
-export declare function getPgEnum(schema: string | PgSchema, enumeration: Enumeration, context?: ConverterContext): PgEnum<[string, ...string[]]>;
-export {};

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

@@ -1,300 +0,0 @@
-import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
-import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
-import { MultiKeyMap } from '../../../data-structures/multi-key-map.js';
-import { tryGetEnumName } from '../../../enumeration/enumeration.js';
-import { NotSupportedError } from '../../../errors/not-supported.error.js';
-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';
-import { fromEntries, objectEntries } from '../../../utils/object/object.js';
-import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
-import { bytea, numericDate, timestamp } from '../../data-types/index.js';
-import { JsonSchema } from '../../schemas/json.js';
-import { NumericDateSchema } from '../../schemas/numeric-date.js';
-import { TimestampSchema } from '../../schemas/timestamp.js';
-import { UuidSchema } from '../../schemas/uuid.js';
-import { decryptBytes, encryptBytes } from '../encryption.js';
-import { convertQuery } from '../query-converter.js';
-const getDbSchema = memoizeSingle(pgSchema);
-export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
-const columnDefinitionsSymbol = Symbol('columnDefinitions');
-const columnDefinitionsMapSymbol = Symbol('columnDefinitionsMap');
-export function getColumnDefinitions(table) {
-    return table[columnDefinitionsSymbol];
-}
-export function getColumnDefinitionsMap(table) {
-    return table[columnDefinitionsMapSymbol];
-}
-export function _getDrizzleTableFromType(type, fallbackSchemaName) {
-    const metadata = reflectionRegistry.getMetadata(type);
-    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-    const tableReflectionDatas = [];
-    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
-        const tableReflectionData = currentMetadata.data.tryGet('orm');
-        if (isDefined(tableReflectionData)) {
-            tableReflectionDatas.push(tableReflectionData);
-        }
-    }
-    const mergedTableReflectionData = tableReflectionDatas.reduceRight((merged, data) => ({ ...merged, ...data }), {});
-    const tableReflectionData = tableReflectionDatas[0];
-    const schema = assertDefinedPass(mergedTableReflectionData.schema ?? fallbackSchemaName, 'Table schema not provided');
-    const tableName = tableReflectionData?.name ?? getDefaultTableName(type);
-    const dbSchema = getDbSchema(schema);
-    const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
-    const columnDefinitionsMap = new Map(columnDefinitions.map((column) => [column.objectPath.path, column]));
-    function getColumn(table, propertyName) {
-        return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
-    }
-    function buildIndex(table, data, columnName) {
-        const columns = (data.columns ?? [columnName]).map((columnValue) => {
-            assertDefined(columnValue, 'Missing column name for index.');
-            const [columnName, columnOrder] = isString(columnValue) ? [columnValue] : columnValue;
-            const order = columnOrder ?? data.order ?? 'asc';
-            let column = getColumn(table, columnName);
-            column = column[order]();
-            if (data.options?.nulls == 'first') {
-                column = column.nullsFirst();
-            }
-            else if (data.options?.nulls == 'last') {
-                column = column.nullsLast();
-            }
-            return column;
-        });
-        const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
-        if (isDefined(data.options?.where)) {
-            const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
-            builder = builder.where(query.inlineParams());
-        }
-        return builder;
-    }
-    function buildPrimaryKey(table) {
-        const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
-        return primaryKey({
-            name: mergedTableReflectionData.compundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: mergedTableReflectionData.compundPrimaryKeyNaming }),
-            columns,
-        });
-    }
-    const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
-    const skipPrimaryKey = primaryKeyColumnDefinitions.length > 1;
-    const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.buildType({ skipPrimaryKey })]);
-    const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (table) => [
-        ...((primaryKeyColumnDefinitions.length > 1)
-            ? [buildPrimaryKey(table)]
-            : []),
-        ...(columnDefinitions.map((columnDefinition) => {
-            const indexData = columnDefinition.reflectionData?.index;
-            if (isUndefined(indexData)) {
-                return undefined;
-            }
-            return buildIndex(table, indexData, columnDefinition.name);
-        }).filter(isDefined)),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => {
-            return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
-                const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
-                return foreignKey({
-                    name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
-                    columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
-                    foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
-                });
-            }) ?? [];
-        }),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
-            const columns = data.columns?.map((column) => getColumn(table, column));
-            let constraint = unique(data.options?.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
-            if (data.options?.nulls == 'not distinct') {
-                constraint = constraint.nullsNotDistinct();
-            }
-            return constraint;
-        }),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(table, data)),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table))),
-    ]);
-    drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
-    drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
-    return drizzleSchema;
-}
-function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '') {
-    const metadata = reflectionRegistry.getMetadata(type);
-    assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
-    const objectSchema = getObjectSchema(type);
-    const entries = objectEntries(objectSchema.properties).toSorted(compareByValueSelectionToOrder(['id', orderRest, 'metadata'], (item) => item[0])).flatMap(([property, schema]) => {
-        const columnReflectionData = metadata.properties.get(property)?.data.tryGet('orm');
-        const columnName = columnReflectionData?.name ?? toSnakeCase(property);
-        if ((schema instanceof ObjectSchema) && !(schema instanceof JsonSchema)) {
-            const propertyMetadata = reflectionRegistry.getMetadata(type)?.properties.get(property);
-            assertDefined(propertyMetadata, `Property "${property}" of type "${type.name}" does not have reflection metadata (path: ${path.toString()}).`);
-            const propertyPrefix = columnReflectionData?.embedded?.prefix;
-            const nestedPrefix = [prefix, isNull(propertyPrefix) ? '' : propertyPrefix ?? `${columnName}_`].join('');
-            return getPostgresColumnEntries(columnReflectionData?.embedded?.type ?? propertyMetadata.type, dbSchema, tableName, 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 await encryptBytes(bytes, context.encryptionKey);
-            }
-            : (value) => value;
-        const fromDatabase = encrypted
-            ? async (value, context) => {
-                const decrypted = await decryptBytes(value, context.encryptionKey);
-                return decodeText(decrypted);
-            }
-            : (value) => value;
-        const prefixedColumnName = [prefix, columnName].join('');
-        return [{
-                name: toCamelCase(prefixedColumnName),
-                objectPath,
-                reflectionData: columnReflectionData,
-                buildType: (options) => getPostgresColumn(tableName, toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
-                dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
-                toDatabase,
-                fromDatabase,
-            }];
-    });
-    return entries;
-}
-function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData, options, context) {
-    let nullable = false;
-    let array = false;
-    let baseSchema = propertySchema;
-    while (true) {
-        if ((baseSchema instanceof NullableSchema) || (baseSchema instanceof OptionalSchema)) {
-            nullable = true;
-            baseSchema = baseSchema.schema;
-        }
-        else if (baseSchema instanceof ArraySchema) {
-            array = true;
-            baseSchema = baseSchema.itemSchema;
-        }
-        else {
-            break;
-        }
-    }
-    let column = getPostgresBaseColumn(columnName, dbSchema, baseSchema, reflectionData, context);
-    if (array) {
-        column = column.array();
-    }
-    if (!nullable) {
-        column = column.notNull();
-    }
-    if (isDefined(reflectionData.unique)) {
-        column = column.unique(reflectionData.unique.options?.name ?? getUniqueName(tableName, [columnName], { naming: reflectionData.unique.options?.naming }), isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
-    }
-    if ((reflectionData.primaryKey == true) && (options.skipPrimaryKey != true)) {
-        column = column.primaryKey();
-    }
-    for (const { target, targetColumn } of reflectionData.references ?? []) {
-        column = column.references(() => {
-            const targetTable = getDrizzleTableFromType(target(), dbSchema.schemaName);
-            return targetTable[(targetColumn ?? 'id')];
-        });
-    }
-    if (isDefined(reflectionData.references)) {
-    }
-    return column;
-}
-function getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, context) {
-    if (schema instanceof DefaultSchema) {
-        const column = getPostgresBaseColumn(columnName, dbSchema, schema.schema, reflectionData, context);
-        return column.default(schema.defaultValue);
-    }
-    if (reflectionData.encrypted) {
-        return bytea(columnName);
-    }
-    if (schema instanceof UuidSchema) {
-        let column = uuid(columnName);
-        if (schema.defaultRandom) {
-            column = column.defaultRandom();
-        }
-        return column;
-    }
-    if (schema instanceof TimestampSchema) {
-        return timestamp(columnName);
-    }
-    if (schema instanceof NumericDateSchema) {
-        return numericDate(columnName);
-    }
-    if (schema instanceof NumberSchema) {
-        return schema.integer
-            ? integer(columnName)
-            : doublePrecision(columnName);
-    }
-    if (schema instanceof StringSchema) {
-        return text(columnName);
-    }
-    if (schema instanceof BooleanSchema) {
-        return boolean(columnName);
-    }
-    if (schema instanceof EnumerationSchema) {
-        const pgEnum = getPgEnum(dbSchema, schema.enumeration, context);
-        return pgEnum(columnName);
-    }
-    if (schema instanceof JsonSchema) {
-        return jsonb(columnName);
-    }
-    if (schema instanceof Uint8ArraySchema) {
-        return bytea(columnName);
-    }
-    throw new NotSupportedError(`Schema "${schema.constructor.name}" not supported on type "${context.type.name}" for property "${context.property}"`);
-}
-const enumNames = new Map();
-const enums = new MultiKeyMap();
-export function registerEnum(enumeration, name) {
-    enumNames.set(enumeration, toSnakeCase(name));
-}
-export function getPgEnum(schema, enumeration, context) {
-    const dbSchema = isString(schema) ? getDbSchema(schema) : schema;
-    const enumName = enumNames.get(enumeration) ?? tryGetEnumName(enumeration);
-    if (isUndefined(enumName)) {
-        const errorMessage = 'Enum is not registered. Please register it using `databaseSchema.getEnum(MyEnum)` before use.';
-        if (isDefined(context)) {
-            throw new Error(`${errorMessage} (type: ${context.type.name}, property: ${context.property})`);
-        }
-        throw new Error(errorMessage);
-    }
-    const values = (isArray(enumeration) ? enumeration : enumValues(enumeration))
-        .map((value) => value.toString());
-    const dbEnum = dbSchema.enum(toSnakeCase(enumName), values);
-    if (enums.has([dbSchema.schemaName, enumeration])) {
-        enums.set([dbSchema.schemaName, enumeration], dbEnum);
-    }
-    return dbEnum;
-}
-function getDefaultTableName(type) {
-    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
-}
-function getPrimaryKeyName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'pk', options);
-}
-function getIndexName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'idx', options);
-}
-function getUniqueName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'unique', options);
-}
-function getForeignKeyName(tableName, columns, options) {
-    return getIdentifier(tableName, columns, 'fkey', options);
-}
-function getIdentifier(tableName, columns, suffix, options) {
-    const identifier = `${getTablePrefix(tableName, options?.naming)}_${getColumnNames(columns).join('_')}_${suffix}`;
-    if (identifier.length > 63) {
-        if (options?.naming != 'abbreviated-table') {
-            return getIdentifier(tableName, columns, suffix, { naming: 'abbreviated-table' });
-        }
-        throw new Error(`Identifier "${identifier}" for table "${tableName}" is too long. Maximum length is 63 characters.`);
-    }
-    return identifier;
-}
-function getTablePrefix(tableName, naming) {
-    return (naming == 'abbreviated-table') ? tableName.split('_').map((part) => part[0]).join('') : tableName;
-}
-function getColumnNames(columns) {
-    return columns.map((column) => isString(column) ? column : column.name);
-}