@tstdl/base 0.92.64 → 0.92.65

package/context/context.d.ts

@@ -1,18 +1,18 @@
-import type { SimplifyObject } from '../types.js';
+import type { Function, SimplifyObject } from '../types.js';
 /**
  * Creates a new context provider
  * @param name name of of the context used for function names
  */
-export declare function createContextProvider<Context, const Name extends string>(name: Name): SimplifyObject<{ [P in `getCurrent${Name}Context`]: {
+export declare function createContextProvider<Context, const Name extends string>(name: Name): SimplifyObject<Record<`getCurrent${Name}Context`, {
     (required: true, debugFn: Function): Context;
-    (required?: false | undefined, debugFn?: Function): Context | null;
+    (required?: false, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;
-}; } & { [P in `setCurrent${Name}Context`]: (context: Context | null) => Context | null; } & { [P in `runIn${Name}Context`]: <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT; } & { [P in `isIn${Name}Context`]: {
+}> & Record<`setCurrent${Name}Context`, (context: Context | null) => Context | null> & Record<`runIn${Name}Context`, <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT> & Record<`isIn${Name}Context`, {
     (required: true, debugFn: Function): Context;
-    (required?: false | undefined, debugFn?: Function): Context | null;
+    (required?: false, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;
-}; } & { [P in `assertIn${Name}Context`]: {
+}> & Record<`assertIn${Name}Context`, {
     (required: true, debugFn: Function): Context;
-    (required?: false | undefined, debugFn?: Function): Context | null;
+    (required?: false, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;
-}; }>;
+}>>;

package/orm/server/repository.d.ts

@@ -40,7 +40,7 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
     readonly session: Database | PgTransaction;
     readonly isInTransaction: boolean;
     readonly [resolveArgumentType]: EntityType<T>;
-    constructor(type?: EntityType<T>, table?: PgTableFromType<string, EntityType>, columnDefinitions?: ColumnDefinition[], columnDefinitionsMap?: Map<string, ColumnDefinition>, session?: Database | PgTransaction);
+    constructor();
     withOptionalTransaction(transaction: Transaction | undefined): EntityRepository<T>;
     withTransaction(transaction: Transaction): EntityRepository<T>;
     startTransaction(config?: TransactionConfig): Promise<Transaction>;

package/orm/server/repository.js

@@ -8,13 +8,11 @@ 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);
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 import { count, eq, inArray, sql } from 'drizzle-orm';
 import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
+import { createContextProvider } from '../../context/context.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
-import { Optional, Singleton } from '../../injector/decorators.js';
+import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
 import { resolveArgumentType } from '../../injector/interfaces.js';
 import { injectionToken } from '../../injector/token.js';
@@ -38,6 +36,7 @@ export const ENTITY_TYPE = injectionToken('EntityType');
 const entityTypeToken = Symbol('EntityType');
 const entityRepositoryConfigToken = Symbol('EntityRepositoryConfig');
 const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
+const { getCurrentEntityRepositoryContext, runInEntityRepositoryContext } = createContextProvider('EntityRepository');
 let EntityRepository = class EntityRepository {
     #repositoryConstructor;
     #withTransactionCache = new WeakMap();
@@ -49,9 +48,10 @@ let EntityRepository = class EntityRepository {
     columnDefinitionsMap;
     session;
     isInTransaction;
-    constructor(type, table, columnDefinitions, columnDefinitionsMap, session) {
+    constructor() {
         this.#repositoryConstructor = new.target;
         const entityRepositoryConfig = new.target[entityRepositoryConfigToken] ?? inject(EntityRepositoryConfig);
+        const { type, table, columnDefinitions, columnDefinitionsMap, session } = getCurrentEntityRepositoryContext() ?? {};
         this.type = type ?? injectArgument(this, { optional: true }) ?? assertDefinedPass(new.target[entityTypeToken], 'Missing entity type.');
         this.table = table ?? getDrizzleTableFromType(this.type, entityRepositoryConfig.schema);
         this.columnDefinitions = columnDefinitions ?? getColumnDefinitions(this.table);
@@ -69,7 +69,14 @@ let EntityRepository = class EntityRepository {
         if (this.#withTransactionCache.has(transaction)) {
             return this.#withTransactionCache.get(transaction);
         }
-        const repositoryWithTransaction = new this.#repositoryConstructor(this.type, this.table, this.columnDefinitions, this.columnDefinitionsMap, transaction.transaction);
+        const context = {
+            type: this.type,
+            table: this.table,
+            columnDefinitions: this.columnDefinitions,
+            columnDefinitionsMap: this.columnDefinitionsMap,
+            session: transaction.transaction
+        };
+        const repositoryWithTransaction = runInEntityRepositoryContext(context, () => new this.#repositoryConstructor());
         this.#withTransactionCache.set(transaction, repositoryWithTransaction);
         return repositoryWithTransaction;
     }
@@ -456,12 +463,7 @@ let EntityRepository = class EntityRepository {
 };
 EntityRepository = __decorate([
     Singleton(),
-    __param(0, Optional()),
-    __param(1, Optional()),
-    __param(2, Optional()),
-    __param(3, Optional()),
-    __param(4, Optional()),
-    __metadata("design:paramtypes", [Object, Object, Array, Map, Object])
+    __metadata("design:paramtypes", [])
 ], EntityRepository);
 export { EntityRepository };
 export function injectRepository(type) {

package/package.json

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