@tstdl/base 0.83.0 → 0.83.2

package/.eslintrc.cjs

@@ -1,4 +1,5 @@
 module.exports = {
+  root: true,
   env: {
     browser: true,
     es2022: true,

package/api/server/gateway.js

@@ -61,9 +61,8 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var ApiGateway_1;
 const defaultMaxBytes = 10 * import_units.mebibyte;
-let ApiGateway = ApiGateway_1 = class ApiGateway2 {
+let ApiGateway = class ApiGateway2 {
   requestTokenProvider;
   logger;
   prefix;
@@ -221,11 +220,11 @@ let ApiGateway = ApiGateway_1 = class ApiGateway2 {
     return import_schema.Schema.parse(schema, body);
   }
 };
-ApiGateway = ApiGateway_1 = __decorate([
+ApiGateway = __decorate([
   (0, import_container.singleton)({
     defaultArgumentProvider: (context) => context.resolve(import_tokens.API_MODULE_OPTIONS).gatewayOptions
   }),
-  __param(1, (0, import_container.resolveArg)(ApiGateway_1.name)),
+  __param(1, (0, import_container.resolveArg)("ApiGateway")),
   __param(2, (0, import_container.injectArg)()),
   __metadata("design:paramtypes", [import_api_request_token_provider.ApiRequestTokenProvider, import_logger.Logger, Object])
 ], ApiGateway);

package/authentication/server/authentication.service.js

@@ -271,11 +271,10 @@ let AuthenticationService = class AuthenticationService2 {
   }
   async deriveSigningSecrets() {
     const key = await (0, import_cryptography.importPbkdf2Key)(this.secret);
-    const hash = await globalThis.crypto.subtle.deriveBits({ name: "PBKDF2", hash: "SHA-512", iterations: 5e5, salt: new Uint8Array() }, key, SIGNING_SECRETS_LENGTH * 3);
-    const bufferSize = SIGNING_SECRETS_LENGTH / 8;
-    this.derivedTokenSigningSecret = new Uint8Array(hash.slice(0, bufferSize));
-    this.derivedRefreshTokenSigningSecret = new Uint8Array(hash.slice(bufferSize, bufferSize * 2));
-    this.derivedSecretResetTokenSigningSecret = new Uint8Array(hash.slice(bufferSize * 2));
+    const [derivedTokenSigningSecret, derivedRefreshTokenSigningSecret, derivedSecretResetTokenSigningSecret] = await (0, import_cryptography.deriveBytesMultiple)(3, SIGNING_SECRETS_LENGTH / 8, { name: "PBKDF2", hash: "SHA-512", iterations: 5e5, salt: new Uint8Array() }, key);
+    this.derivedTokenSigningSecret = derivedTokenSigningSecret;
+    this.derivedRefreshTokenSigningSecret = derivedRefreshTokenSigningSecret;
+    this.derivedSecretResetTokenSigningSecret = derivedSecretResetTokenSigningSecret;
   }
   async getHash(secret, salt) {
     const key = await (0, import_cryptography.importPbkdf2Key)(secret);

package/http/server/node/node-http-server.js

@@ -67,8 +67,7 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var NodeHttpServer_1;
-let NodeHttpServer = NodeHttpServer_1 = class NodeHttpServer2 extends import_http_server.HttpServer {
+let NodeHttpServer = class NodeHttpServer2 extends import_http_server.HttpServer {
   httpServer;
   sockets;
   requestIterable;
@@ -170,9 +169,9 @@ let NodeHttpServer = NodeHttpServer_1 = class NodeHttpServer2 extends import_htt
     return item;
   }
 };
-NodeHttpServer = NodeHttpServer_1 = __decorate([
+NodeHttpServer = __decorate([
   (0, import_container.singleton)(),
-  __param(0, (0, import_container.resolveArg)(NodeHttpServer_1.name)),
+  __param(0, (0, import_container.resolveArg)("NodeHttpServer")),
   __metadata("design:paramtypes", [import_logger.Logger])
 ], NodeHttpServer);
 function getResponder(httpResponse) {

package/key-value-store/mongo/mongo-key-value.repository.js

@@ -44,18 +44,17 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var MongoKeyValueRepository_1;
 const indexes = [
   { key: { module: 1, key: 1 }, unique: true }
 ];
-let MongoKeyValueRepository = MongoKeyValueRepository_1 = class MongoKeyValueRepository2 extends import_mongo.MongoEntityRepository {
+let MongoKeyValueRepository = class MongoKeyValueRepository2 extends import_mongo.MongoEntityRepository {
   constructor(collection, logger) {
     super(collection, import_mongo.noopTransformer, { logger, indexes });
   }
 };
-MongoKeyValueRepository = MongoKeyValueRepository_1 = __decorate([
+MongoKeyValueRepository = __decorate([
   (0, import_container.singleton)({ defaultArgumentProvider: (context) => context.resolve(import_tokens.DEFAULT_KEY_VALUE_REPOSITORY_CONFIG) }),
   __param(0, (0, import_container.forwardArg)()),
-  __param(1, (0, import_container.resolveArg)(MongoKeyValueRepository_1.name)),
+  __param(1, (0, import_container.resolveArg)("MongoKeyValueRepository")),
   __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], MongoKeyValueRepository);

package/mail/mail.service.js

@@ -49,8 +49,7 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var MailService_1;
-let MailService = MailService_1 = class MailService2 {
+let MailService = class MailService2 {
   mailClient;
   templateService;
   mailLogRepository;
@@ -99,11 +98,11 @@ let MailService = MailService_1 = class MailService2 {
     return this.send(fullMailData, name);
   }
 };
-MailService = MailService_1 = __decorate([
+MailService = __decorate([
   (0, import_container.singleton)(),
   __param(2, (0, import_container.inject)(import_mail_log_repository.MailLogRepository)),
   __param(2, (0, import_container.optional)()),
-  __param(3, (0, import_container.resolveArg)(MailService_1.name)),
+  __param(3, (0, import_container.resolveArg)("MailService")),
   __param(4, (0, import_container.inject)(import_tokens.MAIL_DEFAULT_DATA)),
   __param(4, (0, import_container.optional)()),
   __metadata("design:paramtypes", [

package/migration/migrator.js

@@ -50,8 +50,7 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var Migrator_1;
-let Migrator = Migrator_1 = class Migrator2 {
+let Migrator = class Migrator2 {
   migrationStateRepository;
   lockProvider;
   logger;
@@ -109,9 +108,9 @@ let Migrator = Migrator_1 = class Migrator2 {
     return result;
   }
 };
-Migrator = Migrator_1 = __decorate([
+Migrator = __decorate([
   (0, import_container.singleton)(),
   __param(1, (0, import_container.resolveArg)("migrator:")),
-  __param(2, (0, import_container.resolveArg)(Migrator_1.name)),
+  __param(2, (0, import_container.resolveArg)("Migrator")),
   __metadata("design:paramtypes", [import_migration_state_repository.MigrationStateRepository, import_lock.LockProvider, import_logger.Logger])
 ], Migrator);

package/migration/mongo/migration-state-repository.js

@@ -45,18 +45,17 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var MongoMigrationStateRepository_1;
 const indexes = [
   { key: { name: 1 }, unique: true }
 ];
-let MongoMigrationStateRepository = MongoMigrationStateRepository_1 = class MongoMigrationStateRepository2 extends import_mongo_entity_repository.MongoEntityRepository {
+let MongoMigrationStateRepository = class MongoMigrationStateRepository2 extends import_mongo_entity_repository.MongoEntityRepository {
   constructor(collection, logger) {
     super(collection, import_mongo_entity_repository.noopTransformer, { logger, indexes });
   }
 };
-MongoMigrationStateRepository = MongoMigrationStateRepository_1 = __decorate([
+MongoMigrationStateRepository = __decorate([
   (0, import_container.singleton)({ defaultArgumentProvider: () => import_module.mongoMigrationStateRepositoryModuleConfig.defaultMigrationStateRepositoryConfig }),
   __param(0, (0, import_container.forwardArg)()),
-  __param(1, (0, import_container.resolveArg)(MongoMigrationStateRepository_1.name)),
+  __param(1, (0, import_container.resolveArg)("MongoMigrationStateRepository")),
   __metadata("design:paramtypes", [import_classes.Collection, import_logger.Logger])
 ], MongoMigrationStateRepository);

package/openid-connect/mongo-oidc-state.repository.js

@@ -45,7 +45,6 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var MongoOidcStateRepository_1;
 let repositoryConfig;
 const indexes = [
   { key: { value: 1 }, unique: true },
@@ -58,15 +57,15 @@ const transformer = {
     expiration: (0, import_mongo.mapTo)("expiration", (timestamp) => new Date(timestamp))
   }
 };
-let MongoOidcStateRepository = MongoOidcStateRepository_1 = class MongoOidcStateRepository2 extends import_mongo.MongoEntityRepository {
+let MongoOidcStateRepository = class MongoOidcStateRepository2 extends import_mongo.MongoEntityRepository {
   constructor(collection, logger) {
     super(collection, transformer, { logger, indexes });
   }
 };
-MongoOidcStateRepository = MongoOidcStateRepository_1 = __decorate([
+MongoOidcStateRepository = __decorate([
   (0, import_container.singleton)({ defaultArgumentProvider: () => repositoryConfig }),
   __param(0, (0, import_container.forwardArg)()),
-  __param(1, (0, import_container.resolveArg)(MongoOidcStateRepository_1.name)),
+  __param(1, (0, import_container.resolveArg)("MongoOidcStateRepository")),
   __metadata("design:paramtypes", [import_mongo.Collection, import_logger.Logger])
 ], MongoOidcStateRepository);
 function configureMongoOidcStateRepository(mongoOidcStateRepositoryConfig, register = true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.83.0",
+  "version": "0.83.2",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -44,7 +44,7 @@
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.6",
     "@koa/router": "^12.0",
-    "@tstdl/angular": "^0.82",
+    "@tstdl/angular": "^0.83",
     "@zxcvbn-ts/core": "2.2",
     "@zxcvbn-ts/language-common": "2.0",
     "@zxcvbn-ts/language-de": "2.1",

package/types.d.ts

@@ -83,10 +83,10 @@ type FromEntriesEntryValue<T extends readonly (readonly [any, any])[], K> = Extr
 export type FromEntries<T> = T extends readonly (readonly [infer Key, any])[] ? {
     [K in Cast<Key, PropertyKey>]: Fallback<FromEntriesEntryValue<T, K>, T[number][1]>;
 } : never;
-export type Writable<T> = {
+export type Writable<T> = T extends readonly (infer U)[] ? U[] : {
     -readonly [P in keyof T]: T[P];
 };
-export type DeepWritable<T> = {
+export type DeepWritable<T> = T extends readonly (infer U)[] ? DeepWritable<U>[] : {
     -readonly [P in keyof T]: DeepWritable<T[P]>;
 };
 export type RequiredKeys<T> = {

package/utils/cryptography.d.ts

@@ -1,4 +1,5 @@
 import type { BinaryData, TypedExtract } from '../types.js';
+import type { ReadonlyTuple } from 'type-fest';
 export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
 export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
 export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
@@ -104,3 +105,13 @@ export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolea
  * @param extractable whether the key can be used for exportKey
  */
 export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
+type AlgorithmParameter = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
+/**
+ * derive multiply byte arrays
+ * @param count how many Uint8Arrays to dervice
+ * @param length length of each Uint8Array in bytes
+ * @param algorithm algorithm to derive with
+ * @param baseKey key to derive from
+ */
+export declare function deriveBytesMultiple<C extends number>(count: C, length: number, algorithm: AlgorithmParameter, baseKey: CryptoKey): Promise<ReadonlyTuple<Uint8Array, C>>;
+export {};

package/utils/cryptography.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var cryptography_exports = {};
 __export(cryptography_exports, {
   decrypt: () => decrypt,
+  deriveBytesMultiple: () => deriveBytesMultiple,
   digest: () => digest,
   encrypt: () => encrypt,
   generateEcdsaKey: () => generateEcdsaKey,
@@ -31,6 +32,7 @@ __export(cryptography_exports, {
   verify: () => verify
 });
 module.exports = __toCommonJS(cryptography_exports);
+var import_array = require("./array/array.js");
 var import_base64 = require("./base64.js");
 var import_encoding = require("./encoding.js");
 var import_random = require("./random.js");
@@ -120,6 +122,11 @@ async function generatePbkdf2Key(extractable = false) {
   const key = (0, import_random.getRandomBytes)(16);
   return importPbkdf2Key(key, extractable);
 }
+async function deriveBytesMultiple(count, length, algorithm, baseKey) {
+  const totalBits = count * length * 8;
+  const bytes = await globalThis.crypto.subtle.deriveBits(algorithm, baseKey, totalBits);
+  return (0, import_array.createArray)(count, (index) => new Uint8Array(bytes.slice(index * length, index * length + length)));
+}
 function isBinaryKey(key) {
   return (0, import_type_guards.isDefined)(key.byteLength);
 }