@tstdl/base 0.93.139 → 0.93.140

package/message-bus/README.md

@@ -0,0 +1,244 @@
+# Message Bus
+
+A flexible, RxJS-based message bus module for decoupled in-process and cross-context communication, designed for seamless integration with dependency injection.
+
+## Table of Contents
+
+- [✨ Features](#-features)
+- [Core Concepts](#core-concepts)
+  - [Implementations](#implementations)
+  - [Message Observables](#message-observables)
+- [🚀 Basic Usage](#-basic-usage)
+  - [1. Configuration](#1-configuration)
+  - [2. Injection & Usage](#2-injection--usage)
+- [🔧 Advanced Topics](#-advanced-topics)
+  - [Cross-Context Communication (BroadcastChannel)](#cross-context-communication-broadcastchannel)
+  - [Fire and Forget](#fire-and-forget)
+  - [Resource Management](#resource-management)
+- [📚 API](#-api)
+
+## ✨ Features
+
+- **Decoupled Communication**: Enables components to communicate via named channels without direct references.
+- **Reactive Architecture**: Built on **RxJS**, providing powerful operators for filtering and transforming message streams.
+- **Dual Modes & Cross-Platform**:
+  - **Local**: High-performance in-memory communication using RxJS Subjects.
+  - **BroadcastChannel**: Cross-context communication (tabs, windows, workers) using the standard Web API.
+- **DI Integration**: Implements `Resolvable`, allowing direct injection with channel names as arguments.
+- **Type Safety**: Fully supports generic types for message payloads.
+- **Smart Filtering**: Distinguishes between messages from _other_ instances and _all_ messages (including self).
+- **Memory Safe**: Implements `AsyncDisposable` for proper cleanup of subscriptions and channels. Uses `WeakRefMap` internally to prevent memory leaks on unused channels.
+
+## Core Concepts
+
+### Implementations
+
+The module provides two strategies, selectable via configuration at application startup:
+
+1.  **`LocalMessageBus`**:
+    - **Scope**: Single JavaScript environment (e.g., one browser tab, one Node.js process).
+    - **Mechanism**: Shared RxJS `Subject`.
+    - **Use Case**: Component-to-component communication, global event bus within an app.
+
+2.  **`BroadcastChannelMessageBus`**:
+    - **Scope**: Same-origin browsing contexts (e.g., multiple tabs, iframes, workers).
+    - **Mechanism**: Wraps the `BroadcastChannel` API.
+    - **Use Case**: Synchronizing state across tabs (e.g., logout in one tab affects all others).
+
+### Message Observables
+
+Every `MessageBus` instance exposes two streams to handle different scenarios:
+
+- **`messages$`**: Emits messages published by **other** instances on the same channel. It filters out messages sent by _this_ specific instance. Use this to react to external events.
+- **`allMessages$`**: Emits **every** message on the channel, including those published by _this_ instance. Use this for logging, global state updates, or UI synchronization that must reflect local actions immediately.
+
+## 🚀 Basic Usage
+
+### 1. Configuration
+
+Register the desired implementation provider in your application bootstrap.
+
+**For in-process communication (Local):**
+
+```typescript
+import { configureLocalMessageBus } from '@tstdl/base/message-bus';
+
+// In your bootstrap/main file
+configureLocalMessageBus();
+```
+
+### 2. Injection & Usage
+
+Inject the `MessageBus` by passing the channel name as the argument.
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { MessageBus } from '@tstdl/base/message-bus';
+
+// 1. Define your message type
+type UserCreatedEvent = { id: string; email: string };
+
+export class UserService {
+  // 2. Inject the bus for a specific channel ('user-events')
+  private readonly userBus = inject(MessageBus<UserCreatedEvent>, 'user-events');
+
+  async createUser(email: string) {
+    const id = '123';
+    // ... creation logic ...
+
+    // 3. Publish a message
+    await this.userBus.publish({ id, email });
+  }
+}
+
+export class NotificationService {
+  private readonly userBus = inject(MessageBus<UserCreatedEvent>, 'user-events');
+
+  constructor() {
+    // 4. Subscribe to messages
+    this.userBus.messages$.subscribe((event) => {
+      console.log(`New user created: ${event.email}`);
+    });
+  }
+}
+```
+
+### 3. Alternative: Manual Resolution
+
+If you're not using dependency injection for a specific class or need to resolve a channel dynamically, use the `MessageBusProvider`.
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { MessageBusProvider } from '@tstdl/base/message-bus';
+
+const provider = inject(MessageBusProvider);
+const bus = provider.get<string>('dynamic-channel');
+
+await bus.publish('Hello world');
+```
+
+## 🔧 Advanced Topics
+
+### Reactive Patterns
+
+Since `MessageBus` is built on RxJS, you can use any operators to handle your message streams.
+
+```typescript
+import { filter, bufferTime } from 'rxjs';
+
+// Only handle specific events
+this.userBus.messages$.pipe(
+  filter(event => event.email.endsWith('@example.com'))
+).subscribe(event => { ... });
+
+// Batch events for processing
+this.userBus.messages$.pipe(
+  bufferTime(1000),
+  filter(batch => batch.length > 0)
+).subscribe(batch => {
+  console.log(`Processed ${batch.length} events this second.`);
+});
+```
+
+### Cross-Context Communication (BroadcastChannel)
+
+To enable communication between different tabs or windows (browsers) or between multiple workers/processes (Node.js), use the `BroadcastChannel` configuration.
+
+```typescript
+import { configureBroadcastChannelMessageBus } from '@tstdl/base/message-bus';
+
+// Use this instead of configureLocalMessageBus
+configureBroadcastChannelMessageBus();
+```
+
+> **Note:** `BroadcastChannel` is natively supported in modern browsers and Node.js 18+. For older environments, a polyfill may be required.
+
+### Custom Injector Configuration
+
+When configuring the `LocalMessageBus`, you can optionally specify which injector to use. This is useful in complex setups or when using multiple containers.
+
+```typescript
+import { configureLocalMessageBus } from '@tstdl/base/message-bus';
+import { myCustomInjector } from './my-context';
+
+configureLocalMessageBus({ injector: myCustomInjector });
+```
+
+**Example: Logout Synchronization**
+
+```typescript
+import { inject } from '@tstdl/base/injector';
+import { MessageBus } from '@tstdl/base/message-bus';
+
+type AuthEvent = { type: 'logout' };
+
+class AuthService {
+  private readonly authBus = inject(MessageBus<AuthEvent>, 'auth');
+
+  async logout() {
+    // Perform logout
+    await this.authBus.publish({ type: 'logout' });
+    window.location.reload();
+  }
+
+  listenForExternalLogout() {
+    // 'messages$' only emits if *another* tab publishes the event
+    this.authBus.messages$.subscribe((event) => {
+      if (event.type === 'logout') {
+        console.log('Logout triggered in another tab.');
+        window.location.reload();
+      }
+    });
+  }
+}
+```
+
+### Fire and Forget
+
+The standard `publish` method returns a `Promise` that resolves when the message has been dispatched (e.g., posted to the BroadcastChannel). If you do not need to wait for this, use `publishAndForget`.
+
+```typescript
+// Non-blocking publish
+this.messageBus.publishAndForget({ type: 'ping' });
+```
+
+### Resource Management
+
+`MessageBus` implements `AsyncDisposable`. When a bus is no longer needed, it should be disposed to close underlying channels (like `BroadcastChannel`) and complete internal subjects.
+
+If you are using the dependency injection system with scoped providers, this is handled automatically. If you create instances manually or hold them in long-lived services, ensure you dispose of them.
+
+```typescript
+await bus[Symbol.asyncDispose]();
+```
+
+## 📚 API
+
+### Classes & Interfaces
+
+| Name                                  | Description                                           |
+| :------------------------------------ | :---------------------------------------------------- |
+| `MessageBus<T>`                       | Abstract base class for a message bus instance.       |
+| `MessageBusBase<T>`                   | Helper class for implementing custom message buses.   |
+| `MessageBusProvider`                  | Abstract factory for creating `MessageBus` instances. |
+| `LocalMessageBus<T>`                  | Implementation for in-process communication.          |
+| `LocalMessageBusProvider`             | Provider implementation for `LocalMessageBus`.        |
+| `BroadcastChannelMessageBus<T>`       | Implementation for cross-context communication.       |
+| `BroadcastChannelMessageBusProvider` | Provider implementation for `BroadcastChannelMessageBus`. |
+
+### `MessageBus<T>` Members
+
+| Member                      | Type            | Description                                  |
+| :-------------------------- | :-------------- | :------------------------------------------- |
+| `messages$`                 | `Observable<T>` | Stream of messages from **other** instances. |
+| `allMessages$`              | `Observable<T>` | Stream of **all** messages (including self). |
+| `publish(message)`          | `Promise<void>` | Publishes a message asynchronously.          |
+| `publishAndForget(message)` | `void`          | Publishes a message without waiting.         |
+| `dispose()`                 | `Promise<void>` | Manually disposes the bus.                   |
+
+### Configuration Functions
+
+| Function                                | Description                                                           |
+| :-------------------------------------- | :-------------------------------------------------------------------- |
+| `configureLocalMessageBus()`            | Registers `LocalMessageBus` as the default implementation.            |
+| `configureBroadcastChannelMessageBus()` | Registers `BroadcastChannelMessageBus` as the default implementation. |

package/message-bus/message-bus-base.js

@@ -13,7 +13,7 @@ export class MessageBusBase extends MessageBus {
         this.logger = logger;
         this.publishSubject = new Subject();
         this.disposeToken = new CancellationToken();
-        this.messages$ = defer(() => this._messages$).pipe(takeUntil(this.disposeToken.set$), share());
+        this.messages$ = defer(() => this._messages$).pipe(takeUntil(this.disposeToken), share());
         this.allMessages$ = merge(this.messages$, this.publishSubject);
     }
     publishAndForget(message) {

package/module/README.md

@@ -0,0 +1,182 @@
+# Application Modules
+
+The `@tstdl/base/module` library provides a robust framework for building modular applications with managed lifecycles. It defines a standard contract for components that need to be started, monitored, and gracefully stopped, such as background workers, API servers, or custom services.
+
+## Table of Contents
+
+- [✨ Features](#-features)
+- [Core Concepts](#core-concepts)
+  - [The Module Class](#the-module-class)
+  - [Lifecycle States](#lifecycle-states)
+- [🚀 Basic Usage](#-basic-usage)
+  - [Creating a Custom Module](#creating-a-custom-module)
+  - [Manual Execution](#manual-execution)
+- [🔧 Advanced Topics](#-advanced-topics)
+  - [FunctionModule](#functionmodule)
+  - [WebServerModule](#webservermodule)
+- [📚 API](#-api)
+
+## ✨ Features
+
+- **Standardized Lifecycle**: Uniform `run()` and `stop()` methods for all application components.
+- **State Management**: Built-in tracking of module states (`Running`, `Stopping`, `Stopped`, `Erroneous`).
+- **Graceful Shutdown**: Integrated `CancellationSignal` support for clean resource cleanup.
+- **Resource Management**: Implemented `AsyncDisposable` for automatic cleanup when using the `using` keyword.
+- **Ready-to-Use Modules**: Includes pre-built modules for common tasks like running functions or web servers.
+- **Type Safety**: Fully typed with TypeScript for reliable development.
+
+## Core Concepts
+
+### The Module Class
+
+The abstract `Module` class is the foundation of this library. It handles the internal state machine and synchronization required to start and stop services safely.
+
+When you extend `Module`, you implement a single protected method: `_run(cancellationSignal)`. This method contains your main logic. The base class ensures that `_run` is called only when the module is stopped and handles the propagation of the cancellation signal when `stop()` is called.
+
+### Lifecycle States
+
+A module is always in one of the following states, defined by the `ModuleState` enum:
+
+1.  **Stopped**: The initial state. The module is ready to run.
+2.  **Running**: The `_run` method is currently executing.
+3.  **Stopping**: A stop has been requested, and the cancellation signal has been triggered, but the `_run` promise has not yet resolved.
+4.  **Erroneous**: The module threw an unhandled exception during execution.
+
+## 🚀 Basic Usage
+
+### Creating a Custom Module
+
+To create a module, extend the `Module` class and implement the `_run` method. Use the provided `CancellationSignal` to detect when the module should stop.
+
+```typescript
+import { CancellationSignal } from '@tstdl/base/cancellation';
+import { Module } from '@tstdl/base/module';
+import { cancelableTimeout } from '@tstdl/base/utils';
+
+export class DataProcessorModule extends Module {
+  constructor() {
+    super('DataProcessor');
+  }
+
+  protected async _run(cancellationSignal: CancellationSignal): Promise<void> {
+    console.log('DataProcessor started.');
+
+    // Run a loop until the signal is set (stop requested)
+    while (cancellationSignal.isUnset) {
+      console.log('Processing data batch...');
+
+      // Simulate work that can be cancelled
+      await cancelableTimeout(1000, cancellationSignal);
+    }
+
+    console.log('DataProcessor stopping gracefully.');
+  }
+}
+```
+
+### Manual Execution
+
+While modules are often managed by an `Application` runner (from `@tstdl/base/application`), you can run them manually.
+
+```typescript
+import { DataProcessorModule } from './data-processor.module.js';
+import { timeout } from '@tstdl/base/utils';
+
+async function main() {
+  const module = new DataProcessorModule();
+
+  // Start the module (non-blocking)
+  const runPromise = module.run();
+
+  console.log(`Module state: ${module.state}`); // Running
+
+  // Let it run for a bit
+  await timeout(3000);
+
+  // Stop the module
+  console.log('Stopping module...');
+  await module.stop();
+
+  // Wait for the run promise to complete to ensure cleanup is done
+  await runPromise;
+
+  console.log(`Module state: ${module.state}`); // Stopped
+}
+
+main();
+```
+
+## 🔧 Advanced Topics
+
+### FunctionModule
+
+The `FunctionModule` is a generic wrapper that allows you to treat a simple asynchronous function as a full-fledged module. This is useful for simple background tasks or scripts that don't require a dedicated class.
+
+It is typically used in conjunction with the dependency injection system or the `Application` runner (from `@tstdl/base/application`), which handles the instantiation and argument injection.
+
+```typescript
+import { Application, provideModule } from '@tstdl/base/application';
+import { CancellationSignal } from '@tstdl/base/cancellation';
+
+async function myTask(signal: CancellationSignal) {
+  console.log('Function module running');
+
+  while (signal.isUnset) {
+    // ... logic
+    await timeout(1000);
+  }
+}
+
+// Run the task as a module within an application
+Application.run('MyApplication', [
+  provideModule(myTask)
+]);
+```
+
+### WebServerModule
+
+The `WebServerModule` is a specialized module that integrates with `@tstdl/base/http` and `@tstdl/base/api` to run an HTTP server. It automatically registers API controllers and handles the server lifecycle.
+
+It is designed to be used with the Dependency Injection system.
+
+**Configuration:**
+
+You can configure the port using `configureWebServerModule`.
+
+```typescript
+import { configureWebServerModule, WebServerModule } from '@tstdl/base/module';
+import { Application, provideModule } from '@tstdl/base/application';
+import { configureNodeHttpServer } from '@tstdl/base/http/node';
+import { configureApiServer } from '@tstdl/base/api/server';
+
+// 1. Configure the environment
+function bootstrap() {
+  configureNodeHttpServer(); // Select Node.js HTTP implementation
+  configureApiServer({
+    controllers: [
+      /* ... your controllers ... */
+    ],
+  });
+
+  // Configure the WebServerModule specific settings
+  configureWebServerModule({ port: 8080 });
+}
+
+// 2. Run the application with the WebServerModule
+Application.run('MyApiServer', [
+  provideModule(WebServerModule),
+  // ... other providers
+]);
+```
+
+## 📚 API
+
+| Type         | Name                           | Description                                                                                                  |
+| :----------- | :----------------------------- | :----------------------------------------------------------------------------------------------------------- |
+| **Class**    | `Module`                       | Abstract base class for all modules. Handles state transitions and cancellation signals. Also implements `AsyncDisposable`. |
+| **Enum**     | `ModuleState`                  | Enumeration of module states: `Running`, `Stopping`, `Stopped`, `Erroneous`.                                 |
+| **Class**    | `FunctionModule`               | A generic module implementation that executes a provided function.                                           |
+| **Type**     | `FunctionModuleFunction`       | Signature for functions used with `FunctionModule`: `(signal: CancellationSignal) => void \| Promise<void>`. |
+| **Class**    | `WebServerModule`              | A module that runs an HTTP server and serves registered API controllers.                                     |
+| **Type**     | `WebServerModuleConfiguration` | Configuration object for `WebServerModule` (e.g., `{ port: number }`).                                       |
+| **Function** | `configureWebServerModule`     | Helper function to set the global configuration for the `WebServerModule`.                                   |

package/module/module.d.ts

@@ -11,7 +11,7 @@ export type ModuleState = EnumType<typeof ModuleState>;
 export declare abstract class Module implements AsyncDisposable {
     private runPromise;
     private _state;
-    protected readonly cancellationToken: CancellationToken;
+    protected cancellationToken: CancellationToken;
     readonly name: string;
     get state(): ModuleState;
     private get stateString();

package/module/module.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { CancellationToken } from '../cancellation/index.js';
 import { defineEnum } from '../enumeration/enumeration.js';
 import { enumValueName } from '../utils/enum.js';
@@ -8,8 +60,8 @@ export const ModuleState = defineEnum('ModuleState', {
     Erroneous: 3,
 });
 export class Module {
-    runPromise;
-    _state;
+    runPromise = Promise.resolve();
+    _state = ModuleState.Stopped;
     cancellationToken;
     name;
     get state() {
@@ -20,27 +72,35 @@ export class Module {
     }
     constructor(name) {
         this.name = name;
-        this.runPromise = Promise.resolve();
-        this._state = ModuleState.Stopped;
-        this.cancellationToken = new CancellationToken();
     }
     async [Symbol.asyncDispose]() {
         await this.stop();
     }
     async run() {
-        if (this._state != ModuleState.Stopped) {
-            throw new Error(`cannot start module, it is ${this.stateString}`);
-        }
-        this.cancellationToken.unset();
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            this._state = ModuleState.Running;
-            this.runPromise = this._run(this.cancellationToken);
-            await this.runPromise;
-            this._state = ModuleState.Stopped;
-        }
-        catch (error) {
-            this._state = ModuleState.Erroneous;
-            throw error;
+            if (this._state != ModuleState.Stopped) {
+                throw new Error(`cannot start module, it is ${this.stateString}`);
+            }
+            const cancellationToken = __addDisposableResource(env_1, new CancellationToken(), false);
+            this.cancellationToken = cancellationToken;
+            try {
+                this._state = ModuleState.Running;
+                this.runPromise = this._run(cancellationToken);
+                await this.runPromise;
+                this._state = ModuleState.Stopped;
+            }
+            catch (error) {
+                this._state = ModuleState.Erroneous;
+                throw error;
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
         }
     }
     async stop() {

package/module/modules/web-server.module.js

@@ -38,7 +38,7 @@ let WebServerModule = class WebServerModule extends Module {
     async _run(cancellationSignal) {
         this.initialize();
         await this.httpServer.listen(this.config.port ?? 8000);
-        const closePromise = cancellationSignal.$set.then(async () => {
+        const closePromise = cancellationSignal.wait().then(async () => {
             await this.httpServer[Symbol.asyncDispose]();
         });
         for await (const context of this.httpServer) {

package/notification/tests/notification-type.service.test.js

@@ -1,35 +1,44 @@
-import { describe, expect, test } from 'vitest';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 import { runInInjectionContext } from '../../injector/index.js';
 import { setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { NotificationTypeService } from '../server/services/notification-type.service.js';
 describe('NotificationTypeService', () => {
-    test('should initialize types correctly', async () => {
-        const { injector, database } = await setupIntegrationTest({ modules: { notification: true, authentication: true } });
-        // Cleanup
+    let injector;
+    let database;
+    beforeEach(async () => {
+        ({ injector, database } = await setupIntegrationTest({ modules: { notification: true, authentication: true } }));
         await truncateTables(database, 'notification', ['type']);
+    });
+    afterEach(async () => {
+        await injector.dispose();
+    });
+    test('should initialize types correctly', async () => {
         const service = injector.resolve(NotificationTypeService);
+        const prefix = crypto.randomUUID();
+        const type1 = `${prefix}_TYPE1`;
+        const type2 = `${prefix}_TYPE2`;
         const typeData = {
-            TYPE1: { label: 'Type 1' },
-            TYPE2: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
+            [type1]: { label: 'Type 1' },
+            [type2]: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
         };
         await runInInjectionContext(injector, async () => {
             const result = await service.initializeTypes(typeData);
-            expect(result.TYPE1.label).toBe('Type 1');
-            expect(result.TYPE2.key).toBe('TYPE2');
-            expect(result.TYPE2.throttling?.limit).toBe(1);
+            expect(result[type1]?.label).toBe('Type 1');
+            expect(result[type2]?.key).toBe(type2);
+            expect(result[type2]?.throttling?.limit).toBe(1);
             // Verify persistence
-            const dbTypes = await service.repository.loadAll();
+            const dbTypes = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
             expect(dbTypes).toHaveLength(2);
             // Update
             const updatedData = {
-                TYPE1: { label: 'Type 1 Updated' },
-                TYPE2: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
+                [type1]: { label: 'Type 1 Updated' },
+                [type2]: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
             };
             const resultUpdated = await service.initializeTypes(updatedData);
-            expect(resultUpdated.TYPE1.label).toBe('Type 1 Updated');
-            const dbTypesUpdated = await service.repository.loadAll();
+            expect(resultUpdated[type1]?.label).toBe('Type 1 Updated');
+            const dbTypesUpdated = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
             expect(dbTypesUpdated).toHaveLength(2);
-            expect(dbTypesUpdated.find((c) => c.key == 'TYPE1')?.label).toBe('Type 1 Updated');
+            expect(dbTypesUpdated.find((c) => c.key == type1)?.label).toBe('Type 1 Updated');
         });
     });
 });