@tstdl/base 0.92.88 → 0.92.90

package/document-management/models/document-property-value.model.js

@@ -7,11 +7,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+import { eq } from 'drizzle-orm';
 import { References } from '../../orm/decorators.js';
 import { Entity } from '../../orm/entity.js';
+import { numNonNulls } from '../../orm/sqls.js';
 import { Check, NumericDate, Unique, Uuid } from '../../orm/types.js';
 import { BooleanProperty, Integer, NumberProperty, StringProperty } from '../../schema/index.js';
-import { sql } from 'drizzle-orm';
 import { DocumentProperty } from './document-property.model.js';
 import { DocumentRequestAssignmentTask } from './document-request-assignment-task.model.js';
 import { DocumentRequestFile } from './document-request-file.model.js';
@@ -50,7 +51,7 @@ __decorate([
     __metadata("design:type", Object)
 ], DocumentPropertyValueBase.prototype, "date", void 0);
 DocumentPropertyValueBase = __decorate([
-    Check('only_one_value', (table) => sql `num_nonnulls(${table.text}, ${table.integer}, ${table.decimal}, ${table.boolean}, ${table.date}) = 1`)
+    Check('only_one_value', (table) => eq(numNonNulls(table.text, table.integer, table.decimal, table.boolean, table.date), 1))
 ], DocumentPropertyValueBase);
 export { DocumentPropertyValueBase };
 let DocumentPropertyValue = class DocumentPropertyValue extends DocumentPropertyValueBase {

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

@@ -1,6 +1,6 @@
 import type { RequireExactlyOne, Stringified } from 'type-fest';
 import type { CancellationSignal } from '../../../cancellation/token.js';
-import { type AfterResolve, type AfterResolveContext, afterResolve, resolveArgumentType } from '../../../injector/index.js';
+import { type AfterResolveContext, afterResolve } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
 import type { Query } from '../../../orm/index.js';
@@ -8,9 +8,7 @@ import { type Transaction } from '../../../orm/server/index.js';
 import { Queue } from '../../../queue/queue.js';
 import type { OneOrMany, Record } from '../../../types.js';
 import { type AddOrArchiveDocumentToOrFromCollectionParameters, type ApplyDocumentRequestsTemplateParameters, type ApproveDocumentRequestFileParameters, type AssignPropertyToTypeParameters, type CategoryAndTypesView, type CreateCollectionParameters, type CreateDocumentCategoryParameters, type CreateDocumentParameters, type CreateDocumentPropertyParameters, type CreateDocumentRequestFileParameters, type CreateDocumentRequestParameters, type CreateDocumentRequestTemplateParameters, type CreateDocumentRequestsTemplateParameters, type CreateDocumentTypeParameters, type DeleteDocumentRequestFileParameters, type DeleteDocumentRequestParameters, type DeleteDocumentRequestTemplateParameters, type DeleteDocumentRequestsTemplateParameters, Document, DocumentCategory, DocumentCollection, DocumentCollectionDocument, DocumentFile, type DocumentManagementData, DocumentProperty, DocumentPropertyDataType, DocumentPropertyValue, DocumentRequest, DocumentRequestAssignmentTask, DocumentRequestAssignmentTaskCollection, DocumentRequestAssignmentTaskPropertyValue, DocumentRequestCollection, DocumentRequestFile, DocumentRequestFilePropertyValue, DocumentRequestTemplate, DocumentRequestsTemplate, type DocumentRequestsTemplateData, DocumentType, DocumentTypeProperty, type LoadDataCollectionsMetadataParameters, type RejectDocumentRequestFileParameters, type RequestFilesStats, type SetDocumentPropertiesParameters, type UpdateDocumentParameters, type UpdateDocumentRequestFileParameters, type UpdateDocumentRequestParameters, type UpdateDocumentRequestTemplateParameters, type UpdateDocumentRequestsTemplateParameters } from '../../models/index.js';
-import { DocumentManagementConfig } from '../module.js';
 import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
-export type DocumentServiceArgument = DocumentManagementConfig;
 type DocumentInformationExtractionPropertyResult = {
     propertyId: string;
     dataType: DocumentPropertyDataType;
@@ -34,12 +32,12 @@ type ExtractionJobData = RequireExactlyOne<{
 type AssignmentJobData = RequireExactlyOne<{
     requestAssignmentTaskId: string;
 }>;
-export declare class DocumentManagementService implements AfterResolve<DocumentServiceArgument, any> {
+declare const DocumentManagementService_base: import("../../../types.js").Type<import("../../../orm/server/index.js").EntityRepository<DocumentCollection>>;
+export declare class DocumentManagementService extends DocumentManagementService_base {
     #private;
     protected readonly ancillaryService: DocumentManagementAncillaryService;
     protected readonly documentCategoryService: import("../../../orm/server/index.js").EntityRepository<DocumentCategory>;
     protected readonly documentCollectionDocumentService: import("../../../orm/server/index.js").EntityRepository<DocumentCollectionDocument>;
-    protected readonly documentCollectionService: import("../../../orm/server/index.js").EntityRepository<DocumentCollection>;
     protected readonly documentFileService: import("../../../orm/server/index.js").EntityRepository<DocumentFile>;
     protected readonly documentPropertyService: import("../../../orm/server/index.js").EntityRepository<DocumentProperty>;
     protected readonly documentPropertyValueService: import("../../../orm/server/index.js").EntityRepository<DocumentPropertyValue>;
@@ -59,7 +57,6 @@ export declare class DocumentManagementService implements AfterResolve<DocumentS
     protected readonly extractionQueue: Queue<ExtractionJobData>;
     protected readonly assignmentQueue: Queue<AssignmentJobData>;
     protected readonly logger: Logger;
-    readonly [resolveArgumentType]: DocumentServiceArgument;
     [afterResolve](_: unknown, { cancellationSignal }: AfterResolveContext<any>): void;
     processQueues(cancellationSignal: CancellationSignal): void;
     resolveNames<const T extends (DocumentCollection | string)[]>(...collectionsOrIds: T): Promise<Stringified<T>>;

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

@@ -63,11 +63,11 @@ import { AiService } from '../../../ai/index.js';
 import { Enumerable } from '../../../enumerable/index.js';
 import { BadRequestError } from '../../../errors/index.js';
 import { TemporaryFile, getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
-import { Singleton, afterResolve, inject, injectArgument, provide, resolveArgumentType } from '../../../injector/index.js';
+import { Singleton, afterResolve, inject, provide } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
-import { getEntityMap } from '../../../orm/index.js';
-import { DatabaseConfig, EntityRepositoryConfig, TRANSACTION_TIMESTAMP, arrayAgg, coalesce, injectRepository, jsonAgg, toJsonb } from '../../../orm/server/index.js';
+import { TRANSACTION_TIMESTAMP, arrayAgg, coalesce, getEntityMap, jsonAgg, toJsonb } from '../../../orm/index.js';
+import { DatabaseConfig, EntityRepositoryConfig, getRepository, injectRepository } from '../../../orm/server/index.js';
 import { getPdfPageCount } from '../../../pdf/index.js';
 import { Queue } from '../../../queue/queue.js';
 import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
@@ -93,12 +93,11 @@ const defaultGenerationOptions = {
         topP: 0.2
     }
 };
-let DocumentManagementService = DocumentManagementService_1 = class DocumentManagementService {
+let DocumentManagementService = DocumentManagementService_1 = class DocumentManagementService extends getRepository(DocumentCollection) {
     #aiService = inject(AiService);
     ancillaryService = inject(DocumentManagementAncillaryService);
     documentCategoryService = injectRepository(DocumentCategory);
     documentCollectionDocumentService = injectRepository(DocumentCollectionDocument);
-    documentCollectionService = injectRepository(DocumentCollection);
     documentFileService = injectRepository(DocumentFile);
     documentPropertyService = injectRepository(DocumentProperty);
     documentPropertyValueService = injectRepository(DocumentPropertyValue);
@@ -114,11 +113,14 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
     documentService = injectRepository(Document);
     documentTypePropertyService = injectRepository(DocumentTypeProperty);
     documentTypeService = injectRepository(DocumentType);
-    fileObjectStorage = inject(ObjectStorage, (injectArgument(this, { optional: true }) ?? inject(DocumentManagementConfig)).fileObjectStorageModule);
+    fileObjectStorage = inject(ObjectStorage, inject(DocumentManagementConfig).fileObjectStorageModule);
     extractionQueue = inject((Queue), { name: 'DocumentManagement:extraction', processTimeout: 15 * millisecondsPerMinute });
     assignmentQueue = inject((Queue), { name: 'DocumentManagement:assignment', processTimeout: 15 * millisecondsPerMinute });
     logger = inject(Logger, DocumentManagementService_1.name);
     [afterResolve](_, { cancellationSignal }) {
+        if (this.isFork) {
+            return;
+        }
         this.processQueues(cancellationSignal);
     }
     processQueues(cancellationSignal) {
@@ -144,7 +146,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         if (loadIds.length == 0) {
             return this.ancillaryService.resolveNames(collectionsOrIds);
         }
-        const loadedCollections = await this.documentCollectionService.loadManyByQuery({ id: { $in: loadIds } });
+        const loadedCollections = await this.loadManyByQuery({ id: { $in: loadIds } });
         const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
             ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
             : collectionOrId);
@@ -156,9 +158,9 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         return fromEntries(entries);
     }
     async loadData(collectionIds, collectionsMetadata) {
-        return this.documentCollectionService.transaction(async (_, transaction) => {
+        return this.transaction(async (_, transaction) => {
             const [collections, collectionDocuments, requestCollections, categories, types] = await Promise.all([
-                this.documentCollectionService.withTransaction(transaction).loadMany(collectionIds),
+                this.withTransaction(transaction).loadMany(collectionIds),
                 this.documentCollectionDocumentService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
                 this.documentRequestCollectionService.withTransaction(transaction).loadManyByQuery({ collectionId: { $in: collectionIds } }),
                 this.documentCategoryService.withTransaction(transaction).loadManyByQuery({}, { order: 'label' }),
@@ -240,7 +242,7 @@ let DocumentManagementService = DocumentManagementService_1 = class DocumentMana
         return this.documentTypeService.insert(parameters);
     }
     async createCollection(parameters) {
-        return this.documentCollectionService.insert(parameters ?? {});
+        return this.insert(parameters ?? {});
     }
     async collectionHasDocumentByFilter(collectionId, filter) {
         const collectionDocuments = await this.documentCollectionDocumentService.loadManyByQuery({ collectionId });

package/eslint.config.js

@@ -63,7 +63,8 @@ export default [
           }
         }
       }],
-      '@stylistic/yield-star-spacing': ['error', 'after'],
+      '@stylistic/yield-star-spacing': ['warn', 'after'],
+      '@stylistic/generator-star-spacing': ['warn', 'before'],
       '@stylistic/indent': 'off'
     }
   }

package/orm/index.d.ts

@@ -1,5 +1,6 @@
 export * from './entity.js';
 export * from './query.js';
 export * from './repository.types.js';
+export * from './sqls.js';
 export * from './types.js';
 export * from './utils.js';

package/orm/index.js

@@ -1,5 +1,6 @@
 export * from './entity.js';
 export * from './query.js';
 export * from './repository.types.js';
+export * from './sqls.js';
 export * from './types.js';
 export * from './utils.js';

package/orm/server/index.d.ts

@@ -3,5 +3,4 @@ export * from './database.js';
 export * from './module.js';
 export * from './query-converter.js';
 export * from './repository.js';
-export * from './sqls.js';
 export * from './transaction.js';

package/orm/server/index.js

@@ -3,5 +3,4 @@ export * from './database.js';
 export * from './module.js';
 export * from './query-converter.js';
 export * from './repository.js';
-export * from './sqls.js';
 export * from './transaction.js';

package/orm/server/repository.d.ts

@@ -14,7 +14,8 @@ export declare const repositoryType: unique symbol;
 export declare class EntityRepositoryConfig {
     schema: string;
 }
-export type TransactionHandler<T extends EntityWithoutMetadata, R> = (repository: EntityRepository<T>, transaction: Transaction) => Promise<R>;
+export type TransactionHandler<T extends EntityRepository<any>, R> = (repository: T, transaction: Transaction) => Promise<R>;
+type InferSelect<T extends Entity | EntityWithoutMetadata = Entity | EntityWithoutMetadata> = PgTableFromType<EntityType<T>>['$inferSelect'];
 export declare class EntityRepository<T extends Entity | EntityWithoutMetadata = EntityWithoutMetadata> implements Resolvable<EntityType<T>> {
     #private;
     readonly type: EntityType<T>;
@@ -23,15 +24,14 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     readonly isInTransaction: boolean;
     readonly hasMetadata: boolean;
     get table(): PgTableFromType<EntityType<T>>;
+    protected get isFork(): boolean;
     readonly [resolveArgumentType]: EntityType<T>;
-    readonly _anyInferSelect: PgTableFromType<EntityType<Entity>>['$inferSelect'];
-    readonly _inferSelect: PgTableFromType<EntityType<T>>['$inferSelect'];
     constructor();
-    withOptionalTransaction(transaction: Transaction | undefined): EntityRepository<T>;
-    withTransaction(transaction: Transaction): EntityRepository<T>;
+    withOptionalTransaction(transaction: Transaction | undefined): this;
+    withTransaction(transaction: Transaction): this;
     startTransaction(config?: TransactionConfig): Promise<Transaction>;
-    useTransaction<R>(transaction: Transaction | undefined, handler: TransactionHandler<T, R>): Promise<R>;
-    transaction<R>(handler: TransactionHandler<T, R>, config?: TransactionConfig): Promise<R>;
+    useTransaction<R>(transaction: Transaction | undefined, handler: TransactionHandler<this, R>): Promise<R>;
+    transaction<R>(handler: TransactionHandler<this, R>, config?: TransactionConfig): Promise<R>;
     load(id: string): Promise<T>;
     tryLoad(id: string): Promise<T | undefined>;
     loadByQuery(query: Query<T>, options?: LoadOptions<T>): Promise<T>;
@@ -77,15 +77,15 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
     hardDeleteManyByQuery(query: Query<T>): Promise<T[]>;
     $getColumn(pathOrColumn: Paths<UntaggedDeep<T>> | ColumnDefinition): PgColumn;
     $convertOrderBy(orderBy: Order<T>): SQL<unknown>[];
-    $convertQuery(query: Query<T>): SQL;
-    $mapManyToEntity(columns: this['_inferSelect'][]): Promise<T[]>;
-    $mapToEntity(columns: this['_inferSelect']): Promise<T>;
-    $mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[]): Promise<PgInsertValue<PgTableFromType>[]>;
-    $mapToColumns(obj: DeepPartial<T> | NewEntity<T>): Promise<PgInsertValue<PgTableFromType>>;
-    $mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[]): Promise<PgInsertValue<PgTableFromType>[]>;
-    $mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>): Promise<PgInsertValue<PgTableFromType>>;
-    $mapUpdate(update: EntityUpdate<T>): Promise<PgUpdateSetSource<PgTableFromType>>;
-    $getIdLimitQuery(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
+    convertQuery(query: Query<T>): SQL;
+    mapManyToEntity(columns: InferSelect[]): Promise<T[]>;
+    mapToEntity(columns: InferSelect): Promise<T>;
+    mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[]): Promise<PgInsertValue<PgTableFromType>[]>;
+    mapToColumns(obj: DeepPartial<T> | NewEntity<T>): Promise<PgInsertValue<PgTableFromType>>;
+    mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[]): Promise<PgInsertValue<PgTableFromType>[]>;
+    mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>): Promise<PgInsertValue<PgTableFromType>>;
+    mapUpdate(update: EntityUpdate<T>): Promise<PgUpdateSetSource<PgTableFromType>>;
+    getIdLimitQuery(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
         id: PgColumn<{
             name: string;
             tableName: string;
@@ -124,15 +124,15 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
             generated: undefined;
         }, {}, {}>;
     }>, "where" | "limit">;
-    $getAttributesUpdate(attributes: SQL | EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
-    protected mapManyToEntity(columns: this['_anyInferSelect'][], transformContext: TransformContext): Promise<T[]>;
-    protected mapToEntity(columns: this['_anyInferSelect'], transformContext: TransformContext): Promise<T>;
-    protected mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>[]>;
-    protected mapToColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
-    protected mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>[]>;
-    protected mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
-    protected mapUpdate(update: EntityUpdate<T>, transformContext: TransformContext): Promise<PgUpdateSetSource<PgTableFromType>>;
-    protected getMetadataUpdate(update?: EntityUpdate<T>): PgUpdateSetSource<PgTableFromType<EntityType<Entity>>> | undefined;
+    protected getAttributesUpdate(attributes: SQL | EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
+    protected _mapManyToEntity(columns: InferSelect[], transformContext: TransformContext): Promise<T[]>;
+    protected _mapToEntity(columns: InferSelect, transformContext: TransformContext): Promise<T>;
+    protected _mapManyToColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>[]>;
+    protected _mapToColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
+    protected _mapManyToInsertColumns(objects: (DeepPartial<T> | NewEntity<T>)[], transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>[]>;
+    protected _mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
+    protected _mapUpdate(update: EntityUpdate<T>, transformContext: TransformContext): Promise<PgUpdateSetSource<PgTableFromType>>;
+    protected _getMetadataUpdate(update?: EntityUpdate<T>): PgUpdateSetSource<PgTableFromType<EntityType<Entity>>> | undefined;
     protected getIdLimitSelect(query: Query<T>): Omit<import("drizzle-orm/pg-core").PgSelectBase<string, {
         id: PgColumn<{
             name: string;
@@ -172,7 +172,6 @@ export declare class EntityRepository<T extends Entity | EntityWithoutMetadata =
             generated: undefined;
         }, {}, {}>;
     }>, "where" | "limit">;
-    protected getAttributesUpdate(attributes: SQL | EntityMetadataAttributes | undefined): SQL<unknown> | undefined;
     protected getTransformContext(): Promise<TransformContext>;
 }
 export declare function injectRepository<T extends Entity | EntityWithoutMetadata>(type: EntityType<T>): EntityRepository<T>;

package/orm/server/repository.js

@@ -25,10 +25,10 @@ import { typeExtends } from '../../utils/index.js';
 import { fromDeepObjectEntries, fromEntries, objectEntries } from '../../utils/object/object.js';
 import { assertDefinedPass, isArray, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
 import { Entity } from '../entity.js';
+import { TRANSACTION_TIMESTAMP } from '../sqls.js';
 import { Database } from './database.js';
 import { getColumnDefinitions, getDrizzleTableFromType } from './drizzle/schema-converter.js';
 import { convertQuery } from './query-converter.js';
-import { TRANSACTION_TIMESTAMP } from './sqls.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
 import { DrizzleTransaction } from './transaction.js';
 export const repositoryType = Symbol('repositoryType');
@@ -38,11 +38,11 @@ export class EntityRepositoryConfig {
 const entityTypeToken = Symbol('EntityType');
 const { getCurrentEntityRepositoryContext, runInEntityRepositoryContext, isInEntityRepositoryContext } = createContextProvider('EntityRepository');
 let EntityRepository = class EntityRepository {
+    #context = getCurrentEntityRepositoryContext() ?? {};
     #injector = inject(Injector);
     #repositoryConstructor;
     #withTransactionCache = new WeakMap();
-    #encryptionSecret = isInEntityRepositoryContext() ? getCurrentEntityRepositoryContext()?.encryptionSecret : inject(ENCRYPTION_SECRET, undefined, { optional: true });
-    #context = getCurrentEntityRepositoryContext() ?? {};
+    #encryptionSecret = isInEntityRepositoryContext() ? this.#context.encryptionSecret : inject(ENCRYPTION_SECRET, undefined, { optional: true });
     #transformContext = this.#context.transformContext;
     type = this.#context.type ?? injectArgument(this, { optional: true }) ?? assertDefinedPass(this.constructor[entityTypeToken], 'Missing entity type.');
     typeName = this.type.entityName ?? this.type.name;
@@ -56,6 +56,9 @@ let EntityRepository = class EntityRepository {
     get table() {
         return this.#table;
     }
+    get isFork() {
+        return this.isInTransaction;
+    }
     constructor() {
         this.#repositoryConstructor = new.target;
     }
@@ -115,7 +118,7 @@ let EntityRepository = class EntityRepository {
         return entity;
     }
     async tryLoadByQuery(query, options) {
-        const sqlQuery = this.$convertQuery(query);
+        const sqlQuery = this.convertQuery(query);
         let dbQuery = this.session.select()
             .from(this.#table)
             .where(sqlQuery)
@@ -128,8 +131,7 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        const transformContext = await this.getTransformContext();
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async loadMany(ids, options) {
         return this.loadManyByQuery(inArray(this.#table.id, ids), options);
@@ -139,7 +141,7 @@ let EntityRepository = class EntityRepository {
         yield* entities;
     }
     async loadManyByQuery(query, options) {
-        const sqlQuery = this.$convertQuery(query);
+        const sqlQuery = this.convertQuery(query);
         let dbQuery = this.session.select()
             .from(this.#table)
             .where(sqlQuery)
@@ -151,8 +153,7 @@ let EntityRepository = class EntityRepository {
             dbQuery = dbQuery.orderBy(...this.$convertOrderBy(options.order));
         }
         const rows = await dbQuery;
-        const transformContext = await this.getTransformContext();
-        return this.mapManyToEntity(rows, transformContext);
+        return this.mapManyToEntity(rows);
     }
     async *loadManyByQueryCursor(query, options) {
         const entities = await this.loadManyByQuery(query, options);
@@ -173,7 +174,7 @@ let EntityRepository = class EntityRepository {
         return assertDefinedPass(result).count;
     }
     async countByQuery(query) {
-        const sqlQuery = this.$convertQuery(query);
+        const sqlQuery = this.convertQuery(query);
         const dbQuery = this.session
             .select({ count: count() })
             .from(this.#table)
@@ -185,7 +186,7 @@ let EntityRepository = class EntityRepository {
         return this.hasByQuery(eq(this.#table.id, id));
     }
     async hasByQuery(query) {
-        const sqlQuery = this.$convertQuery(query);
+        const sqlQuery = this.convertQuery(query);
         const dbQuery = this.session
             .select({ exists: sql `SELECT EXISTS(SELECT 1 FROM ${this.#table} WHERE ${sqlQuery})` })
             .from(this.#table);
@@ -204,8 +205,7 @@ let EntityRepository = class EntityRepository {
      * @returns entity if inserted, undefined on conflict
      */
     async tryInsert(entity) {
-        const transformContext = await this.getTransformContext();
-        const columns = await this.mapToInsertColumns(entity, transformContext);
+        const columns = await this.mapToInsertColumns(entity);
         const [row] = await this.session
             .insert(this.#table)
             .values(columns)
@@ -214,28 +214,25 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async insert(entity) {
-        const transformContext = await this.getTransformContext();
-        const columns = await this.mapToInsertColumns(entity, transformContext);
+        const columns = await this.mapToInsertColumns(entity);
         const [row] = await this.session
             .insert(this.#table)
             .values(columns)
             .returning();
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async insertMany(entities) {
-        const transformContext = await this.getTransformContext();
-        const columns = await this.mapManyToInsertColumns(entities, transformContext);
+        const columns = await this.mapManyToInsertColumns(entities);
         const rows = await this.session.insert(this.#table).values(columns).returning();
-        return this.mapManyToEntity(rows, transformContext);
+        return this.mapManyToEntity(rows);
     }
     async upsert(target, entity, update) {
-        const transformContext = await this.getTransformContext();
         const targetColumns = toArray(target).map((path) => this.$getColumn(path));
-        const columns = await this.mapToInsertColumns(entity, transformContext);
-        const mappedUpdate = await this.mapUpdate(update ?? entity, transformContext);
+        const columns = await this.mapToInsertColumns(entity);
+        const mappedUpdate = await this.mapUpdate(update ?? entity);
         const [row] = await this.session
             .insert(this.#table)
             .values(columns)
@@ -244,17 +241,16 @@ let EntityRepository = class EntityRepository {
             set: mappedUpdate
         })
             .returning();
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async upsertMany(target, entities, update) {
-        const transformContext = await this.getTransformContext();
         const targetColumns = toArray(target).map((path) => this.$getColumn(path));
-        const columns = await this.mapManyToInsertColumns(entities, transformContext);
+        const columns = await this.mapManyToInsertColumns(entities);
         const mappedUpdate = isDefined(update)
-            ? await this.mapUpdate(update, transformContext)
+            ? await this.mapUpdate(update)
             : {
                 ...fromEntries(this.#columnDefinitions.map((column) => [column.name, sql `excluded.${sql.identifier(this.$getColumn(column).name)}`])),
-                ...this.getMetadataUpdate(update)
+                ...this._getMetadataUpdate(update)
             };
         const rows = await this.session
             .insert(this.#table)
@@ -264,7 +260,7 @@ let EntityRepository = class EntityRepository {
             set: mappedUpdate
         })
             .returning();
-        return this.mapManyToEntity(rows, transformContext);
+        return this.mapManyToEntity(rows);
     }
     async update(id, update) {
         const entity = await this.tryUpdate(id, update);
@@ -274,8 +270,7 @@ let EntityRepository = class EntityRepository {
         return entity;
     }
     async tryUpdate(id, update) {
-        const transformContext = await this.getTransformContext();
-        const mappedUpdate = await this.mapUpdate(update, transformContext);
+        const mappedUpdate = await this.mapUpdate(update);
         const [row] = await this.session
             .update(this.#table)
             .set(mappedUpdate)
@@ -284,7 +279,7 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async updateByQuery(query, update) {
         const entity = await this.tryUpdateByQuery(query, update);
@@ -294,8 +289,7 @@ let EntityRepository = class EntityRepository {
         return entity;
     }
     async tryUpdateByQuery(query, update) {
-        const transformContext = await this.getTransformContext();
-        const mappedUpdate = await this.mapUpdate(update, transformContext);
+        const mappedUpdate = await this.mapUpdate(update);
         const idQuery = this.getIdLimitSelect(query);
         const [row] = await this.session
             .update(this.#table)
@@ -305,21 +299,20 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async updateMany(ids, update) {
         return this.updateManyByQuery(inArray(this.#table.id, ids), update);
     }
     async updateManyByQuery(query, update) {
-        const transformContext = await this.getTransformContext();
-        const sqlQuery = this.$convertQuery(query);
-        const mappedUpdate = await this.mapUpdate(update, transformContext);
+        const sqlQuery = this.convertQuery(query);
+        const mappedUpdate = await this.mapUpdate(update);
         const rows = await this.session
             .update(this.#table)
             .set(mappedUpdate)
             .where(sqlQuery)
             .returning();
-        return this.mapManyToEntity(rows, transformContext);
+        return this.mapManyToEntity(rows);
     }
     async delete(id, metadataUpdate) {
         const entity = await this.tryDelete(id, metadataUpdate);
@@ -343,8 +336,7 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        const transformContext = await this.getTransformContext();
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async deleteByQuery(query, metadataUpdate) {
         const entity = await this.tryDeleteByQuery(query, metadataUpdate);
@@ -369,8 +361,7 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        const transformContext = await this.getTransformContext();
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async deleteMany(ids, metadataUpdate) {
         return this.deleteManyByQuery(inArray(this.#table.id, ids), metadataUpdate);
@@ -379,7 +370,7 @@ let EntityRepository = class EntityRepository {
         if (!this.hasMetadata) {
             return this.hardDeleteManyByQuery(query);
         }
-        const sqlQuery = this.$convertQuery(query);
+        const sqlQuery = this.convertQuery(query);
         const rows = await this.session
             .update(this.#tableWithMetadata)
             .set({
@@ -388,8 +379,7 @@ let EntityRepository = class EntityRepository {
         })
             .where(sqlQuery)
             .returning();
-        const transformContext = await this.getTransformContext();
-        return this.mapManyToEntity(rows, transformContext);
+        return this.mapManyToEntity(rows);
     }
     async hardDelete(id) {
         const result = await this.tryHardDelete(id);
@@ -406,8 +396,7 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        const transformContext = await this.getTransformContext();
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async hardDeleteByQuery(query) {
         const result = await this.tryHardDeleteByQuery(query);
@@ -425,20 +414,18 @@ let EntityRepository = class EntityRepository {
         if (isUndefined(row)) {
             return undefined;
         }
-        const transformContext = await this.getTransformContext();
-        return this.mapToEntity(row, transformContext);
+        return this.mapToEntity(row);
     }
     async hardDeleteMany(ids) {
         return this.hardDeleteManyByQuery(inArray(this.#table.id, ids));
     }
     async hardDeleteManyByQuery(query) {
-        const sqlQuery = this.$convertQuery(query);
+        const sqlQuery = this.convertQuery(query);
         const rows = await this.session
             .delete(this.#table)
             .where(sqlQuery)
             .returning();
-        const transformContext = await this.getTransformContext();
-        return this.mapManyToEntity(rows, transformContext);
+        return this.mapManyToEntity(rows);
     }
     $getColumn(pathOrColumn) {
         if (isString(pathOrColumn)) {
@@ -463,47 +450,53 @@ let EntityRepository = class EntityRepository {
             return direction == 'asc' ? asc(column) : desc(column);
         });
     }
-    $convertQuery(query) {
+    convertQuery(query) {
         return convertQuery(query, this.#table, this.#columnDefinitionsMap);
     }
-    async $mapManyToEntity(columns) {
+    async mapManyToEntity(columns) {
         const transformContext = await this.getTransformContext();
-        return this.mapManyToEntity(columns, transformContext);
+        return this._mapManyToEntity(columns, transformContext);
     }
-    async $mapToEntity(columns) {
+    async mapToEntity(columns) {
         const transformContext = await this.getTransformContext();
-        return this.mapToEntity(columns, transformContext);
+        return this._mapToEntity(columns, transformContext);
     }
-    async $mapManyToColumns(objects) {
+    async mapManyToColumns(objects) {
         const transformContext = await this.getTransformContext();
-        return this.mapManyToColumns(objects, transformContext);
+        return this._mapManyToColumns(objects, transformContext);
     }
-    async $mapToColumns(obj) {
+    async mapToColumns(obj) {
         const transformContext = await this.getTransformContext();
-        return this.mapToColumns(obj, transformContext);
+        return this._mapToColumns(obj, transformContext);
     }
-    async $mapManyToInsertColumns(objects) {
+    async mapManyToInsertColumns(objects) {
         const transformContext = await this.getTransformContext();
-        return this.mapManyToInsertColumns(objects, transformContext);
+        return this._mapManyToInsertColumns(objects, transformContext);
     }
-    async $mapToInsertColumns(obj) {
+    async mapToInsertColumns(obj) {
         const transformContext = await this.getTransformContext();
-        return this.mapToInsertColumns(obj, transformContext);
+        return this._mapToInsertColumns(obj, transformContext);
     }
-    async $mapUpdate(update) {
+    async mapUpdate(update) {
         const transformContext = await this.getTransformContext();
-        return this.mapUpdate(update, transformContext);
+        return this._mapUpdate(update, transformContext);
     }
-    $getIdLimitQuery(query) {
+    getIdLimitQuery(query) {
         return this.getIdLimitSelect(query);
     }
-    $getAttributesUpdate(attributes) {
-        return this.getAttributesUpdate(attributes);
+    getAttributesUpdate(attributes) {
+        if (isUndefined(attributes)) {
+            return undefined;
+        }
+        if (attributes instanceof SQL) {
+            return attributes;
+        }
+        return sql `${this.#tableWithMetadata.attributes} || ${JSON.stringify(attributes)}::jsonb`;
     }
-    async mapManyToEntity(columns, transformContext) {
-        return toArrayAsync(mapAsync(columns, async (column) => this.mapToEntity(column, transformContext)));
+    async _mapManyToEntity(columns, transformContext) {
+        return toArrayAsync(mapAsync(columns, async (column) => this._mapToEntity(column, transformContext)));
     }
-    async mapToEntity(columns, transformContext) {
+    async _mapToEntity(columns, transformContext) {
         const entries = [];
         for (const def of this.#columnDefinitions) {
             const rawValue = columns[def.name];
@@ -513,10 +506,10 @@ let EntityRepository = class EntityRepository {
         const obj = fromDeepObjectEntries(entries);
         return Schema.parse(this.type, obj);
     }
-    async mapManyToColumns(objects, transformContext) {
-        return toArrayAsync(mapAsync(objects, async (obj) => this.mapToColumns(obj, transformContext)));
+    async _mapManyToColumns(objects, transformContext) {
+        return toArrayAsync(mapAsync(objects, async (obj) => this._mapToColumns(obj, transformContext)));
     }
-    async mapToColumns(obj, transformContext) {
+    async _mapToColumns(obj, transformContext) {
         const columns = {};
         for (const def of this.#columnDefinitions) {
             const rawValue = def.dereferenceObjectPath(obj);
@@ -524,11 +517,11 @@ let EntityRepository = class EntityRepository {
         }
         return columns;
     }
-    async mapManyToInsertColumns(objects, transformContext) {
-        return toArrayAsync(mapAsync(objects, async (obj) => this.mapToInsertColumns(obj, transformContext)));
+    async _mapManyToInsertColumns(objects, transformContext) {
+        return toArrayAsync(mapAsync(objects, async (obj) => this._mapToInsertColumns(obj, transformContext)));
     }
-    async mapToInsertColumns(obj, transformContext) {
-        const mapped = await this.mapToColumns(obj, transformContext);
+    async _mapToInsertColumns(obj, transformContext) {
+        const mapped = await this._mapToColumns(obj, transformContext);
         return {
             ...mapped,
             ...(this.hasMetadata
@@ -540,7 +533,7 @@ let EntityRepository = class EntityRepository {
                 : undefined)
         };
     }
-    async mapUpdate(update, transformContext) {
+    async _mapUpdate(update, transformContext) {
         const mappedUpdate = {};
         for (const column of this.#columnDefinitions) {
             const value = column.dereferenceObjectPath(update);
@@ -551,10 +544,10 @@ let EntityRepository = class EntityRepository {
         }
         return {
             ...mappedUpdate,
-            ...this.getMetadataUpdate(update)
+            ...this._getMetadataUpdate(update)
         };
     }
-    getMetadataUpdate(update) {
+    _getMetadataUpdate(update) {
         return this.hasMetadata
             ? {
                 attributes: this.getAttributesUpdate(update?.metadata?.attributes),
@@ -564,21 +557,12 @@ let EntityRepository = class EntityRepository {
             : undefined;
     }
     getIdLimitSelect(query) {
-        const sqlQuery = this.$convertQuery(query);
+        const sqlQuery = this.convertQuery(query);
         return this.session.select({ id: this.#table.id })
             .from(this.#table)
             .where(sqlQuery)
             .limit(1);
     }
-    getAttributesUpdate(attributes) {
-        if (isUndefined(attributes)) {
-            return undefined;
-        }
-        if (attributes instanceof SQL) {
-            return attributes;
-        }
-        return sql `${this.#tableWithMetadata.attributes} || ${JSON.stringify(attributes)}::jsonb`;
-    }
     async getTransformContext() {
         if (isUndefined(this.#transformContext)) {
             if (isUndefined(this.#encryptionSecret)) {

package/orm/{server/sqls.d.ts → sqls.d.ts}

@@ -1,9 +1,9 @@
 import { type Column, type SQL } from 'drizzle-orm';
 import type { GetSelectTableSelection, SelectResultField, TableLike } from 'drizzle-orm/query-builders/select.types';
-import type { Uuid } from '../types.js';
+import type { Uuid } from './types.js';
 export declare const TRANSACTION_TIMESTAMP: SQL<Date>;
 export declare const RANDOM_UUID: SQL<Uuid>;
-type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
+export type IntervalUnit = 'millennium' | 'millenniums' | 'millennia' | 'century' | 'centuries' | 'decade' | 'decades' | 'year' | 'years' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds' | 'microsecond' | 'microseconds';
 export declare function interval(value: number, unit: IntervalUnit): SQL;
 export declare function arrayAgg<T extends Column>(column: T): SQL<SelectResultField<T>[]>;
 export declare function jsonAgg<T extends TableLike>(tableOrColumn: T): SQL<SelectResultField<GetSelectTableSelection<T>>[]>;
@@ -12,4 +12,5 @@ export declare namespace jsonAgg {
 }
 export declare function coalesce<T extends (Column | SQL)[]>(...columns: T): SQL<SelectResultField<T>[number]>;
 export declare function toJsonb<T extends (Column | SQL)>(column: T): SQL<SelectResultField<T>>;
-export {};
+export declare function numNulls(...columns: Column[]): SQL<number>;
+export declare function numNonNulls(...columns: Column[]): SQL<number>;

package/orm/{server/sqls.js → sqls.js}

@@ -17,3 +17,9 @@ export function coalesce(...columns) {
 export function toJsonb(column) {
     return sql `to_jsonb(${column})`;
 }
+export function numNulls(...columns) {
+    return sql `num_nulls(${sql.join(columns, sql.raw(', '))})`;
+}
+export function numNonNulls(...columns) {
+    return sql `num_nonnulls(${sql.join(columns, sql.raw(', '))})`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.88",
+  "version": "0.92.90",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -173,7 +173,7 @@
     "mongodb": "^6.14",
     "nodemailer": "^6.10",
     "pg": "^8.13",
-    "playwright": "^1.50",
+    "playwright": "^1.51",
     "preact": "^10.26",
     "preact-render-to-string": "^6.5",
     "undici": "^7.4",

package/queue/postgres/queue.js

@@ -9,7 +9,8 @@ import { merge } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/index.js';
 import { inject, injectArgument, provide, Singleton } from '../../injector/index.js';
 import { MessageBus } from '../../message-bus/index.js';
-import { DatabaseConfig, EntityRepositoryConfig, injectRepository, interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/server/index.js';
+import { interval, RANDOM_UUID, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../orm/server/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { isDefined, isString } from '../../utils/type-guards.js';
 import { millisecondsPerSecond } from '../../utils/units.js';
@@ -102,9 +103,9 @@ let PostgresQueue = class PostgresQueue extends Queue {
             .where(this.#dequeueQuery)
             .orderBy(asc(job.priority), asc(job.enqueueTimestamp), asc(job.lastDequeueTimestamp), asc(job.tries))
             .limit(count)
-            .for('update')))
+            .for('update', { skipLocked: true })))
             .returning();
-        return this.#repository.$mapManyToEntity(rows); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+        return this.#repository.mapManyToEntity(rows);
     }
     async acknowledge(job) {
         return this.cancel(job.id);