@tstdl/base 0.92.48 → 0.92.50

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

@@ -10,7 +10,7 @@ import { BadRequestError } from '../../../errors/index.js';
 import { getMimeType, getMimeTypeExtensions } from '../../../file/index.js';
 import { Singleton, inject, injectArgument, provide, resolveArgumentType } from '../../../injector/index.js';
 import { ObjectStorage } from '../../../object-storage/index.js';
-import { DATABASE_CONFIG, EntityRepositoryConfig, injectRepository } from '../../../orm/server/index.js';
+import { DatabaseConfig, EntityRepositoryConfig, injectRepository } from '../../../orm/server/index.js';
 import { toArray } from '../../../utils/array/index.js';
 import { assertDefinedPass, compareByValueSelectionToOrder, currentTimestamp, digest, isBoolean, isDefined, isNotNull, isNull, isNumber, isString, isUint8Array, millisecondsPerMinute } from '../../../utils/index.js';
 import { groupToMap } from '../../../utils/iterable-helpers/index.js';
@@ -354,7 +354,7 @@ DocumentManagementService = __decorate([
     Singleton({
         providers: [
             provide(EntityRepositoryConfig, { useValue: { schema: 'document_management' } }),
-            { provide: DATABASE_CONFIG, useFactory: (_, context) => context.resolve(DocumentManagementConfig).database }
+            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(DocumentManagementConfig).database }
         ]
     })
 ], DocumentManagementService);

package/orm/server/database.d.ts

@@ -1,6 +1,7 @@
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import type { PoolConfig } from 'pg';
 import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { DatabaseArgument } from './module.js';
+export type DatabaseArgument = string | PoolConfig;
 export declare class Database extends NodePgDatabase<any> implements Resolvable<DatabaseArgument> {
     readonly [resolveArgumentType]?: DatabaseArgument;
 }

package/orm/server/database.js

@@ -4,11 +4,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { ReplaceClass } from '../../injector/decorators.js';
+import { drizzle, NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { inject, Injector, ReplaceClass } from '../../injector/index.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { DatabaseConfig } from './module.js';
 let Database = class Database extends NodePgDatabase {
 };
 Database = __decorate([
     ReplaceClass(NodePgDatabase)
 ], Database);
 export { Database };
+Injector.registerSingleton(Database, {
+    useFactory: (argument) => {
+        const connection = argument ?? inject(DatabaseConfig, undefined, { optional: true })?.connection;
+        if (isUndefined(connection)) {
+            throw new Error('Missing postgres connection. Provide it either via injection argument or provider.');
+        }
+        return drizzle({ connection });
+    }
+});

package/orm/server/module.d.ts

@@ -1,6 +1,10 @@
 import type { PoolConfig } from 'pg';
-export type DatabaseConfig = {
-    connection: DatabaseArgument;
+import { EntityRepositoryConfig } from './repository.js';
+export declare class DatabaseConfig {
+    connection?: string | PoolConfig;
+}
+export type OrmModuleOptions = {
+    connection?: string | PoolConfig;
+    repositoryConfig?: EntityRepositoryConfig;
 };
-export type DatabaseArgument = string | PoolConfig;
-export declare const DATABASE_CONFIG: import("../../injector/index.js").InjectionToken<DatabaseConfig, never>;
+export declare function configureOrm(options: OrmModuleOptions): void;

package/orm/server/module.js

@@ -1,15 +1,14 @@
-import { drizzle } from 'drizzle-orm/node-postgres';
-import { inject, injectionToken } from '../../injector/index.js';
 import { Injector } from '../../injector/injector.js';
-import { isUndefined } from '../../utils/type-guards.js';
-import { Database } from './database.js';
-export const DATABASE_CONFIG = injectionToken('EntityRepositoryConfig');
-Injector.registerSingleton(Database, {
-    useFactory: (argument) => {
-        const connection = argument ?? inject(DATABASE_CONFIG, undefined, { optional: true })?.connection;
-        if (isUndefined(connection)) {
-            throw new Error('Missing postgres connection. Provide it either via injection argument or provider.');
-        }
-        return drizzle({ connection });
+import { isDefined } from '../../utils/type-guards.js';
+import { EntityRepositoryConfig } from './repository.js';
+export class DatabaseConfig {
+    connection;
+}
+export function configureOrm(options) {
+    if (isDefined(options.connection)) {
+        Injector.register(DatabaseConfig, { useValue: { connection: options.connection } });
     }
-});
+    if (isDefined(options.repositoryConfig)) {
+        Injector.register(EntityRepositoryConfig, { useValue: options.repositoryConfig });
+    }
+}

package/orm/server/repository.d.ts

@@ -12,7 +12,7 @@ import { type Transaction, type TransactionConfig } from './transaction.js';
 type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export declare const repositoryType: unique symbol;
 export type OrderOptions<T extends Entity> = {
-    order?: Partial<Record<Paths<T>, 1 | -1 | 'asc' | 'desc'>>;
+    order?: Partial<Record<Paths<UntaggedDeep<T>>, 1 | -1 | 'asc' | 'desc'>>;
 };
 export type LoadOptions<T extends Entity> = OrderOptions<T> & {
     offset?: number;
@@ -63,8 +63,8 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
     hasAll(ids: string[]): Promise<boolean>;
     insert(entity: NewEntity<T>): Promise<T>;
     insertMany(entities: NewEntity<T>[]): Promise<T[]>;
-    upsert(target: OneOrMany<Extract<keyof T, string>>, entity: NewEntity<T>, update?: EntityUpdate<T>): Promise<T>;
-    upsertMany(target: OneOrMany<Extract<keyof T, string>>, entities: NewEntity<T>[], update: EntityUpdate<T>): Promise<T[]>;
+    upsert(target: OneOrMany<Paths<UntaggedDeep<T>>>, entity: NewEntity<T>, update?: EntityUpdate<T>): Promise<T>;
+    upsertMany(target: OneOrMany<Paths<UntaggedDeep<T>>>, entities: NewEntity<T>[], update: EntityUpdate<T>): Promise<T[]>;
     update(id: string, update: EntityUpdate<T>): Promise<T>;
     tryUpdate(id: string, update: EntityUpdate<T>): Promise<T | undefined>;
     updateByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<T>;

package/orm/server/repository.js

@@ -390,7 +390,7 @@ let EntityRepository = class EntityRepository {
             ...mappedUpdate,
             attributes: this.getAttributesUpdate(update.metadata?.attributes),
             revision: sql `${this.table.revision} + 1`,
-            revisionTimestamp: sql `transaction_timestamp()`
+            revisionTimestamp: TRANSACTION_TIMESTAMP
         };
     }
     getIdLimitQuery(query) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.48",
+  "version": "0.92.50",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/types/tagged.d.ts

@@ -11,6 +11,6 @@ export type Tagged<Type = unknown, TagName extends PropertyKey = PropertyKey, Ta
 export type GetTagMetadata<Type extends Tag<unknown, TagName, unknown>, TagName extends PropertyKey> = NonNullable<Type[typeof tag]>[TagName];
 export type UnwrapTagged<TaggedType extends Tag<unknown, PropertyKey, any>> = TaggedType extends Tagged<infer Type, PropertyKey, any> ? Type : never;
 export type Untagged<T> = T extends Tagged ? UnwrapTagged<T> : T;
-export type UntaggedDeep<T> = T extends Tagged ? UnwrapTagged<T> : T extends readonly (infer U)[] ? UntaggedDeep<U>[] : T extends Record ? {
-    [P in keyof T]: UntaggedDeep<T[P]>;
+export type UntaggedDeep<T> = Untagged<T> extends any[] | Record ? {
+    [P in keyof Untagged<T>]: UntaggedDeep<Untagged<T>[P]>;
 } : Untagged<T>;

package/types.d.ts

@@ -190,7 +190,7 @@ export type DeepPartialArray<T> = DeepPartial<T>[];
 export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
 export type BinaryData = ArrayBuffer | ArrayBufferView;
 export type Paths<T extends Record> = T extends object ? {
-    [K in keyof T]-?: K extends string | number ? K | `${K}.${Paths<T[K]>}` : never;
+    [K in keyof T]-?: K extends string | number ? `${K}` | `${K}.${Paths<T[K]>}` : never;
 }[keyof T] : never;
 export type TypeFromPath<T extends Record, Path extends Paths<T> | string> = {
     [K in Path]: K extends keyof T ? T[K] : K extends `${infer P}.${infer S}` ? T[P] extends Record ? TypeFromPath<T[P], S> : never : never;