@tstdl/base 0.93.61 → 0.93.64

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

@@ -56,9 +56,9 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
             throw new BadRequestError('Document has no type');
         }
         const workflow = await this.#documentWorkflowService.initiateWorkflow(document.tenantId, documentId, DocumentWorkflowStep.Validation);
-        const typeValidations = await this.#documentTypeValidationService.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, typeId: document.typeId });
+        const typeValidations = await this.#documentTypeValidationService.loadManyByQuery({ tenantId, typeId: document.typeId });
         for (const typeValidation of typeValidations) {
-            const validationDefinition = await this.#validationDefinitionService.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: typeValidation.validationId });
+            const validationDefinition = await this.#validationDefinitionService.loadByQuery({ tenantId, id: typeValidation.validationId });
             const execution = await this.#validationExecutionService.insert({
                 tenantId: document.tenantId,
                 definitionId: validationDefinition.id,
@@ -95,15 +95,15 @@ let DocumentValidationService = DocumentValidationService_1 = class DocumentVali
         }
         const [documentCollections, documentTypeProperties, type] = await Promise.all([
             this.#documentCollectionAssignmentRepository.loadManyByQuery({ tenantId, documentId: document.id }),
-            this.#documentTypePropertyService.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, typeId: document.typeId }),
-            this.#documentTypeService.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: document.typeId }),
+            this.#documentTypePropertyService.loadManyByQuery({ tenantId, typeId: document.typeId }),
+            this.#documentTypeService.loadByQuery({ tenantId, id: document.typeId }),
         ]);
         const documentCollectionIds = getEntityIds(documentCollections);
         const documentPropertyIds = getEntityIds(documentTypeProperties);
         const [collections, category, properties, propertyValues] = await Promise.all([
             this.#documentManagementService.loadManyByQuery({ tenantId, id: { $in: documentCollectionIds } }),
-            this.#documentCategoryService.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: type.categoryId }),
-            this.#documentPropertyService.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, id: { $in: documentPropertyIds } }),
+            this.#documentCategoryService.loadByQuery({ tenantId, id: type.categoryId }),
+            this.#documentPropertyService.loadManyByQuery({ tenantId, id: { $in: documentPropertyIds } }),
             this.#documentPropertyValueService.loadManyByQuery({ tenantId, documentId: document.id }),
         ]);
         return {

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

@@ -16,8 +16,8 @@ import { toArray } from '../../../utils/array/index.js';
 import { objectKeys } from '../../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../../utils/stream/from-promise.js';
 import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
-import { isDefined, isNotReadableStream, isNotUint8Array, isString, isUndefined } from '../../../utils/type-guards.js';
-import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentType, DocumentWorkflowStep } from '../../models/index.js';
+import { isDefined, isNotReadableStream, isNotUint8Array, isUndefined } from '../../../utils/type-guards.js';
+import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentWorkflowStep } from '../../models/index.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentFileService } from './document-file.service.js';
 import { DocumentManagementObservationService } from './document-management-observation.service.js';
@@ -33,7 +33,6 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     #workflowService = injectTransactional(DocumentWorkflowService);
     #documentPropertyService = injectTransactional(DocumentPropertyService);
     #collectionService = injectTransactional(DocumentCollectionService);
-    #documentTypeRepository = injectRepository(DocumentType);
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #observationService = inject(DocumentManagementObservationService);
@@ -42,10 +41,6 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     async create(tenantId, { typeId, title, subtitle, date, summary, tags, approval, comment, originalFileName, assignment, properties, metadata }, contentSource, { createUserId }) {
         const document = await this.transaction(async (tx) => {
             const isUpload = isNotUint8Array(contentSource) && isNotReadableStream(contentSource);
-            if (isString(typeId)) {
-                // verify that the type exists for the tenant
-                await this.#documentTypeRepository.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: typeId });
-            }
             const document = await this.repository.withTransaction(tx).insert({
                 tenantId,
                 typeId: typeId ?? null,

package/document-management/service-models/document-management.view-model.d.ts

@@ -40,7 +40,7 @@ export declare class DocumentRequestView extends DocumentRequest {
 }
 export declare class DocumentPropertyView implements TypedOmit<DocumentProperty, 'metadata'> {
     id: string;
-    tenantId: string | null;
+    tenantId: string;
     label: string;
     dataType: DocumentPropertyDataType;
     typeIds: string[];

package/document-management/service-models/document-management.view-model.js

@@ -144,7 +144,7 @@ __decorate([
 ], DocumentPropertyView.prototype, "id", void 0);
 __decorate([
     StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
+    __metadata("design:type", String)
 ], DocumentPropertyView.prototype, "tenantId", void 0);
 __decorate([
     StringProperty(),

package/document-management/service-models/document.service-model.d.ts

@@ -20,10 +20,10 @@ export declare const updateDocumentCollectionsParametersSchema: import("../../sc
 }>;
 export declare const createDocumentParametersSchema: import("../../schema/index.js").ObjectSchema<{
     date?: import("../../orm/index.js").NumericDate | null | undefined;
+    summary?: string | null | undefined;
     title?: string | null | undefined;
     typeId?: import("../../orm/index.js").Uuid | null | undefined;
     subtitle?: string | null | undefined;
-    summary?: string | null | undefined;
     comment?: string | null | undefined;
     approval?: import("../models/document.model.js").DocumentApproval | undefined;
     originalFileName?: string | null | undefined;
@@ -97,7 +97,7 @@ export declare const createDocumentRequestsTemplateParametersSchema: import("../
 export declare const updateDocumentRequestsTemplateParametersSchema: import("../../schema/index.js").ObjectSchema<{
     id: import("../../orm/index.js").IsPrimaryKey<import("../../orm/index.js").HasDefault<import("../../orm/index.js").Uuid>>;
     description?: string | null | undefined;
-    tenantId?: string | null | undefined;
+    tenantId?: import("../../orm/index.js").Uuid | undefined;
     label?: string | undefined;
     metadata?: Partial<{
         attributes: import("../../orm/index.js").HasDefault<import("../../orm/index.js").Json<import("../../orm/index.js").EntityMetadataAttributes>>;
@@ -126,7 +126,7 @@ export declare const createDocumentRequestTemplateParametersSchema: import("../.
 }>;
 export declare const updateDocumentRequestTemplateParametersSchema: import("../../schema/index.js").ObjectSchema<{
     id: import("../../orm/index.js").IsPrimaryKey<import("../../orm/index.js").HasDefault<import("../../orm/index.js").Uuid>>;
-    tenantId?: string | null | undefined;
+    tenantId?: import("../../orm/index.js").Uuid | undefined;
     typeId?: import("../../orm/index.js").Uuid | undefined;
     comment?: string | null | undefined;
     metadata?: Partial<{
@@ -181,8 +181,8 @@ export declare const setDocumentPropertiesParametersSchema: import("../../schema
     documentId: string;
 }>;
 export declare const createDocumentCategoryParametersSchema: import("../../schema/index.js").ObjectSchema<{
-    parentId: import("../../orm/index.js").Uuid | null;
     label: string;
+    parentId: import("../../orm/index.js").Uuid | null;
     metadata?: Partial<{
         attributes: import("../../orm/index.js").HasDefault<import("../../orm/index.js").Json<import("../../orm/index.js").EntityMetadataAttributes>>;
     }> | undefined;

package/document-management/service-models/enriched/enriched-document-category.view.d.ts

@@ -6,7 +6,7 @@ import type { EnrichedDocument } from './enriched-document.view.js';
 export declare class EnrichedDocumentCategory implements TypedOmit<DocumentCategory, 'parentId' | 'metadata'> {
     #private;
     readonly id: string;
-    readonly tenantId: string | null;
+    readonly tenantId: string;
     readonly label: string;
     readonly parent: EnrichedDocumentCategory | null;
     readonly helper: {

package/document-management/service-models/enriched/enriched-document-type.view.d.ts

@@ -6,7 +6,7 @@ import type { EnrichedDocumentManagementData } from './enriched-document-managem
 export declare class EnrichedDocumentType implements TypedOmit<DocumentType, 'categoryId' | 'metadata'> {
     #private;
     readonly id: string;
-    readonly tenantId: string | null;
+    readonly tenantId: string;
     readonly label: string;
     readonly category: EnrichedDocumentCategory;
     readonly helper: {

package/examples/document-management/main.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import '../../polyfills.js';
+import { configureGenkit } from '../../ai/genkit/module.js';
 import { configureAiService } from '../../ai/index.js';
 import { MockApiRequestTokenProvider } from '../../api/server/api-request-token.provider.js';
 import { configureApiServer } from '../../api/server/module.js';
@@ -88,6 +89,11 @@ async function bootstrap() {
     configurePostgresQueue();
     configureLocalMessageBus();
     configureDefaultSignalsImplementation();
+    configureGenkit({
+        gemini: {
+            apiKey: config.ai.apiKey,
+        },
+    });
     configureOrm({
         connection: {
             host: config.database.host,

package/json-path/json-path.js

@@ -1,7 +1,7 @@
 import { isIterable } from '../utils/iterable-helpers/is-iterable.js';
 import { assertDefinedPass, isArray, isDefined, isString, isSymbol, isUndefined } from '../utils/type-guards.js';
 const numberPattern = /^\d+$/u;
-const parsePattern = /(?:(?:^|\.)(?<dot>[^.[]+))|(?<root>^\$)|\[(?:(?:'(?<bracket>.+?)')|(?<index>\d+)|(?:Symbol\((?<symbol>.*)\)))\]|(?<error>.+?)/ug;
+const parsePattern = /(?:(?:^|\.)(?<dot>[^.[]+))|(?<root>^\$)|\[(?:(?:['"](?<bracket>.+?)['"])|(?<index>\d+)|(?:Symbol\((?<symbol>.*)\)))\]|(?<error>.+?)/ug;
 export class JsonPath {
     _options;
     _path;

package/orm/decorators.d.ts

@@ -63,10 +63,8 @@ export type OrmColumnReflectionData = {
         type: AbstractConstructor;
         prefix?: string | null;
     };
-    references?: {
-        target: () => EntityType;
-        targetColumn?: TargetColumnPath<any>;
-    }[];
+    references?: ReferenceReflectionData[];
+    tenantReference?: TypedOmit<ReferenceReflectionData, 'excludeTenant'>[];
     paradeField?: ParadeFieldOptions;
     tsVector?: TsVectorOptions<any>;
     encrypted?: boolean;
@@ -75,6 +73,11 @@ export type OrmColumnReflectionData = {
         mode: 'soft' | 'hard';
     };
 };
+type ReferenceReflectionData<T extends AnyEntity = AnyEntity> = {
+    target: () => EntityType<T>;
+    targetColumn?: TargetColumnPath<T>;
+    excludeTenant?: boolean;
+};
 /**
  * Reflection data for unique constraints.
  */
@@ -236,8 +239,17 @@ export declare function PrimaryKeyProperty(): PropertyDecorator;
  * Define a foreign key relationship.
  * @param type A function returning the referenced entity type.
  */
-export declare function References(target: () => EntityType): PropertyDecorator;
-export declare function References<T extends AnyEntity>(target: () => EntityType<T>, targetColumn?: TargetColumnPath<T>): PropertyDecorator;
+export declare function Reference<T extends AnyEntity>(target: () => EntityType<T>, targetColumn?: TargetColumnPath<T>): PropertyDecorator;
+export declare function Reference<T extends AnyEntity>(target: () => EntityType, options?: TypedOmit<ReferenceReflectionData<T>, 'target'>): PropertyDecorator;
+export { 
+/** @deprecated use {@link Reference} instead. */
+Reference as References };
+/**
+ * Define a foreign key relationship.
+ * @param type A function returning the referenced entity type.
+ */
+export declare function TenantReference(target: () => EntityType): PropertyDecorator;
+export declare function TenantReference<T extends AnyEntity>(target: () => EntityType<T>, targetColumn?: TargetColumnPath<T>): PropertyDecorator;
 /**
  * Define a table check constraint.
  * @template T The entity type.
@@ -375,4 +387,3 @@ export declare function ParadeIndex<T extends BaseEntity>(options: ParadeIndexRe
 export declare function ParadeIndex(options?: ParadeFieldOptions): PropertyDecorator;
 export declare function ParadeCompoundIndex<T extends BaseEntity>(alias: string, compoundColumns: ParadeIndexCompoundColumnColumnsProvider<T>, options?: TypedOmit<ParadeFieldOptions, 'alias'>): ClassDecorator;
 export declare function ParadeExpressionIndex<T extends BaseEntity>(alias: string, expression: ParadeIndexExpressionProvider<T>, options?: TypedOmit<ParadeFieldOptions, 'alias'>): ClassDecorator;
-export {};

package/orm/decorators.js

@@ -68,8 +68,16 @@ export function Column(options) {
 export function PrimaryKeyProperty() {
     return createColumnDecorator({ primaryKey: true });
 }
-export function References(target, targetColumn) {
-    return createColumnDecorator({ references: [{ target, targetColumn }] });
+export function Reference(target, targetColumnOrOptions) {
+    const targetColumn = (isString(targetColumnOrOptions) ? targetColumnOrOptions : targetColumnOrOptions?.targetColumn);
+    const options = isString(targetColumnOrOptions) ? undefined : targetColumnOrOptions;
+    return createColumnDecorator({ references: [{ target, targetColumn, excludeTenant: options?.excludeTenant }] });
+}
+export { 
+/** @deprecated use {@link Reference} instead. */
+Reference as References };
+export function TenantReference(target, targetColumn) {
+    return createColumnDecorator({ tenantReference: [{ target, targetColumn: targetColumn }] });
 }
 /**
  * Define a table check constraint.

package/orm/entity.d.ts

@@ -1,10 +1,10 @@
-import type { Type } from '../types/index.js';
+import type { AbstractType } from '../types/index.js';
 import type { Embedded, HasDefault, IsPrimaryKey, Json, Timestamp, Uuid } from './types.js';
 /**
  * Represents the type (constructor) of an entity, potentially holding an entity name.
  * @template T - The entity class type.
  */
-export interface EntityType<T extends BaseEntity = BaseEntity | Entity> extends Type<T> {
+export interface EntityType<T extends BaseEntity = BaseEntity | Entity> extends AbstractType<T> {
     readonly entityName?: string;
 }
 export type AnyEntity = BaseEntity | Entity;

package/orm/entity.js

@@ -81,6 +81,7 @@ export class TenantEntity extends Entity {
     tenantId;
 }
 __decorate([
+    PrimaryKeyProperty(),
     UuidProperty(),
     __metadata("design:type", String)
 ], TenantEntity.prototype, "tenantId", void 0);
@@ -88,6 +89,7 @@ export class TenantBaseEntity extends BaseEntity {
     tenantId;
 }
 __decorate([
+    PrimaryKeyProperty(),
     UuidProperty(),
     __metadata("design:type", String)
 ], TenantBaseEntity.prototype, "tenantId", void 0);

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

@@ -1,9 +1,9 @@
 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 { Enumeration } from '../../../types/index.js';
+import { type EntityType } from '../../entity.js';
 import type { ColumnDefinition, ColumnDefinitionsMap, PgTableFromType } from '../types.js';
 type ConverterContext = {
-    type: AbstractConstructor;
+    type: EntityType;
     property: string;
 };
 export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;

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

@@ -11,11 +11,13 @@ import { compareByValueSelectionToOrder, orderRest } from '../../../utils/compar
 import { decodeText, encodeUtf8 } from '../../../utils/encoding.js';
 import { enumValues } from '../../../utils/enum.js';
 import { memoize, memoizeSingle } from '../../../utils/function/memoize.js';
+import { typeExtends } from '../../../utils/index.js';
 import { compileDereferencer } from '../../../utils/object/dereference.js';
 import { fromEntries, mapObjectKeysToSnakeCase, objectEntries } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNull, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
 import { resolveValueOrProvider } from '../../../utils/value-or-provider.js';
 import { bytea, numericDate, timestamp, tsvector } from '../../data-types/index.js';
+import { TenantBaseEntity, TenantEntity } from '../../entity.js';
 import { getEnumName } from '../../enums.js';
 import { JsonSchema, NumericDateSchema, NumericSchema, TimestampSchema, TsVectorSchema, UuidSchema } from '../../schemas/index.js';
 import { decryptBytes, encryptBytes } from '../encryption.js';
@@ -87,7 +89,9 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         return builder;
     }
     function buildPrimaryKey(table) {
-        const columns = primaryKeyColumnDefinitions.map((columnDefinition) => table[columnDefinition.name]);
+        const columns = primaryKeyColumnDefinitions
+            .toSorted(compareByValueSelectionToOrder(['tenantId', 'id', orderRest], (columnDefinition) => columnDefinition.name))
+            .map((columnDefinition) => table[columnDefinition.name]);
         return primaryKey({
             name: mergedTableReflectionData.compoundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: mergedTableReflectionData.compoundPrimaryKeyNaming }),
             columns,
@@ -185,6 +189,17 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                 }
                 return buildIndex(table, indexData, columnDefinition.name);
             }).filter(isDefined)),
+            ...columnDefinitions.flatMap((columnDefinition) => {
+                return columnDefinition.reflectionData?.tenantReference?.map((tenantReferenceData) => {
+                    const foreignTable = getDrizzleTableFromType(tenantReferenceData.target(), dbSchema.schemaName);
+                    const nonTenantColumn = tenantReferenceData.targetColumn ?? 'id';
+                    return foreignKey({
+                        name: getForeignKeyName(tableName, [nonTenantColumn]),
+                        columns: [getColumn(table, 'tenantId'), getColumn(table, columnDefinition.name)],
+                        foreignColumns: [getColumn(foreignTable, 'tenantId'), getColumn(foreignTable, nonTenantColumn)],
+                    });
+                }) ?? [];
+            }),
             ...tableReflectionDatas.flatMap((tableReflectionData) => {
                 return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
                     const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
@@ -283,14 +298,16 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
     if ((reflectionData.primaryKey == true) && (options.skipPrimaryKey != true)) {
         column = column.primaryKey();
     }
-    for (const { target, targetColumn } of reflectionData.references ?? []) {
+    for (const { target, targetColumn, excludeTenant } of reflectionData.references ?? []) {
         column = column.references(() => {
-            const targetTable = getDrizzleTableFromType(target(), dbSchema.schemaName);
+            const targetType = target();
+            if ((excludeTenant != true) && (typeExtends(context.type, TenantBaseEntity) || typeExtends(context.type, TenantEntity)) && (typeExtends(targetType, TenantBaseEntity) || typeExtends(targetType, TenantEntity))) {
+                throw new Error(`${context.type.entityName ?? context.type.name} references ${targetType.entityName ?? targetType.name} via ${targetColumn ?? 'id'} without tenantId. This may lead to data integrity issues. Use \`@TenantReference()\` or set \`excludeTenant: true\` in the Reference decorator options to avoid this warning.`);
+            }
+            const targetTable = getDrizzleTableFromType(targetType, dbSchema.schemaName);
             return targetTable[(targetColumn ?? 'id')];
         });
     }
-    if (isDefined(reflectionData.references)) {
-    }
     return column;
 }
 function getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, context) {

package/orm/server/repository.js

@@ -11,12 +11,11 @@ import { NotFoundError } from '../../errors/not-found.error.js';
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
 import { afterResolve, resolveArgumentType } from '../../injector/interfaces.js';
-import { Schema } from '../../schema/schema.js';
 import { distinct, 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, fromEntries, objectEntries } from '../../utils/object/object.js';
+import { assignDeep, fromEntries, objectEntries } from '../../utils/object/object.js';
 import { toSnakeCase } from '../../utils/string/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { tryIgnoreAsync } from '../../utils/try-ignore.js';
@@ -1073,14 +1072,13 @@ let EntityRepository = class EntityRepository extends Transactional {
         return await toArrayAsync(mapAsync(columns, async (column) => await this._mapToEntity(column, transformContext)));
     }
     async _mapToEntity(columns, transformContext) {
-        const entries = [];
+        const entity = new this.type();
         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
+            assignDeep(entity, def.objectPath, transformed);
         }
-        const obj = fromDeepObjectEntries(entries);
-        return Schema.parse(this.type, obj);
+        return entity;
     }
     async _mapManyToColumns(objects, transformContext) {
         return await toArrayAsync(mapAsync(objects, async (obj) => await this._mapToColumns(obj, transformContext)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.61",
+  "version": "0.93.64",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -37,6 +37,7 @@
     "./supports": "./supports.js",
     "./tokens": "./tokens.js",
     "./ai": "./ai/index.js",
+    "./ai/genkit": "./ai/genkit/index.js",
     "./api": "./api/index.js",
     "./api/client": "./api/client/index.js",
     "./api/server": "./api/server/index.js",
@@ -138,18 +139,21 @@
     "type-fest": "^5.3"
   },
   "peerDependencies": {
-    "@google-cloud/storage": "^7.17",
-    "@google/genai": "^1.30",
+    "@genkit-ai/google-genai": "^1.25",
+    "@google-cloud/storage": "^7.18",
+    "@google/genai": "^1.32",
+    "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
-    "drizzle-orm": "^0.44",
+    "drizzle-orm": "^0.45",
     "file-type": "^21.1",
+    "genkit": "^1.25",
     "handlebars": "^4.7",
     "minio": "^8.0",
-    "mjml": "^4.17",
+    "mjml": "^4.18",
     "nodemailer": "^7.0",
     "pg": "^8.16",
     "playwright": "^1.57",
@@ -158,7 +162,7 @@
     "sharp": "^0.34",
     "undici": "^7.16",
     "urlpattern-polyfill": "^10.1",
-    "zod": "^4.1"
+    "zod": "^3.25"
   },
   "peerDependenciesMeta": {
     "@tstdl/angular": {
@@ -182,7 +186,7 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.48"
+    "typescript-eslint": "8.49"
   },
   "overrides": {
     "drizzle-kit": {

package/pdf/utils.js

@@ -149,5 +149,5 @@ export async function pdfToImage(file, page, size, format) {
     if (isNotString(file)) {
         process.autoWrite(file);
     }
-    return process.readOutputBytes();
+    return await process.readOutputBytes();
 }

package/schema/converters/zod-converter.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import type { SchemaTestable } from '../schema.js';
 export type SchemaConversionOptions = {
     /** Default coerce option if not specified in schema */

package/schema/converters/zod-converter.js

@@ -1,11 +1,11 @@
 import { match, P } from 'ts-pattern';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import { NotSupportedError } from '../../errors/not-supported.error.js';
 import { JsonPath } from '../../json-path/json-path.js';
 import { objectEntries, objectKeys } from '../../utils/object/object.js';
 import { isArray, isInstanceOf, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
 import { SchemaError } from '../schema.error.js';
-import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, ConstraintSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, FunctionSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, RegExpSchema, StringSchema, SymbolSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
+import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, ConstraintSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, RegExpSchema, StringSchema, SymbolSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
 import { schemaTestableToSchema } from '../testable.js';
 export function convertToZodSchema(testable, options) {
     const schema = schemaTestableToSchema(testable);
@@ -143,17 +143,6 @@ function convertToZodSchemaBase(schema, options) {
         // enumeration is either EnumerationObject or string-only EnumerationArray, both is fine for z.enum
         // using `as`, as z.enum is overloaded and only one type per overload
         return z.enum(s.enumeration);
-    })
-        .with(P.instanceOf(FunctionSchema), (s) => {
-        let zodSchema = z.function();
-        if (isNotNull(s.parameterSchemas)) {
-            const args = s.parameterSchemas.map((parameterSchema) => convertToZodSchemaBase(parameterSchema, options));
-            zodSchema = zodSchema.input(...args);
-        }
-        if (isNotNull(s.returnValueSchema)) {
-            zodSchema = zodSchema.output(convertToZodSchemaBase(s.returnValueSchema, options));
-        }
-        return zodSchema;
     })
         .with(P.instanceOf(DefaultSchema), (s) => convertToZodSchemaBase(s.schema, options).default(s.defaultValue))
         .with(P.instanceOf(TransformSchema), (s) => convertToZodSchemaBase(s.schema, options).transform((input) => s.transformFn(input)))

package/schema/converters/zod-v3-converter.d.ts

@@ -1,4 +1,4 @@
-import { z, type ZodTypeDef } from 'zod/v3';
+import { type ZodObject, type ZodType, type ZodTypeDef } from 'zod/v3';
 import type { Record } from '../../types/types.js';
 import type { SchemaTestable } from '../schema.js';
 import { ObjectSchema } from '../schemas/index.js';
@@ -9,5 +9,5 @@ export type SchemaConversionOptions = {
     mask?: boolean;
 };
 /** WARNING: *DOES NOT* cover all schemas and options. Meant for usage in schema generators like genkit, not for full schema testing in APIs etc. */
-export declare function convertToZodV3Schema<T extends Record>(testable: ObjectSchema<T>, options?: SchemaConversionOptions): z.ZodObject<any, any, any, T>;
-export declare function convertToZodV3Schema<O, I = unknown>(testable: SchemaTestable<O>, options?: SchemaConversionOptions): z.ZodType<O, ZodTypeDef, I>;
+export declare function convertToZodV3Schema<T extends Record>(testable: ObjectSchema<T>, options?: SchemaConversionOptions): ZodObject<any, any, any, T>;
+export declare function convertToZodV3Schema<O, I = unknown>(testable: SchemaTestable<O>, options?: SchemaConversionOptions): ZodType<O, ZodTypeDef, I>;

package/utils/file-reader.d.ts

@@ -1,4 +1,3 @@
 export declare function readAsText(blob: Blob, encoding?: string): Promise<string>;
 export declare function readAsArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
-export declare function readAsBinaryString(blob: Blob): Promise<string>;
 export declare function readAsDataUrl(blob: Blob): Promise<string>;

package/utils/file-reader.js

@@ -1,18 +1,15 @@
 import { DetailsError } from '../errors/details.error.js';
 export async function readAsText(blob, encoding) {
-    return setup((reader) => reader.readAsText(blob, encoding));
+    return await setup((reader) => reader.readAsText(blob, encoding));
 }
 export async function readAsArrayBuffer(blob) {
-    return setup((reader) => reader.readAsArrayBuffer(blob));
-}
-export async function readAsBinaryString(blob) {
-    return setup((reader) => reader.readAsBinaryString(blob));
+    return await setup((reader) => reader.readAsArrayBuffer(blob));
 }
 export async function readAsDataUrl(blob) {
-    return setup((reader) => reader.readAsDataURL(blob));
+    return await setup((reader) => reader.readAsDataURL(blob));
 }
 async function setup(dispatcher) {
-    return new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
         const reader = new FileReader();
         reader.onload = () => resolve(reader.result);
         reader.onerror = () => reject(new DetailsError(reader.error.message, reader.error));

package/utils/object/object.d.ts

@@ -30,6 +30,8 @@ export declare function filterNullishObjectProperties<T extends ObjectLiteral>(o
 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][];
+export declare function assignDeep(target: object, path: JsonPathInput, value: any): void;
+export declare function assignDeepObjectEntries(target: object, entries: readonly (readonly [JsonPathInput, any])[]): void;
 export declare function fromDeepObjectEntries(entries: readonly (readonly [JsonPathInput, any])[]): ObjectLiteral;
-export declare function omit<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Omit<T, K>>;
-export declare function pick<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Pick<T, K>>;
+export declare function omit<T extends Record, K extends keyof T>(object: T, keys: K[]): SimplifyObject<Omit<T, K>>;
+export declare function pick<T extends Record, K extends keyof T>(object: T, keys: K[]): SimplifyObject<Pick<T, K>>;