@tstdl/base 0.92.68 → 0.92.70

package/orm/decorators.d.ts

@@ -4,6 +4,7 @@ import type { EntityType } from './entity.js';
 type IndexMethod = LiteralUnion<'hash' | 'btree' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hnsw' | 'ivfflat', string>;
 export type OrmTableReflectionData = {
     name?: string;
+    schema?: string;
     unique?: UniqueReflectionData[];
     index?: IndexReflectionData[];
 };
@@ -47,9 +48,9 @@ export declare function PrimaryKey(): PropertyDecorator;
 export declare function References(type: () => EntityType): PropertyDecorator;
 export declare function Encrypted(): PropertyDecorator;
 export declare function Embedded(type: AbstractConstructor, options?: TypedOmit<NonNullable<OrmColumnReflectionData['embedded']>, 'type'>): PropertyDecorator;
-export declare function Table(options?: string | {
-    name: string;
-}): ClassDecorator;
+type TableOptions = Partial<Pick<OrmTableReflectionData, 'name' | 'schema'>>;
+export declare function Table(name?: string, options?: TypedOmit<TableOptions, 'schema'>): ClassDecorator;
+export declare function Table(options?: TableOptions): ClassDecorator;
 export declare function Unique(name?: string, options?: UniqueReflectionData['options']): PropertyDecorator;
 export declare function Unique(name: string | undefined, columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;
 export declare function Unique(columns: [string, ...string[]], options?: UniqueReflectionData['options']): ClassDecorator;

package/orm/decorators.js

@@ -1,6 +1,5 @@
 import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/utils.js';
 import { Property } from '../schema/index.js';
-import { filterUndefinedObjectProperties } from '../utils/object/object.js';
 import { assertNotArrayPass, isArray, isString } from '../utils/type-guards.js';
 export function createTableDecorator(data) {
     return createClassDecorator({ data: { orm: data }, mergeData: true });
@@ -28,8 +27,10 @@ export function Embedded(type, options) {
         include: [Property(type), createColumnDecorator({ embedded: { type, ...options } })]
     });
 }
-export function Table(options) {
-    return createTableDecorator(filterUndefinedObjectProperties({ name: isString(options) ? options : options?.name }));
+export function Table(nameOrOptions, optionsOrNothing) {
+    const name = isString(nameOrOptions) ? nameOrOptions : nameOrOptions?.name;
+    const schema = isString(nameOrOptions) ? optionsOrNothing?.schema : nameOrOptions?.schema;
+    return createTableDecorator({ name, schema });
 }
 export function Unique(nameOrColumns, columnsOrOptions, options) {
     if (isArray(nameOrColumns)) {

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

@@ -8,7 +8,7 @@ type ConverterContext = {
 };
 export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
 export declare function getColumnDefinitions(table: PgTableWithColumns<any>): ColumnDefinition[];
-export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, schemaName: S): PgTableFromType<S, T>;
+export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, schemaName?: S): PgTableFromType<S, T>;
 export declare function registerEnum(enumeration: Enumeration, name: string): void;
 export declare function getPgEnum(schema: string | PgSchema, enumeration: Enumeration, context?: ConverterContext): PgEnum<[string, ...string[]]>;
 export {};

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

@@ -28,9 +28,10 @@ export function getColumnDefinitions(table) {
 export function _getDrizzleTableFromType(type, schemaName) {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-    const dbSchema = getDbSchema(schemaName);
     const tableReflectionData = metadata.data.tryGet('orm');
+    const schema = assertDefinedPass(schemaName ?? tableReflectionData?.schema, 'Table schema not provided');
     const tableName = tableReflectionData?.name ?? getDefaultTableName(type);
+    const dbSchema = getDbSchema(schema);
     const columnDefinitions = getPostgresColumnEntries(type, tableName, dbSchema);
     function getColumn(table, propertyName) {
         return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);

package/orm/server/repository.d.ts

@@ -30,7 +30,6 @@ export declare class EntityRepositoryConfig {
     schema: string;
 }
 export type TransactionHandler<T extends Entity, R> = (repository: EntityRepository<T>, transaction: Transaction) => Promise<R>;
-export declare const ENTITY_TYPE: import("../../injector/token.js").InjectionToken<EntityType<any>, never>;
 export declare class EntityRepository<T extends Entity = Entity> implements Resolvable<EntityType<T>> {
     #private;
     readonly type: EntityType<T>;
@@ -113,5 +112,5 @@ export declare class EntityRepository<T extends Entity = Entity> implements Reso
     protected getTransformContext(): Promise<TransformContext>;
 }
 export declare function injectRepository<T extends Entity>(type: EntityType<T>): EntityRepository<T>;
-export declare function getRepository<T extends Entity>(type: EntityType<T>, config?: EntityRepositoryConfig): Type<EntityRepository<T>>;
+export declare function getRepository<T extends Entity>(type: EntityType<T>): Type<EntityRepository<T>>;
 export {};

package/orm/server/repository.js

@@ -15,7 +15,6 @@ import { NotFoundError } from '../../errors/not-found.error.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';
 import { Schema } from '../../schema/schema.js';
 import { toArray } from '../../utils/array/array.js';
 import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
@@ -32,15 +31,13 @@ export const repositoryType = Symbol('repositoryType');
 export class EntityRepositoryConfig {
     schema;
 }
-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');
+const { getCurrentEntityRepositoryContext, runInEntityRepositoryContext, isInEntityRepositoryContext } = createContextProvider('EntityRepository');
 let EntityRepository = class EntityRepository {
     #repositoryConstructor;
     #withTransactionCache = new WeakMap();
-    #encryptionSecret = inject(ENCRYPTION_SECRET, undefined, { optional: true });
+    #encryptionSecret = isInEntityRepositoryContext() ? getCurrentEntityRepositoryContext()?.encryptionSecret : inject(ENCRYPTION_SECRET, undefined, { optional: true });
     #transformContext;
     type;
     table;
@@ -50,14 +47,14 @@ let EntityRepository = class EntityRepository {
     isInTransaction;
     constructor() {
         this.#repositoryConstructor = new.target;
-        const entityRepositoryConfig = new.target[entityRepositoryConfigToken] ?? inject(EntityRepositoryConfig);
-        const { type, table, columnDefinitions, columnDefinitionsMap, session } = getCurrentEntityRepositoryContext() ?? {};
+        const { type, table, columnDefinitions, columnDefinitionsMap, session, transformContext } = getCurrentEntityRepositoryContext() ?? {};
         this.type = type ?? injectArgument(this, { optional: true }) ?? assertDefinedPass(new.target[entityTypeToken], 'Missing entity type.');
-        this.table = table ?? getDrizzleTableFromType(this.type, entityRepositoryConfig.schema);
+        this.table = table ?? getDrizzleTableFromType(this.type, inject(EntityRepositoryConfig).schema);
         this.columnDefinitions = columnDefinitions ?? getColumnDefinitions(this.table);
         this.columnDefinitionsMap = columnDefinitionsMap ?? new Map(this.columnDefinitions.map((column) => [column.objectPath.path, column]));
         this.session = session ?? inject(Database);
         this.isInTransaction = this.session instanceof DrizzlePgTransaction;
+        this.#transformContext = transformContext;
     }
     withOptionalTransaction(transaction) {
         if (isUndefined(transaction)) {
@@ -74,7 +71,9 @@ let EntityRepository = class EntityRepository {
             table: this.table,
             columnDefinitions: this.columnDefinitions,
             columnDefinitionsMap: this.columnDefinitionsMap,
-            session: transaction.transaction
+            session: transaction.transaction,
+            encryptionSecret: this.#encryptionSecret,
+            transformContext: this.#transformContext
         };
         const repositoryWithTransaction = runInEntityRepositoryContext(context, () => new this.#repositoryConstructor());
         this.#withTransactionCache.set(transaction, repositoryWithTransaction);
@@ -469,12 +468,11 @@ export { EntityRepository };
 export function injectRepository(type) {
     return inject((EntityRepository), type);
 }
-export function getRepository(type, config) {
+export function getRepository(type) {
     const className = `${type.name}Service`;
     const entityRepositoryClass = {
         [className]: class extends EntityRepository {
             static [entityTypeToken] = type;
-            static [entityRepositoryConfigToken] = config;
         }
     }[className];
     Singleton()(entityRepositoryClass);

package/package.json

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