@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/authentication/server/helper.js

@@ -1,73 +1,94 @@
-import { BadRequestError } from '../../error/bad-request.error.js';
-import { InvalidTokenError } from '../../error/invalid-token.error.js';
-import { currentTimestampSeconds } from '../../utils/date-time.js';
-import { parseAndValidateJwtTokenString } from '../../utils/jwt.js';
-import { isArray, isDefined, isUndefined } from '../../utils/type-guards.js';
-/**
- *
- * @param request
- * @param cookieName (default "authorization")
- * @returns token string
- */
-export function tryGetAuthorizationTokenStringFromRequest(request, cookieName = 'authorization', forceCookie = false) {
-    const authorizationHeaders = forceCookie ? undefined : request.headers.tryGet('Authorization');
-    const authorizationString = (isArray(authorizationHeaders) ? authorizationHeaders[0] : authorizationHeaders)
-        ?? request.cookies.tryGet(cookieName);
-    if (isDefined(authorizationString)) {
-        const authorizationSchemeEnd = authorizationString.indexOf(' ');
-        const authorizationScheme = authorizationString.slice(0, authorizationSchemeEnd).trim().toLowerCase();
-        if (authorizationScheme != 'bearer') {
-            throw new BadRequestError(`Unsupported authorization scheme "${authorizationScheme}".`);
-        }
-        const authorization = authorizationString.slice(authorizationSchemeEnd).trim();
-        return authorization;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helper_exports = {};
+__export(helper_exports, {
+  getRefreshTokenFromString: () => getRefreshTokenFromString,
+  getSecretResetTokenFromString: () => getSecretResetTokenFromString,
+  getTokenFromRequest: () => getTokenFromRequest,
+  getTokenFromString: () => getTokenFromString,
+  tryGetAuthorizationTokenStringFromRequest: () => tryGetAuthorizationTokenStringFromRequest,
+  tryGetTokenFromRequest: () => tryGetTokenFromRequest
+});
+module.exports = __toCommonJS(helper_exports);
+var import_bad_request_error = require("../../error/bad-request.error.js");
+var import_invalid_token_error = require("../../error/invalid-token.error.js");
+var import_date_time = require("../../utils/date-time.js");
+var import_jwt = require("../../utils/jwt.js");
+var import_type_guards = require("../../utils/type-guards.js");
+function tryGetAuthorizationTokenStringFromRequest(request, cookieName = "authorization", forceCookie = false) {
+  const authorizationHeaders = forceCookie ? void 0 : request.headers.tryGet("Authorization");
+  const authorizationString = ((0, import_type_guards.isArray)(authorizationHeaders) ? authorizationHeaders[0] : authorizationHeaders) ?? request.cookies.tryGet(cookieName);
+  if ((0, import_type_guards.isDefined)(authorizationString)) {
+    const authorizationSchemeEnd = authorizationString.indexOf(" ");
+    const authorizationScheme = authorizationString.slice(0, authorizationSchemeEnd).trim().toLowerCase();
+    if (authorizationScheme != "bearer") {
+      throw new import_bad_request_error.BadRequestError(`Unsupported authorization scheme "${authorizationScheme}".`);
     }
-    return undefined;
+    const authorization = authorizationString.slice(authorizationSchemeEnd).trim();
+    return authorization;
+  }
+  return void 0;
 }
-export async function tryGetTokenFromRequest(request, tokenVersion, secret) {
-    const tokenString = tryGetAuthorizationTokenStringFromRequest(request);
-    if (isUndefined(tokenString)) {
-        return undefined;
-    }
-    return getTokenFromString(tokenString, tokenVersion, secret);
+async function tryGetTokenFromRequest(request, tokenVersion, secret) {
+  const tokenString = tryGetAuthorizationTokenStringFromRequest(request);
+  if ((0, import_type_guards.isUndefined)(tokenString)) {
+    return void 0;
+  }
+  return getTokenFromString(tokenString, tokenVersion, secret);
 }
-export async function getTokenFromRequest(request, tokenVersion, secret) {
-    const token = await tryGetTokenFromRequest(request, tokenVersion, secret);
-    if (isUndefined(token)) {
-        throw new InvalidTokenError('Missing authorization token');
-    }
-    return token;
+async function getTokenFromRequest(request, tokenVersion, secret) {
+  const token = await tryGetTokenFromRequest(request, tokenVersion, secret);
+  if ((0, import_type_guards.isUndefined)(token)) {
+    throw new import_invalid_token_error.InvalidTokenError("Missing authorization token");
+  }
+  return token;
 }
-export async function getTokenFromString(tokenString, tokenVersion, secret) {
-    if (isUndefined(tokenString)) {
-        throw new InvalidTokenError('Missing authorization token');
-    }
-    const validatedToken = await parseAndValidateJwtTokenString(tokenString, 'HS256', secret);
-    if (validatedToken.header.v != tokenVersion) {
-        throw new InvalidTokenError('Invalid token version');
-    }
-    if ((validatedToken.payload.exp + 2500) <= currentTimestampSeconds()) {
-        throw new InvalidTokenError('Token expired');
-    }
-    return validatedToken;
+async function getTokenFromString(tokenString, tokenVersion, secret) {
+  if ((0, import_type_guards.isUndefined)(tokenString)) {
+    throw new import_invalid_token_error.InvalidTokenError("Missing authorization token");
+  }
+  const validatedToken = await (0, import_jwt.parseAndValidateJwtTokenString)(tokenString, "HS256", secret);
+  if (validatedToken.header.v != tokenVersion) {
+    throw new import_invalid_token_error.InvalidTokenError("Invalid token version");
+  }
+  if (validatedToken.payload.exp + 2500 <= (0, import_date_time.currentTimestampSeconds)()) {
+    throw new import_invalid_token_error.InvalidTokenError("Token expired");
+  }
+  return validatedToken;
 }
-export async function getRefreshTokenFromString(tokenString, secret) {
-    if (isUndefined(tokenString)) {
-        throw new InvalidTokenError('Missing refresh token');
-    }
-    const validatedRefreshToken = await parseAndValidateJwtTokenString(tokenString, 'HS256', secret);
-    if (validatedRefreshToken.payload.exp <= currentTimestampSeconds()) {
-        throw new InvalidTokenError('Refresh token expired.');
-    }
-    return validatedRefreshToken;
+async function getRefreshTokenFromString(tokenString, secret) {
+  if ((0, import_type_guards.isUndefined)(tokenString)) {
+    throw new import_invalid_token_error.InvalidTokenError("Missing refresh token");
+  }
+  const validatedRefreshToken = await (0, import_jwt.parseAndValidateJwtTokenString)(tokenString, "HS256", secret);
+  if (validatedRefreshToken.payload.exp <= (0, import_date_time.currentTimestampSeconds)()) {
+    throw new import_invalid_token_error.InvalidTokenError("Refresh token expired.");
+  }
+  return validatedRefreshToken;
 }
-export async function getSecretResetTokenFromString(tokenString, secret) {
-    if (isUndefined(tokenString)) {
-        throw new InvalidTokenError('Missing secret reset token');
-    }
-    const validatedSecretResetToken = await parseAndValidateJwtTokenString(tokenString, 'HS256', secret);
-    if (validatedSecretResetToken.payload.exp <= currentTimestampSeconds()) {
-        throw new InvalidTokenError('Secret reset token expired.');
-    }
-    return validatedSecretResetToken;
+async function getSecretResetTokenFromString(tokenString, secret) {
+  if ((0, import_type_guards.isUndefined)(tokenString)) {
+    throw new import_invalid_token_error.InvalidTokenError("Missing secret reset token");
+  }
+  const validatedSecretResetToken = await (0, import_jwt.parseAndValidateJwtTokenString)(tokenString, "HS256", secret);
+  if (validatedSecretResetToken.payload.exp <= (0, import_date_time.currentTimestampSeconds)()) {
+    throw new import_invalid_token_error.InvalidTokenError("Secret reset token expired.");
+  }
+  return validatedSecretResetToken;
 }

package/authentication/server/index.js

@@ -1,11 +1,28 @@
-export * from './authentication-api-request-token.provider.js';
-export * from './authentication-credentials.repository.js';
-export * from './authentication-secret-requirements.validator.js';
-export * from './authentication-secret-reset.handler.js';
-export * from './authentication-session.repository.js';
-export * from './authentication-subject.resolver.js';
-export * from './authentication-token-payload.provider.js';
-export * from './authentication.api-controller.js';
-export * from './authentication.service.js';
-export * from './helper.js';
-export * from './module.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./authentication-api-request-token.provider.js"), module.exports);
+__reExport(server_exports, require("./authentication-credentials.repository.js"), module.exports);
+__reExport(server_exports, require("./authentication-secret-requirements.validator.js"), module.exports);
+__reExport(server_exports, require("./authentication-secret-reset.handler.js"), module.exports);
+__reExport(server_exports, require("./authentication-session.repository.js"), module.exports);
+__reExport(server_exports, require("./authentication-subject.resolver.js"), module.exports);
+__reExport(server_exports, require("./authentication-token-payload.provider.js"), module.exports);
+__reExport(server_exports, require("./authentication.api-controller.js"), module.exports);
+__reExport(server_exports, require("./authentication.service.js"), module.exports);
+__reExport(server_exports, require("./helper.js"), module.exports);
+__reExport(server_exports, require("./module.js"), module.exports);

package/authentication/server/module.d.ts

@@ -1,4 +1,5 @@
-import type { InjectionToken, Provider } from '../../container/index.js';
+import type { Provider } from '../../injector/provider.js';
+import type { InjectionToken } from '../../injector/token.js';
 import { AuthenticationCredentialsRepository } from './authentication-credentials.repository.js';
 import { AuthenticationSessionRepository } from './authentication-session.repository.js';
 import { AuthenticationSubjectResolver } from './authentication-subject.resolver.js';

package/authentication/server/module.js

@@ -1,26 +1,49 @@
-import { container, isProvider } from '../../container/index.js';
-import { isDefined } from '../../utils/type-guards.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 function configureAuthenticationServer(config) {
-    if (isDefined(config.serviceOptions)) {
-        container.register(AuthenticationServiceOptions, isProvider(config.serviceOptions) ? config.serviceOptions : { useValue: config.serviceOptions });
-    }
-    else {
-        throw new Error('Either serviceOptions or serviceOptionsToken must be provided.');
-    }
-    container.registerSingleton(AuthenticationCredentialsRepository, { useToken: config.credentialsRepository });
-    container.registerSingleton(AuthenticationSessionRepository, { useToken: config.sessionRepository });
-    if (isDefined(config.authenticationService)) {
-        container.registerSingleton(AuthenticationService, { useToken: config.authenticationService });
-    }
-    if (isDefined(config.tokenPayloadProvider)) {
-        container.registerSingleton(AuthenticationTokenPayloadProvider, { useToken: config.tokenPayloadProvider });
-    }
-    if (isDefined(config.subjectResolver)) {
-        container.registerSingleton(AuthenticationSubjectResolver, { useToken: config.subjectResolver });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var module_exports = {};
+__export(module_exports, {
+  configureAuthenticationServer: () => configureAuthenticationServer
+});
+module.exports = __toCommonJS(module_exports);
+var import_injector = require("../../injector/injector.js");
+var import_provider = require("../../injector/provider.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_authentication_credentials_repository = require("./authentication-credentials.repository.js");
+var import_authentication_session_repository = require("./authentication-session.repository.js");
+var import_authentication_subject_resolver = require("./authentication-subject.resolver.js");
+var import_authentication_token_payload_provider = require("./authentication-token-payload.provider.js");
+var import_authentication_service = require("./authentication.service.js");
+function configureAuthenticationServer(config) {
+  if ((0, import_type_guards.isDefined)(config.serviceOptions)) {
+    import_injector.Injector.register(import_authentication_service.AuthenticationServiceOptions, (0, import_provider.isProvider)(config.serviceOptions) ? config.serviceOptions : { useValue: config.serviceOptions });
+  } else {
+    throw new Error("Either serviceOptions or serviceOptionsToken must be provided.");
+  }
+  import_injector.Injector.registerSingleton(import_authentication_credentials_repository.AuthenticationCredentialsRepository, { useToken: config.credentialsRepository });
+  import_injector.Injector.registerSingleton(import_authentication_session_repository.AuthenticationSessionRepository, { useToken: config.sessionRepository });
+  if ((0, import_type_guards.isDefined)(config.authenticationService)) {
+    import_injector.Injector.registerSingleton(import_authentication_service.AuthenticationService, { useToken: config.authenticationService });
+  }
+  if ((0, import_type_guards.isDefined)(config.tokenPayloadProvider)) {
+    import_injector.Injector.registerSingleton(import_authentication_token_payload_provider.AuthenticationTokenPayloadProvider, { useToken: config.tokenPayloadProvider });
+  }
+  if ((0, import_type_guards.isDefined)(config.subjectResolver)) {
+    import_injector.Injector.registerSingleton(import_authentication_subject_resolver.AuthenticationSubjectResolver, { useToken: config.subjectResolver });
+  }
 }

package/authentication/server/mongo/index.js

@@ -1,2 +1,19 @@
-export * from './mongo-authentication-credentials.repository.js';
-export * from './mongo-authentication-session.repository.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mongo_exports = {};
+module.exports = __toCommonJS(mongo_exports);
+__reExport(mongo_exports, require("./mongo-authentication-credentials.repository.js"), module.exports);
+__reExport(mongo_exports, require("./mongo-authentication-session.repository.js"), module.exports);

package/authentication/server/mongo/mongo-authentication-credentials.repository.d.ts

@@ -1,14 +1,14 @@
-import type { Injectable } from '../../../container/index.js';
-import { type resolveArgumentType } from '../../../container/index.js';
 import type { MaybeNewEntity } from '../../../database/index.js';
 import type { CollectionArgument } from '../../../database/mongo/index.js';
 import { Collection, MongoEntityRepository } from '../../../database/mongo/index.js';
+import { resolveArgumentType } from '../../../injector/index.js';
+import type { Resolvable } from '../../../injector/interfaces.js';
 import { Logger } from '../../../logger/index.js';
 import type { AuthenticationCredentials, NewAuthenticationCredentials } from '../../models/index.js';
 import { AuthenticationCredentialsRepository } from '../authentication-credentials.repository.js';
 export type MongoAuthenticationCredentialsRepositoryArgument = CollectionArgument<AuthenticationCredentials>;
 export type MongoAuthenticationCredentialsRepositoryConfig = MongoAuthenticationCredentialsRepositoryArgument;
-export declare class InternalMongoAuthenticationCredentialsRepository extends MongoEntityRepository<AuthenticationCredentials> implements Injectable<MongoAuthenticationCredentialsRepositoryArgument> {
+export declare class InternalMongoAuthenticationCredentialsRepository extends MongoEntityRepository<AuthenticationCredentials> implements Resolvable<MongoAuthenticationCredentialsRepositoryArgument> {
     readonly [resolveArgumentType]: MongoAuthenticationCredentialsRepositoryArgument;
     constructor(collection: Collection<AuthenticationCredentials>, logger: Logger);
     upsert(credentials: MaybeNewEntity<AuthenticationCredentials>): Promise<void>;

package/authentication/server/mongo/mongo-authentication-credentials.repository.js

@@ -1,66 +1,98 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mongo_authentication_credentials_repository_exports = {};
+__export(mongo_authentication_credentials_repository_exports, {
+  InternalMongoAuthenticationCredentialsRepository: () => InternalMongoAuthenticationCredentialsRepository,
+  MongoAuthenticationCredentialsRepository: () => MongoAuthenticationCredentialsRepository,
+  configureMongoAuthenticationCredentialsRepository: () => configureMongoAuthenticationCredentialsRepository
+});
+module.exports = __toCommonJS(mongo_authentication_credentials_repository_exports);
+var import_database = require("../../../database/index.js");
+var import_mongo = require("../../../database/mongo/index.js");
+var import_injector = require("../../../injector/index.js");
+var import_logger = require("../../../logger/index.js");
+var import_type_guards = require("../../../utils/type-guards.js");
+var import_authentication_credentials_repository = require("../authentication-credentials.repository.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
 };
-import { forwardArg, singleton } from '../../../container/index.js';
-import { getNewId } from '../../../database/index.js';
-import { Collection, MongoEntityRepository, noopTransformer } from '../../../database/mongo/index.js';
-import { Logger } from '../../../logger/index.js';
-import { isUndefined } from '../../../utils/type-guards.js';
-import { AuthenticationCredentialsRepository } from '../authentication-credentials.repository.js';
 let defaultArgument;
 const indexes = [
-    { key: { subject: 1 }, unique: true }
+  { key: { subject: 1 }, unique: true }
 ];
-export let InternalMongoAuthenticationCredentialsRepository = class InternalMongoAuthenticationCredentialsRepository extends MongoEntityRepository {
-    constructor(collection, logger) {
-        super(collection, noopTransformer, { logger, indexes });
-    }
-    async upsert(credentials) {
-        const { id: _, ...credentialsWithoutId } = credentials;
-        await this.baseRepository.update({ subject: credentials.subject }, { $setOnInsert: { _id: getNewId() }, $set: credentialsWithoutId }, { upsert: true });
-    }
+let InternalMongoAuthenticationCredentialsRepository = class InternalMongoAuthenticationCredentialsRepository2 extends import_mongo.MongoEntityRepository {
+  constructor(collection, logger) {
+    super(collection, import_mongo.noopTransformer, { logger, indexes });
+  }
+  async upsert(credentials) {
+    const { id: _, ...credentialsWithoutId } = credentials;
+    await this.baseRepository.update({ subject: credentials.subject }, { $setOnInsert: { _id: (0, import_database.getNewId)() }, $set: credentialsWithoutId }, { upsert: true });
+  }
 };
 InternalMongoAuthenticationCredentialsRepository = __decorate([
-    singleton({
-        defaultArgumentProvider: () => defaultArgument
-    }),
-    __param(0, forwardArg()),
-    __metadata("design:paramtypes", [Collection, Logger])
+  (0, import_injector.Singleton)({
+    defaultArgumentProvider: () => defaultArgument
+  }),
+  __param(0, (0, import_injector.ForwardArg)()),
+  __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], InternalMongoAuthenticationCredentialsRepository);
-export let MongoAuthenticationCredentialsRepository = class MongoAuthenticationCredentialsRepository extends AuthenticationCredentialsRepository {
-    repository;
-    constructor(repository) {
-        super();
-        this.repository = repository;
-    }
-    async tryLoadBySubject(subject) {
-        const credentials = await this.repository.tryLoadByFilter({ subject });
-        if (isUndefined(credentials)) {
-            return credentials;
-        }
-        return {
-            ...credentials,
-            salt: credentials.salt.buffer,
-            hash: credentials.hash.buffer
-        };
-    }
-    async save(credentials) {
-        await this.repository.upsert(credentials);
+let MongoAuthenticationCredentialsRepository = class MongoAuthenticationCredentialsRepository2 extends import_authentication_credentials_repository.AuthenticationCredentialsRepository {
+  repository;
+  constructor(repository) {
+    super();
+    this.repository = repository;
+  }
+  async tryLoadBySubject(subject) {
+    const credentials = await this.repository.tryLoadByFilter({ subject });
+    if ((0, import_type_guards.isUndefined)(credentials)) {
+      return credentials;
     }
+    return {
+      ...credentials,
+      salt: credentials.salt.buffer,
+      hash: credentials.hash.buffer
+    };
+  }
+  async save(credentials) {
+    await this.repository.upsert(credentials);
+  }
 };
 MongoAuthenticationCredentialsRepository = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [InternalMongoAuthenticationCredentialsRepository])
+  (0, import_injector.Singleton)(),
+  __metadata("design:paramtypes", [InternalMongoAuthenticationCredentialsRepository])
 ], MongoAuthenticationCredentialsRepository);
-export function configureMongoAuthenticationCredentialsRepository(config) {
-    defaultArgument = config;
+function configureMongoAuthenticationCredentialsRepository(config) {
+  defaultArgument = config;
 }

package/authentication/server/mongo/mongo-authentication-session.repository.d.ts

@@ -1,14 +1,14 @@
-import type { Injectable } from '../../../container/index.js';
-import { type resolveArgumentType } from '../../../container/index.js';
 import type { CollectionArgument } from '../../../database/mongo/index.js';
 import { Collection, MongoEntityRepository } from '../../../database/mongo/index.js';
+import { resolveArgumentType } from '../../../injector/index.js';
+import type { Resolvable } from '../../../injector/interfaces.js';
 import { Logger } from '../../../logger/index.js';
 import type { AuthenticationSession, NewAuthenticationSession } from '../../models/index.js';
 import type { AuthenticationSessionExtendData } from '../authentication-session.repository.js';
 import { AuthenticationSessionRepository } from '../authentication-session.repository.js';
 export type MongoAuthenticationSessionRepositoryConfig = MongoAuthenticationSessionRepositoryArgument;
 export type MongoAuthenticationSessionRepositoryArgument = CollectionArgument<AuthenticationSession>;
-export declare class InternalMongoAuthenticationSessionRepository extends MongoEntityRepository<AuthenticationSession> implements Injectable<MongoAuthenticationSessionRepositoryArgument> {
+export declare class InternalMongoAuthenticationSessionRepository extends MongoEntityRepository<AuthenticationSession> implements Resolvable<MongoAuthenticationSessionRepositoryArgument> {
     readonly [resolveArgumentType]: MongoAuthenticationSessionRepositoryArgument;
     constructor(collection: Collection<AuthenticationSession>, logger: Logger);
 }