@tstdl/base 0.93.3 → 0.93.4

package/ai/ai.service.d.ts

@@ -36,7 +36,7 @@ export declare class AiServiceOptions {
     };
     /**
      * The default model to use for generation requests.
-     * @default 'gemini-2.5-flash-lite'
+     * @default 'small'
      */
     defaultModel?: AiModel;
 }
@@ -133,6 +133,7 @@ export declare class AiService implements Resolvable<AiServiceArgument> {
     private convertContent;
     private convertFunctions;
     private convertGoogleContent;
+    private mapModel;
 }
 /**
  * Merges an array of streaming generation results into a single, consolidated result.

package/ai/ai.service.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var _a;
 var AiService_1;
 import { FinishReason, FunctionCallingConfigMode as GoogleFunctionCallingMode, GoogleGenAI } from '@google/genai';
+import { match } from 'ts-pattern';
 import { CancellationSignal } from '../cancellation/index.js';
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
@@ -39,7 +40,7 @@ export class AiServiceOptions {
     vertex;
     /**
      * The default model to use for generation requests.
-     * @default 'gemini-2.5-flash-lite'
+     * @default 'small'
      */
     defaultModel;
 }
@@ -80,7 +81,7 @@ let AiService = AiService_1 = class AiService {
     /**
      * The default AI model to use for requests if not specified otherwise.
      */
-    defaultModel = this.#options.defaultModel ?? 'gemini-2.5-flash-lite';
+    defaultModel = this.#options.defaultModel ?? 'gemini-flash-lite-latest';
     /**
      * Creates a new {@link AiSession} for managing conversational history.
      */
@@ -202,7 +203,7 @@ let AiService = AiService_1 = class AiService {
                 thinkingBudget: request.generationOptions?.thinkingBudget,
             },
         };
-        const model = request.model ?? this.defaultModel;
+        const model = this.mapModel(request.model);
         const maxModelTokens = await this.getModelOutputTokenLimit(model);
         const maxTotalOutputTokens = request.generationOptions?.maxOutputTokens ?? maxModelTokens;
         const inputContent = this.convertContents(request.contents);
@@ -427,6 +428,13 @@ let AiService = AiService_1 = class AiService {
                     .filter(isNotNull),
         };
     }
+    mapModel(model) {
+        return match(model)
+            .with('small', () => 'gemini-flash-lite-latest')
+            .with('medium', () => 'gemini-flash-latest')
+            .with('large', () => 'gemini-2.5-pro')
+            .otherwise(() => model ?? this.defaultModel);
+    }
 };
 AiService = AiService_1 = __decorate([
     Singleton()

package/ai/types.d.ts

@@ -113,8 +113,10 @@ export type FunctionCallingMode = 'auto' | 'force' | 'none';
 export type FinishReason = 'stop' | 'maxTokens' | 'unknown';
 /**
  * The specific AI model to use for a request.
+ *
+ * Aliases `small`, `medium`, and `large` map to models that change over time.
  */
-export type AiModel = LiteralUnion<'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite', string>;
+export type AiModel = LiteralUnion<'small' | 'medium' | 'large' | 'gemini-flash-latest' | 'gemini-flash-lite-latest' | 'gemini-2.5-pro' | 'gemini-2.5-flash' | 'gemini-2.5-flash-lite', string>;
 /**
  * Options to control the generation process.
  */

package/document-management/models/document-validation-execution.model.js

@@ -70,7 +70,8 @@ __decorate([
 ], DocumentValidationExecution.prototype, "completedAt", void 0);
 DocumentValidationExecution = __decorate([
     DocumentManagementTable({ name: 'validation_execution' }),
-    Unique(['tenantId', 'id']),
+    Unique(['tenantId', 'id']) // required for foreign key of DocumentValidationExecutionRelatedDocument
+    ,
     Unique(['tenantId', 'workflowId', 'definitionId']),
     ForeignKey(() => DocumentWorkflow, ['tenantId', 'workflowId'], ['tenantId', 'id'])
 ], DocumentValidationExecution);

package/document-management/server/services/document-management-ai.service.js

@@ -79,9 +79,9 @@ import { DocumentFileService } from './document-file.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
 import { DocumentTagService } from './document-tag.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
-const CLASSIFY_MODEL = 'gemini-2.5-flash-lite';
-const EXTRACT_MODEL = 'gemini-2.5-flash';
-const ASSIGN_MODEL = 'gemini-2.5-flash-lite';
+const CLASSIFY_MODEL = 'small';
+const EXTRACT_MODEL = 'medium';
+const ASSIGN_MODEL = 'small';
 let DocumentManagementAiService = DocumentManagementAiService_1 = class DocumentManagementAiService {
     #documentCollectionService = inject(DocumentCollectionService);
     #documentTagService = inject(DocumentTagService);

package/document-management/server/validators/ai-validation-executor.d.ts

@@ -4,8 +4,7 @@ import type { SchemaTestable } from '../../../schema/schema.js';
 import { DocumentValidationExecutor, type DocumentValidationExecutorContext, type DocumentValidationExecutorResult } from './validator.js';
 export declare const AiValidationDifficulty: {
     readonly Easy: "easy";
-    readonly MediumLow: "medium-low";
-    readonly MediumHigh: "medium-high";
+    readonly Medium: "medium";
     readonly Hard: "hard";
 };
 export type AiValidationDifficulty = EnumType<typeof AiValidationDifficulty>;
@@ -13,6 +12,7 @@ export declare abstract class AiValidationExecutor<R> extends DocumentValidation
     protected readonly aiService: AiService;
     abstract readonly schema: SchemaTestable<R>;
     abstract readonly difficulty: AiValidationDifficulty;
+    abstract readonly thinking: boolean;
     execute(context: DocumentValidationExecutorContext): Promise<DocumentValidationExecutorResult>;
     abstract getPrompt(context: DocumentValidationExecutorContext): string | Promise<string>;
     abstract getResult(output: R): DocumentValidationExecutorResult | Promise<DocumentValidationExecutorResult>;

package/document-management/server/validators/ai-validation-executor.js

@@ -12,8 +12,7 @@ import { match } from 'ts-pattern';
 import { DocumentValidationExecutor } from './validator.js';
 export const AiValidationDifficulty = defineEnum('AiValidationDifficulty', {
     Easy: 'easy',
-    MediumLow: 'medium-low',
-    MediumHigh: 'medium-high',
+    Medium: 'medium',
     Hard: 'hard',
 });
 let AiValidationExecutor = class AiValidationExecutor extends DocumentValidationExecutor {
@@ -21,11 +20,11 @@ let AiValidationExecutor = class AiValidationExecutor extends DocumentValidation
     async execute(context) {
         const validationPrompt = await this.getPrompt(context);
         const model = match(this.difficulty)
-            .with('easy', () => 'gemini-2.5-flash-lite')
-            .with('medium-low', () => 'gemini-2.5-flash')
-            .with('medium-high', () => 'gemini-2.5-flash')
-            .with('hard', () => 'gemini-2.5-pro')
+            .with('easy', () => 'small')
+            .with('medium', () => 'medium')
+            .with('hard', () => 'large')
             .exhaustive();
+        const thinkingBudget = this.thinking ? -1 : 0;
         const prompt = `Deine Aufgabe ist es ein Dokument zu validieren.
 
 Validierungsaufgabe:
@@ -33,6 +32,7 @@ ${validationPrompt}`;
         const generation = await this.aiService.generate({
             model,
             generationOptions: {
+                thinkingBudget,
                 temperature: 0.2,
                 topK: 20,
             },

package/document-management/server/validators/single-document-validation-executor.d.ts

@@ -6,7 +6,8 @@ export declare class SingleDocumentValidationExecutor extends AiValidationExecut
     reason?: string;
 }> {
     readonly identifier = "single-document";
-    readonly difficulty: "medium-low";
+    readonly difficulty: "medium";
+    readonly thinking = true;
     schema: import("../../../schema/index.js").ObjectSchema<{
         hasMultipleDocuments: boolean;
         reason?: string | undefined;

package/document-management/server/validators/single-document-validation-executor.js

@@ -3,13 +3,14 @@ import { DocumentValidationResultStatus } from '../../models/document-validation
 import { AiValidationDifficulty, AiValidationExecutor } from './ai-validation-executor.js';
 export class SingleDocumentValidationExecutor extends AiValidationExecutor {
     identifier = 'single-document';
-    difficulty = AiValidationDifficulty.MediumLow;
+    difficulty = AiValidationDifficulty.Medium;
+    thinking = true;
     schema = object({
         hasMultipleDocuments: boolean(),
         reason: optional(string()),
     });
     getPrompt() {
-        return 'Überprüfe ob das Dokument aus mehreren Dokumenten zusammengesetzt ist. Falls ja, begründe in wenigen Worten. Antworte auf deutsch.';
+        return 'Überprüfe ob das Dokument aus mehreren einzelnen Dokumenten zusammengesetzt ist. Falls ja, begründe in wenigen Worten. Antworte auf deutsch.';
     }
     getResult(output) {
         if (output.hasMultipleDocuments) {

package/examples/document-management/main.js

@@ -18,6 +18,7 @@ import { DocumentManagementService } from '../../document-management/server/serv
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
 import { Injector, Singleton } from '../../injector/index.js';
 import { inject, injectManyAsync, runInInjectionContext } from '../../injector/inject.js';
+import { PrettyPrintLogFormatter, provideConsoleLogTransport } from '../../logger/index.js';
 import { configureLocalMessageBus } from '../../message-bus/index.js';
 import { WebServerModule } from '../../module/index.js';
 import { configureS3ObjectStorage } from '../../object-storage/index.js';
@@ -157,4 +158,5 @@ Application.run('DocumentManagementTest', [
     provideInitializer(bootstrap),
     provideModule(main, WebServerModule),
     provideSignalHandler(),
+    provideConsoleLogTransport(PrettyPrintLogFormatter),
 ]);

package/orm/server/drizzle/index.js

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

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,300 @@
+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);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.3",
+  "version": "0.93.4",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -132,11 +132,11 @@
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
     "ts-pattern": "^5.8",
-    "type-fest": "^5.0"
+    "type-fest": "^5.1"
   },
   "peerDependencies": {
     "@google-cloud/storage": "^7.17",
-    "@google/genai": "^1.22",
+    "@google/genai": "^1.24",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
@@ -149,7 +149,7 @@
     "mjml": "^4.16",
     "nodemailer": "^7.0",
     "pg": "^8.16",
-    "playwright": "^1.55",
+    "playwright": "^1.56",
     "preact": "^10.27",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
@@ -178,7 +178,7 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.45"
+    "typescript-eslint": "8.46"
   },
   "overrides": {
     "drizzle-kit": {

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

@@ -1,408 +0,0 @@
-import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
-import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, pgSchema, primaryKey, text, unique, uniqueIndex, uuid, type ExtraConfigColumn, type PgColumn, type PgColumnBuilder, type PgEnum, type PgSchema, type PgTableWithColumns } 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, type TypeMetadata } from '#/reflection/registry.js';
-import { ArraySchema, BooleanSchema, DefaultSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema, Uint8ArraySchema, type Record, type Schema } from '#/schema/index.js';
-import type { AbstractConstructor, Enumeration, EnumerationObject, Type } from '#/types/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 type { IndexReflectionData, OrmColumnReflectionData, OrmTableReflectionData } from '../../decorators.js';
-import type { EntityType } from '../../entity.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';
-import type { BuildTypeOptions, ColumnDefinition, ColumnDefinitionsMap, PgTableFromType, TransformContext } from '../types.js';
-
-type ConverterContext = { type: AbstractConstructor, property: string };
-
-const getDbSchema = memoizeSingle(pgSchema);
-
-export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
-
-const columnDefinitionsSymbol = Symbol('columnDefinitions');
-const columnDefinitionsMapSymbol = Symbol('columnDefinitionsMap');
-
-export function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[] {
-  return (table as PgTableWithColumns<any> & { [columnDefinitionsSymbol]: ColumnDefinition[] })[columnDefinitionsSymbol];
-}
-
-export function getColumnDefinitionsMap(table: PgTableWithColumns<any>): ColumnDefinitionsMap {
-  return (table as PgTableWithColumns<any> & { [columnDefinitionsMapSymbol]: ColumnDefinitionsMap })[columnDefinitionsMapSymbol];
-}
-
-export function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, fallbackSchemaName?: S): PgTableFromType<T, S> {
-  const metadata = reflectionRegistry.getMetadata(type);
-  assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-
-  const tableReflectionDatas: OrmTableReflectionData[] = [];
-
-  for (let currentMetadata: TypeMetadata | undefined = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
-    const tableReflectionData = currentMetadata.data.tryGet<OrmTableReflectionData>('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: Record<string, ExtraConfigColumn>, propertyName: string): ExtraConfigColumn {
-    return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
-  }
-
-  function buildIndex(table: Record<string, ExtraConfigColumn>, data: IndexReflectionData, columnName?: string) {
-    const columns = (data.columns ?? [columnName]).map((columnValue) => {
-      assertDefined(columnValue, 'Missing column name for index.');
-
-      const [columnName, columnOrder] = isString(columnValue) ? [columnValue] as const : columnValue;
-      const order = columnOrder ?? data.order ?? 'asc';
-
-      let column = getColumn(table, columnName);
-      column = column[order]() as ExtraConfigColumn;
-
-      if (data.options?.nulls == 'first') {
-        column = column.nullsFirst() as ExtraConfigColumn;
-      }
-      else if (data.options?.nulls == 'last') {
-        column = column.nullsLast() as ExtraConfigColumn;
-      }
-
-      return column;
-    }) as [ExtraConfigColumn, ...ExtraConfigColumn[]];
-
-    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 as PgTableWithColumns<any> as PgTableFromType<EntityType<any>>), table as PgTableWithColumns<any> as PgTableFromType, columnDefinitionsMap);
-      builder = builder.where(query.inlineParams());
-    }
-
-    return builder;
-  }
-
-  function buildPrimaryKey(table: Record<string, ExtraConfigColumn>) {
-    const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name)) as unknown as [PgColumn, ...PgColumn[]];
-
-    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) as any,
-    (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)) as [ExtraConfigColumn, ...ExtraConfigColumn[]],
-            foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable as any as Record<string, ExtraConfigColumn>, column)) as [ExtraConfigColumn, ...ExtraConfigColumn[]],
-          });
-        }) ?? [];
-      }),
-      ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
-        const columns = data.columns?.map((column) => getColumn(table, column)) as [ExtraConfigColumn, ...ExtraConfigColumn[]];
-
-        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 as PgTableWithColumns<any> as PgTableFromType<EntityType<any>>))),
-    ]
-  );
-
-  (drizzleSchema as Record)[columnDefinitionsSymbol] = columnDefinitions;
-  (drizzleSchema as Record)[columnDefinitionsMapSymbol] = columnDefinitionsMap;
-
-  return drizzleSchema as any as PgTableFromType<T, S>;
-}
-
-function getPostgresColumnEntries(type: AbstractConstructor, dbSchema: PgSchema, tableName: string, path = new JsonPath({ dollar: false }), prefix: string = ''): ColumnDefinition[] {
-  const metadata = reflectionRegistry.getMetadata(type);
-  assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
-
-  const objectSchema = getObjectSchema<Record<string>>(type);
-
-  const entries = objectEntries(objectSchema.properties).toSorted(compareByValueSelectionToOrder(['id', orderRest, 'metadata'], (item) => item[0])).flatMap(([property, schema]): ColumnDefinition[] => {
-    const columnReflectionData = metadata.properties.get(property)?.data.tryGet<OrmColumnReflectionData>('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: unknown, context: TransformContext) => {
-        const bytes = encodeUtf8(value as string);
-        return await encryptBytes(bytes, context.encryptionKey!);
-      }
-      : (value: unknown) => value;
-
-    const fromDatabase = encrypted
-      ? async (value: unknown, context: TransformContext) => {
-        const decrypted = await decryptBytes(value as Uint8Array, context.encryptionKey!);
-        return decodeText(decrypted);
-      }
-      : (value: unknown) => value;
-
-    const prefixedColumnName = [prefix, columnName].join('');
-
-    return [{
-      name: toCamelCase(prefixedColumnName),
-      objectPath,
-      reflectionData: columnReflectionData,
-      buildType: (options: BuildTypeOptions) => getPostgresColumn(tableName, toSnakeCase(prefixedColumnName), dbSchema, schema, columnReflectionData ?? {}, options, { type, property }),
-      dereferenceObjectPath: compileDereferencer(objectPath, { optional: true }),
-      toDatabase,
-      fromDatabase,
-    }];
-  });
-
-  return entries;
-}
-
-function getPostgresColumn(tableName: string, columnName: string, dbSchema: PgSchema, propertySchema: Schema, reflectionData: OrmColumnReflectionData, options: BuildTypeOptions, context: ConverterContext): PgColumnBuilder<any, any, any, any> {
-  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') as keyof PgTableFromType] as PgColumn;
-    });
-  }
-
-  if (isDefined(reflectionData.references)) {
-  }
-
-  return column;
-}
-
-function getPostgresBaseColumn(columnName: string, dbSchema: PgSchema, schema: Schema, reflectionData: OrmColumnReflectionData, context: ConverterContext): PgColumnBuilder<any, any, any, any> {
-  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<Enumeration, string>();
-const enums = new MultiKeyMap<[string, Enumeration], PgEnum<[string, ...string[]]>>();
-
-export function registerEnum(enumeration: Enumeration, name: string): void {
-  enumNames.set(enumeration, toSnakeCase(name));
-}
-
-export function getPgEnum(schema: string | PgSchema, enumeration: Enumeration, context?: ConverterContext): PgEnum<[string, ...string[]]> {
-  const dbSchema = isString(schema) ? getDbSchema(schema) : schema;
-  const enumName = enumNames.get(enumeration) ?? tryGetEnumName(enumeration as EnumerationObject);
-
-  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()) as [string, ...string[]];
-
-  const dbEnum = dbSchema.enum(toSnakeCase(enumName), values);
-
-  if (enums.has([dbSchema.schemaName, enumeration])) {
-    enums.set([dbSchema.schemaName, enumeration], dbEnum);
-  }
-
-  return dbEnum;
-}
-
-function getDefaultTableName(type: Type & Partial<Pick<EntityType, 'entityName'>>): string {
-  return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
-}
-
-function getPrimaryKeyName(tableName: string, columns: (string | PgColumn)[], options?: { naming?: 'abbreviated-table' }) {
-  return getIdentifier(tableName, columns, 'pk', options);
-}
-
-function getIndexName(tableName: string, columns: (string | PgColumn)[], options?: { naming?: 'abbreviated-table' }) {
-  return getIdentifier(tableName, columns, 'idx', options);
-}
-
-function getUniqueName(tableName: string, columns: (string | PgColumn)[], options?: { naming?: 'abbreviated-table' }) {
-  return getIdentifier(tableName, columns, 'unique', options);
-}
-
-function getForeignKeyName(tableName: string, columns: (string | PgColumn)[], options?: { naming?: 'abbreviated-table' }) {
-  return getIdentifier(tableName, columns, 'fkey', options);
-}
-
-function getIdentifier(tableName: string, columns: (string | PgColumn)[], suffix: string, options?: { naming?: 'abbreviated-table' }): string {
-  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: string, naming?: 'abbreviated-table'): string {
-  return (naming == 'abbreviated-table') ? tableName.split('_').map((part) => part[0]).join('') : tableName;
-}
-
-function getColumnNames(columns: (string | PgColumn)[]): string[] {
-  return columns.map((column) => isString(column) ? column : column.name);
-}