@tstdl/base 0.93.61 → 0.93.62

package/document-management/server/drizzle/meta/_journal.json

@@ -8,6 +8,13 @@
       "when": 1750253838549,
       "tag": "0000_ordinary_pretty_boy",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1764857079867,
+      "tag": "0001_lyrical_wong",
+      "breakpoints": true
     }
   ]
 }

package/document-management/server/services/document-category-type.service.d.ts

@@ -7,29 +7,29 @@ export declare class DocumentCategoryTypeService extends Transactional {
     loadCategory(tenantId: string, id: string): Promise<DocumentCategory>;
     loadType(tenantId: string, id: string): Promise<DocumentType>;
     createCategory(data: {
-        tenantId: string | null;
+        tenantId: string;
         label: string;
         parentId: string | null;
         enumKey?: string;
     }): Promise<DocumentCategory>;
     createType(data: {
-        tenantId: string | null;
+        tenantId: string;
         label: string;
         categoryId: string;
         enumKey?: string;
     }): Promise<DocumentType>;
-    updateCategory(tenantId: string | null, id: string, update: {
+    updateCategory(tenantId: string, id: string, update: {
         label?: string;
         parentId?: string | null;
     }): Promise<DocumentCategory>;
-    updateType(tenantId: string | null, id: string, update: {
+    updateType(tenantId: string, id: string, update: {
         label?: string;
         categoryId?: string;
     }): Promise<DocumentType>;
     loadCategoryGraph(tenantId: string, categoryId: string): Promise<DocumentCategory[]>;
-    loadCategoriesAndTypes(tenantId: string | null): Promise<{
+    loadCategoriesAndTypes(tenantId: string): Promise<{
         categories: DocumentCategory[];
         types: DocumentType[];
     }>;
-    loadCategoryViews(tenantId: string | null): Promise<DocumentCategoryView[]>;
+    loadCategoryViews(tenantId: string): Promise<DocumentCategoryView[]>;
 }

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

@@ -14,10 +14,10 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
     categoryRepository = injectRepository(DocumentCategory);
     typeRepository = injectRepository(DocumentType);
     async loadCategory(tenantId, id) {
-        return await this.categoryRepository.loadByQuery({ id, tenantId: { $or: [null, tenantId] } });
+        return await this.categoryRepository.loadByQuery({ tenantId, id });
     }
     async loadType(tenantId, id) {
-        return await this.typeRepository.loadByQuery({ id, tenantId: { $or: [null, tenantId] } });
+        return await this.typeRepository.loadByQuery({ tenantId, id });
     }
     async createCategory(data) {
         return await this.categoryRepository.insert({
@@ -29,7 +29,7 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
     }
     async createType(data) {
         // Ensure the category exists for the tenant before creating the type
-        await this.categoryRepository.loadByQuery({ tenantId: { $or: [null, data.tenantId] }, id: data.categoryId });
+        await this.categoryRepository.loadByQuery({ tenantId: data.tenantId, id: data.categoryId });
         return await this.typeRepository.insert({
             tenantId: data.tenantId,
             label: data.label,
@@ -44,7 +44,7 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
         return await this.typeRepository.updateByQuery({ tenantId, id }, update);
     }
     async loadCategoryGraph(tenantId, categoryId) {
-        const category = await this.categoryRepository.loadByQuery({ tenantId: { $or: [null, tenantId] }, id: categoryId });
+        const category = await this.categoryRepository.loadByQuery({ tenantId, id: categoryId });
         if (category.parentId == null) {
             return [category];
         }
@@ -53,8 +53,8 @@ let DocumentCategoryTypeService = class DocumentCategoryTypeService extends Tran
     }
     async loadCategoriesAndTypes(tenantId) {
         const [categories, types] = await Promise.all([
-            this.categoryRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: 'label' }),
-            this.typeRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: 'label' }),
+            this.categoryRepository.loadManyByQuery({ tenantId }, { order: 'label' }),
+            this.typeRepository.loadManyByQuery({ tenantId }, { order: 'label' }),
         ]);
         return { categories, types };
     }

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

@@ -154,9 +154,9 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
             if (isNull(document.typeId)) {
                 throw new Error(`Document ${document.id} has no type`);
             }
-            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, typeId: document.typeId });
+            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId, typeId: document.typeId });
             const propertyIds = typeProperties.map((property) => property.propertyId);
-            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, id: { $in: propertyIds } }) : undefined;
+            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ tenantId, id: { $in: propertyIds } }) : undefined;
             const propertiesSchemaEntries = properties?.map((property) => {
                 const schema = match(property.dataType)
                     .with('text', () => nullable(string()))

package/document-management/server/services/document-management.service.d.ts

@@ -96,8 +96,8 @@ export declare class DocumentManagementService extends Transactional {
     getRelevantDocumentCollectionIds(tenantId: string, documentId: string): Promise<string[]>;
     loadDataStream(tenantId: string, collectionIds: string[], cancellationSignal: CancellationSignal): AsyncGenerator<DocumentManagementData>;
     loadData(tenantId: string, collectionIds: string[]): Promise<DocumentManagementData>;
-    loadDocumentRequestsTemplateData(tenantId: string | null): Promise<DocumentRequestsTemplateData>;
-    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(tenantId: string | null, data: CategoriesAndTypesInitializationData<CategoryKey, TypeKey, DocumentPropertyKey>): Promise<{
+    loadDocumentRequestsTemplateData(tenantId: string): Promise<DocumentRequestsTemplateData>;
+    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(tenantId: string, data: CategoriesAndTypesInitializationData<CategoryKey, TypeKey, DocumentPropertyKey>): Promise<{
         categories: Record<CategoryKey, DocumentCategory>;
         types: Record<TypeKey, DocumentType>;
         properties: Record<DocumentPropertyKey, DocumentProperty>;

package/document-management/server/services/document-property.service.d.ts

@@ -46,18 +46,18 @@ export declare class DocumentPropertyService extends Transactional {
         }, {}, {}>;
         value: import("drizzle-orm").SQL.Aliased<string | number | boolean | null>;
     }, "documentProperties">;
-    loadViews(tenantId: string | null): Promise<DocumentPropertyView[]>;
+    loadViews(tenantId: string): Promise<DocumentPropertyView[]>;
     createProperty(data: {
-        tenantId: string | null;
+        tenantId: string;
         label: string;
         dataType: DocumentPropertyDataType;
         enumKey?: string;
     }): Promise<DocumentProperty>;
-    updateProperty(tenantId: string | null, id: string, update: {
+    updateProperty(tenantId: string, id: string, update: {
         label?: string;
         dataType?: DocumentPropertyDataType;
     }): Promise<DocumentProperty>;
-    assignPropertyToType(tenantId: string | null, typeId: string, propertyId: string): Promise<void>;
+    assignPropertyToType(tenantId: string, typeId: string, propertyId: string): Promise<void>;
     loadDocumentPropertyValues(tenantId: string, documentId: OneOrMany<string>, includeNulls?: boolean): Promise<DocumentPropertyValueView[]>;
     setPropertyValues(document: Document, propertyValues: SetDocumentPropertyParameters[]): Promise<void>;
 }

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

@@ -46,8 +46,8 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
         .innerJoin(documentProperty, and(eq(documentProperty.id, documentTypeProperty.propertyId), or(drizzleIsNull(documentProperty.tenantId), eq(documentProperty.tenantId, document.tenantId))))
         .leftJoin(documentPropertyValue, and(eq(documentPropertyValue.tenantId, document.tenantId), eq(documentPropertyValue.documentId, document.id), eq(documentPropertyValue.propertyId, documentProperty.id))));
     async loadViews(tenantId) {
-        const properties = await this.#documentPropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } });
-        const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } });
+        const properties = await this.#documentPropertyRepository.loadManyByQuery({ tenantId });
+        const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId });
         return properties.map((property) => {
             const typeIds = typeProperties
                 .filter((typeProperty) => typeProperty.propertyId == property.id)
@@ -94,7 +94,7 @@ let DocumentPropertyService = class DocumentPropertyService extends Transactiona
         }
         await this.transaction(async (tx) => {
             const propertyIds = propertyValues.map((property) => property.propertyId);
-            const properties = await this.#documentPropertyRepository.withTransaction(tx).loadManyByQuery({ tenantId: { $or: [null, document.tenantId] }, id: { $in: propertyIds } });
+            const properties = await this.#documentPropertyRepository.withTransaction(tx).loadManyByQuery({ tenantId: document.tenantId, id: { $in: propertyIds } });
             const propertiesMap = getEntityMap(properties);
             const upserts = propertyValues.filter((value) => isNotNull(value.value)).map(({ propertyId, value, metadata }) => {
                 const property = propertiesMap.get(propertyId);

package/document-management/server/services/document-request.service.d.ts

@@ -5,8 +5,8 @@ import type { RequestStats } from '../../service-models/index.js';
 export declare class DocumentRequestService extends Transactional {
     #private;
     getRequestStats(tenantId: string, collectionIds: OneOrMany<string>): Promise<RequestStats>;
-    createRequestsTemplate(tenantId: string | null, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
-    updateRequestsTemplate(tenantId: string | null, id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
+    createRequestsTemplate(tenantId: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
+    updateRequestsTemplate(tenantId: string, id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
     applyRequestsTemplate(tenantId: string, id: string, collectionIds: string[]): Promise<void>;
     deleteRequestsTemplate(tenantId: string, id: string): Promise<DocumentRequestsTemplate>;
     createRequestTemplate(tenantId: string, requestsTemplateId: string, typeId: string, comment: string): Promise<DocumentRequestTemplate>;

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

@@ -46,7 +46,7 @@ let DocumentRequestService = class DocumentRequestService extends Transactional
         return await this.#documentRequestsTemplateRepository.updateByQuery({ tenantId, id }, parameters);
     }
     async applyRequestsTemplate(tenantId, id, collectionIds) {
-        const requestTemplates = await this.#documentRequestTemplateRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, requestsTemplateId: id });
+        const requestTemplates = await this.#documentRequestTemplateRepository.loadManyByQuery({ tenantId, requestsTemplateId: id });
         await this.transaction(async (tx) => {
             for (const { typeId, comment } of requestTemplates) {
                 await this.withTransaction(tx).createRequest(tenantId, typeId, collectionIds, comment);

package/document-management/server/services/document-tag.service.d.ts

@@ -3,7 +3,7 @@ import { DocumentTag, DocumentTagAssignment, type Document } from '../../models/
 export declare class DocumentTagService extends Transactional {
     readonly tagRepository: import("../../../orm/server/index.js").EntityRepository<DocumentTag>;
     readonly tagAssignmentRepository: import("../../../orm/server/index.js").EntityRepository<DocumentTagAssignment>;
-    loadTags(tenantId: string | null): Promise<DocumentTag[]>;
+    loadTags(tenantId: string): Promise<DocumentTag[]>;
     loadOrCreate(tenantId: string, labels: string[]): Promise<DocumentTag[]>;
     loadDocumentTags(tenantId: string, documentId: string): Promise<DocumentTag[]>;
     assignTags(document: Document, labels: string[]): Promise<void>;

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

@@ -14,7 +14,7 @@ let DocumentTagService = class DocumentTagService extends Transactional {
     tagRepository = injectRepository(DocumentTag);
     tagAssignmentRepository = injectRepository(DocumentTagAssignment);
     async loadTags(tenantId) {
-        return await this.tagRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] } }, { order: { label: 'asc' } });
+        return await this.tagRepository.loadManyByQuery({ tenantId }, { order: { label: 'asc' } });
     }
     async loadOrCreate(tenantId, labels) {
         if (labels.length === 0) {
@@ -22,7 +22,7 @@ let DocumentTagService = class DocumentTagService extends Transactional {
         }
         return await this.tagRepository.transaction(async (tx) => {
             const existingTags = await this.tagRepository.withTransaction(tx).loadManyByQuery({
-                tenantId: { $or: [null, tenantId] },
+                tenantId,
                 label: { $in: labels },
             });
             const newLabels = labels.filter((label) => !existingTags.some((tag) => tag.label == label));

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,7 +16,7 @@ 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 { isDefined, isNotReadableStream, isNotUint8Array, isUndefined } from '../../../utils/type-guards.js';
 import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentType, DocumentWorkflowStep } from '../../models/index.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentFileService } from './document-file.service.js';
@@ -42,10 +42,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.61",
+  "version": "0.93.62",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -138,8 +138,8 @@
     "type-fest": "^5.3"
   },
   "peerDependencies": {
-    "@google-cloud/storage": "^7.17",
-    "@google/genai": "^1.30",
+    "@google-cloud/storage": "^7.18",
+    "@google/genai": "^1.31",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",