@tstdl/base 0.93.17 → 0.93.19

package/authentication/server/authentication.service.js

@@ -630,7 +630,7 @@ AuthenticationService = AuthenticationService_1 = __decorate([
     Singleton({
         providers: [
             provide(EntityRepositoryConfig, { useValue: { schema: 'authentication' } }),
-            { provide: DatabaseConfig, useFactory: (_, context) => context.resolve(AuthenticationModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) },
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(AuthenticationModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],
     })
 ], AuthenticationService);

package/injector/decorators.js

@@ -2,7 +2,7 @@
 import { createClassDecorator, createDecorator, reflectionRegistry } from '../reflection/index.js';
 import { toArray } from '../utils/array/array.js';
 import { filterObject } from '../utils/object/object.js';
-import { isArray, isDefined, isFunction, isNotNull } from '../utils/type-guards.js';
+import { isArray, isDefined, isFunction, isNotNull, isPromise } from '../utils/type-guards.js';
 import { Injector } from './injector.js';
 import { injectMetadataSymbol, injectableMetadataSymbol, injectableOptionsSymbol } from './symbols.js';
 /**
@@ -46,8 +46,11 @@ export function Injectable(options = {}) {
                         ...registrationOptions,
                         providers: [...(optionsToInherit.providers ?? []), ...(registrationOptions.providers ?? [])],
                         afterResolve: (instance, argument, context) => {
-                            optionsToInherit.afterResolve?.(instance, argument, context);
-                            registrationOptions.afterResolve?.(instance, argument, context);
+                            const result1 = optionsToInherit.afterResolve?.(instance, argument, context);
+                            if (isPromise(result1)) {
+                                return result1.then(async () => await registrationOptions.afterResolve?.(instance, argument, context)); // eslint-disable-line @typescript-eslint/no-unsafe-return
+                            }
+                            return registrationOptions.afterResolve?.(instance, argument, context);
                         },
                         metadata: {
                             ...optionsToInherit.metadata,

package/injector/injector.js

@@ -152,7 +152,7 @@ export class Injector {
             }
         }
         if (options?.onlySelf != true) {
-            return this.#parent?.tryGetRegistration(token);
+            return this.#parent?.tryGetRegistration(token, { ...options, skipSelf: false });
         }
         return undefined;
     }
@@ -280,14 +280,11 @@ export class Injector {
         if (isUndefined(token)) {
             throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
         }
-        const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
+        const registration = this.tryGetRegistration(token, options);
         if (isDefined(registration)) {
             const singleRegistration = isArray(registration) ? registration[0] : registration;
             return this._resolveRegistration(singleRegistration, argument, options, context, chain);
         }
-        if (isNotNull(this.#parent) && (options.onlySelf != true)) {
-            return this.#parent._resolve(token, argument, { ...options, skipSelf: false }, context, chain);
-        }
         if (options.optional == true) {
             return undefined;
         }
@@ -305,49 +302,55 @@ export class Injector {
         if (isUndefined(token)) {
             throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
         }
-        const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
-        if (isDefined(registration)) {
-            const registrations = isArray(registration) ? registration : [registration];
-            return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
+        const ownValues = [];
+        const parentValues = [];
+        if (options.skipSelf != true) {
+            const registration = this.tryGetRegistration(token, { onlySelf: true });
+            if (isDefined(registration)) {
+                const registrations = isArray(registration) ? registration : [registration];
+                const resolved = registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
+                ownValues.push(...resolved);
+            }
         }
         if (isNotNull(this.#parent) && (options.onlySelf != true)) {
-            return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
+            parentValues.push(...this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain));
         }
-        if (options.optional == true) {
-            return [];
+        const allValues = [...ownValues, ...parentValues];
+        if ((allValues.length == 0) && (options.optional != true)) {
+            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
         }
-        throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        return allValues;
     }
     _resolveRegistration(registration, argument, options, context, chain) {
         checkOverflow(chain, context);
         const { token, provider, providers } = registration;
+        const resolutionTag = Symbol('ResolutionTag');
+        const resolutionScoped = registration.options.lifecycle == 'resolution';
+        const injectorScoped = registration.options.lifecycle == 'injector';
+        const singletonScoped = registration.options.lifecycle == 'singleton';
+        let resolveArgument = argument ?? registration.options.defaultArgument;
+        if (isUndefined(resolveArgument) && isFunction(registration.options.defaultArgumentProvider)) {
+            resolveArgument = wrapInResolveError(() => registration.options.defaultArgumentProvider(this.getResolveContext(resolutionTag, context, chain)), 'Error in defaultArgumentProvider', chain);
+        }
+        const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument, chain);
+        if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
+            return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
+        }
+        else if (injectorScoped && this.#injectorScopedResolutions.hasFlat(token, argumentIdentity)) {
+            return this.#injectorScopedResolutions.getFlat(token, argumentIdentity).value;
+        }
+        else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
+            return registration.resolutions.get(argumentIdentity);
+        }
         // A new scope is only needed if we are instantiating a class, running a factory, or if the registration explicitly defines scoped providers.
         const needsNewScope = isClassProvider(provider) || isFactoryProvider(provider) || (providers.length > 0);
         const injector = needsNewScope ? this.fork('ResolutionInjector') : this;
         for (const nestedProvider of providers) {
             injector.registerSingleton(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
         }
-        const injectionContext = injector.getInjectionContext(context, argument, chain);
+        const injectionContext = injector.getInjectionContext(context, resolveArgument, chain);
         const previousInjectionContext = setCurrentInjectionContext(injectionContext);
-        const resolutionTag = Symbol('ResolutionTag');
         try {
-            const resolutionScoped = registration.options.lifecycle == 'resolution';
-            const injectorScoped = registration.options.lifecycle == 'injector';
-            const singletonScoped = registration.options.lifecycle == 'singleton';
-            let resolveArgument = argument ?? registration.options.defaultArgument;
-            if (isUndefined(resolveArgument) && isFunction(registration.options.defaultArgumentProvider)) {
-                resolveArgument = wrapInResolveError(() => registration.options.defaultArgumentProvider(injector.getResolveContext(resolutionTag, context, chain)), 'Error in defaultArgumentProvider', chain);
-            }
-            const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument, chain);
-            if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
-                return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
-            }
-            else if (injectorScoped && this.#injectorScopedResolutions.hasFlat(token, argumentIdentity)) {
-                return this.#injectorScopedResolutions.getFlat(token, argumentIdentity).value;
-            }
-            else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
-                return registration.resolutions.get(argumentIdentity);
-            }
             const resolutionContext = { afterResolveRegistrations: [] };
             const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, resolutionContext, injectionContext, chain);
             const resolution = {

package/mail/module.js

@@ -31,6 +31,6 @@ export async function migrateMailSchema() {
     await migrate(database, {
         migrationsSchema: 'mail',
         migrationsTable: '_migrations',
-        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', '')
+        migrationsFolder: import.meta.resolve('./drizzle').replace('file://', ''),
     });
 }

package/orm/data-types/numeric-date.js

@@ -4,7 +4,7 @@
  * using numeric representation (YYYYMMDD).
  */
 import { customType } from 'drizzle-orm/pg-core';
-import { dateToNumericDate, numericDateToDate } from '../../utils/date-time.js';
+import { dateToNumericDate, numericDateToDateObject } from '../../utils/date-time.js';
 /**
  * Custom Drizzle type for PostgreSQL `date` columns, storing dates as numeric values (YYYYMMDD).
  * Converts between JavaScript `number` (YYYYMMDD) and database `date` (ISO string).
@@ -14,7 +14,11 @@ export const numericDate = customType({
         return 'date';
     },
     toDriver(value) {
-        return numericDateToDate(value).toISOString();
+        const { year, month, day } = numericDateToDateObject(value);
+        const yearString = year.toString().padStart(4, '0');
+        const monthString = month.toString().padStart(2, '0');
+        const dayString = day.toString().padStart(2, '0');
+        return `${yearString}-${monthString}-${dayString}`;
     },
     fromDriver(value) {
         const date = new Date(value);

package/package.json

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