@tstdl/base 0.93.16 → 0.93.18

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

@@ -320,32 +320,34 @@ export class Injector {
     }
     _resolveRegistration(registration, argument, options, context, chain) {
         checkOverflow(chain, context);
-        const { token, providers } = registration;
-        const injector = this.fork('ResolutionInjector');
+        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/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.16",
+  "version": "0.93.18",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"