@tstdl/base 0.83.4 → 0.83.6

package/authentication/server/authentication.service.js

@@ -74,7 +74,7 @@ class AuthenticationServiceOptions {
   /** How long a secret reset token is valid. */
   secretResetTokenTimeToLive;
 }
-const SIGNING_SECRETS_LENGTH = 512;
+const SIGNING_SECRETS_LENGTH = 64;
 let AuthenticationService = class AuthenticationService2 {
   credentialsRepository;
   sessionRepository;
@@ -282,7 +282,7 @@ let AuthenticationService = class AuthenticationService2 {
   async deriveSigningSecrets(secret) {
     const key = await (0, import_cryptography.importPbkdf2Key)(secret);
     const algorithm = { name: "PBKDF2", hash: "SHA-512", iterations: 5e5, salt: new Uint8Array() };
-    const [derivedTokenSigningSecret, derivedRefreshTokenSigningSecret, derivedSecretResetTokenSigningSecret] = await (0, import_cryptography.deriveBytesMultiple)(algorithm, key, 3, SIGNING_SECRETS_LENGTH / 8);
+    const [derivedTokenSigningSecret, derivedRefreshTokenSigningSecret, derivedSecretResetTokenSigningSecret] = await (0, import_cryptography.deriveBytesMultiple)(algorithm, key, 3, SIGNING_SECRETS_LENGTH);
     this.derivedTokenSigningSecret = derivedTokenSigningSecret;
     this.derivedRefreshTokenSigningSecret = derivedRefreshTokenSigningSecret;
     this.derivedSecretResetTokenSigningSecret = derivedSecretResetTokenSigningSecret;

package/authentication/server/module.d.ts

@@ -1,16 +1,17 @@
-import type { Type } from '../../types.js';
+import type { InjectionToken, Provider } from '../../container/index.js';
 import { AuthenticationCredentialsRepository } from './authentication-credentials.repository.js';
 import { AuthenticationSessionRepository } from './authentication-session.repository.js';
 import { AuthenticationSubjectResolver } from './authentication-subject.resolver.js';
 import { AuthenticationTokenPayloadProvider } from './authentication-token-payload.provider.js';
 import { AuthenticationService, AuthenticationServiceOptions } from './authentication.service.js';
 export type AuthenticationModuleConfig = {
-    serviceOptions: AuthenticationServiceOptions;
-    credentialsRepository: Type<AuthenticationCredentialsRepository>;
-    sessionRepository: Type<AuthenticationSessionRepository>;
+    serviceOptions?: AuthenticationServiceOptions | Provider<AuthenticationServiceOptions>;
+    serviceOptionsProvider?: Provider<AuthenticationServiceOptions>;
+    credentialsRepository: InjectionToken<AuthenticationCredentialsRepository>;
+    sessionRepository: InjectionToken<AuthenticationSessionRepository>;
     /** override default AuthenticationService */
-    authenticationService?: Type<AuthenticationService<any, any>>;
-    tokenPayloadProvider?: Type<AuthenticationTokenPayloadProvider<any, any>>;
-    subjectResolver?: Type<AuthenticationSubjectResolver>;
+    authenticationService?: InjectionToken<AuthenticationService<any, any>>;
+    tokenPayloadProvider?: InjectionToken<AuthenticationTokenPayloadProvider<any, any>>;
+    subjectResolver?: InjectionToken<AuthenticationSubjectResolver>;
 };
 export declare function configureAuthenticationServer(config: AuthenticationModuleConfig): void;

package/authentication/server/module.js

@@ -29,7 +29,13 @@ var import_authentication_subject_resolver = require("./authentication-subject.r
 var import_authentication_token_payload_provider = require("./authentication-token-payload.provider.js");
 var import_authentication_service = require("./authentication.service.js");
 function configureAuthenticationServer(config) {
-  import_container.container.register(import_authentication_service.AuthenticationServiceOptions, { useValue: config.serviceOptions });
+  if ((0, import_type_guards.isDefined)(config.serviceOptions)) {
+    import_container.container.register(import_authentication_service.AuthenticationServiceOptions, { useValue: config.serviceOptions });
+  } else if ((0, import_type_guards.isDefined)(config.serviceOptionsProvider)) {
+    import_container.container.register(import_authentication_service.AuthenticationServiceOptions, config.serviceOptionsProvider);
+  } else {
+    throw new Error("Either serviceOptions or serviceOptionsToken must be provided.");
+  }
   import_container.container.registerSingleton(import_authentication_credentials_repository.AuthenticationCredentialsRepository, { useToken: config.credentialsRepository });
   import_container.container.registerSingleton(import_authentication_session_repository.AuthenticationSessionRepository, { useToken: config.sessionRepository });
   if ((0, import_type_guards.isDefined)(config.authenticationService)) {

package/container/provider.d.ts

@@ -28,7 +28,8 @@ export declare function classProvider<T>(constructor: Constructor<T>): ClassProv
 export declare function valueProvider<T>(value: T): ValueProvider<T>;
 export declare function tokenProvider<T, A>(token: InjectionToken<T, A>, argument?: InjectableArgument<T, A>): TokenProvider<T>;
 export declare function factoryProvider<T, A>(factory: Factory<T, A>): FactoryProvider<T, A>;
-export declare function isClassProvider<T>(provider: Provider<T>): provider is ClassProvider<T>;
-export declare function isValueProvider<T>(provider: Provider<T>): provider is ValueProvider<T>;
-export declare function isTokenProvider<T>(provider: Provider<T>): provider is TokenProvider<T>;
-export declare function isFactoryProvider<T, A>(provider: Provider<T, A>): provider is FactoryProvider<T, A>;
+export declare function isClassProvider<T>(value: unknown): value is ClassProvider<T>;
+export declare function isValueProvider<T>(value: unknown): value is ValueProvider<T>;
+export declare function isTokenProvider<T>(value: unknown): value is TokenProvider<T>;
+export declare function isFactoryProvider<T, A>(value: unknown): value is FactoryProvider<T, A>;
+export declare function isProvider<T, A>(value: unknown): value is Provider<T, A>;

package/container/provider.js

@@ -22,6 +22,7 @@ __export(provider_exports, {
   factoryProvider: () => factoryProvider,
   isClassProvider: () => isClassProvider,
   isFactoryProvider: () => isFactoryProvider,
+  isProvider: () => isProvider,
   isTokenProvider: () => isTokenProvider,
   isValueProvider: () => isValueProvider,
   tokenProvider: () => tokenProvider,
@@ -29,6 +30,7 @@ __export(provider_exports, {
 });
 module.exports = __toCommonJS(provider_exports);
 var import_object = require("../utils/object/object.js");
+var import_type_guards = require("../utils/type-guards.js");
 function classProvider(constructor) {
   return { useClass: constructor };
 }
@@ -41,15 +43,18 @@ function tokenProvider(token, argument) {
 function factoryProvider(factory) {
   return { useFactory: factory };
 }
-function isClassProvider(provider) {
-  return (0, import_object.hasOwnProperty)(provider, "useClass");
+function isClassProvider(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useClass");
 }
-function isValueProvider(provider) {
-  return (0, import_object.hasOwnProperty)(provider, "useValue");
+function isValueProvider(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useValue");
 }
-function isTokenProvider(provider) {
-  return (0, import_object.hasOwnProperty)(provider, "useToken") || (0, import_object.hasOwnProperty)(provider, "useTokenProvider");
+function isTokenProvider(value) {
+  return (0, import_type_guards.isObject)(value) && ((0, import_object.hasOwnProperty)(value, "useToken") || (0, import_object.hasOwnProperty)(value, "useTokenProvider"));
 }
-function isFactoryProvider(provider) {
-  return (0, import_object.hasOwnProperty)(provider, "useFactory");
+function isFactoryProvider(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useFactory");
+}
+function isProvider(value) {
+  return (0, import_type_guards.isObject)(value) && (isClassProvider(value) || isValueProvider(value) || isTokenProvider(value) || isFactoryProvider(value));
 }

package/package.json

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