@tstdl/base 0.93.187 → 0.93.189

package/rate-limit/rate-limiter.d.ts

@@ -11,10 +11,11 @@ export type RateLimiterConfig = {
     refillInterval: number;
 };
 export type RateLimiterArgument = string | (RateLimiterConfig & {
-    resource: string;
+    namespace: string;
 });
 export declare abstract class RateLimiter extends Transactional implements Resolvable<RateLimiterArgument> {
     readonly [resolveArgumentType]: RateLimiterArgument;
+    abstract readonly namespace: string;
     abstract readonly burstCapacity: number;
     abstract readonly refillInterval: number;
     /**

package/signals/notifier.js

@@ -7,7 +7,7 @@ export function createNotifier() {
         computed: (computation, options) => computed(() => {
             notifier.listen();
             return computation();
-        }, options)
+        }, options),
     };
     return notifier;
 }

package/signals/operators/derive-async.js

@@ -21,7 +21,8 @@ const operatorMap = {
  * @returns A Signal that represents the latest value from the async source.
  */
 export function deriveAsync(source, options) {
-    const initialRaw = untracked(source);
+    const sourceSignal = computed(source);
+    const initialRaw = untracked(sourceSignal);
     const initialSource = isPromise(initialRaw) ? from(initialRaw) : isObservable(initialRaw) ? initialRaw : of(initialRaw);
     const source$ = new BehaviorSubject(initialSource);
     const destroy$ = new Subject();
@@ -44,14 +45,18 @@ export function deriveAsync(source, options) {
         }
         return notification.value;
     }, { equal: options?.equal });
-    let firstRun = true;
+    let lastRaw = initialRaw;
     const effectRef = effect(() => {
-        const rawSource = source();
-        if (firstRun) {
-            firstRun = false;
+        const rawSource = sourceSignal();
+        if (rawSource === lastRaw) {
             return;
         }
-        const observableInput = isPromise(rawSource) ? from(rawSource) : isObservable(rawSource) ? rawSource : of(rawSource);
+        lastRaw = rawSource;
+        const observableInput = isPromise(rawSource)
+            ? from(rawSource)
+            : isObservable(rawSource)
+                ? rawSource
+                : of(rawSource);
         untracked(() => source$.next(observableInput));
     });
     registerFinalization(result, () => {

package/task-queue/postgres/task-queue.js

@@ -86,12 +86,12 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     #logger = inject(Logger, `PostgresTaskQueue:${this.#namespace}`);
     #cancellationSignal = inject(CancellationSignal);
     #rateLimiter = inject(RateLimiter, {
-        resource: this.#namespace,
+        namespace: this.#namespace,
         burstCapacity: this.#config.rateLimit ?? defaultQueueConfig.rateLimit,
         refillInterval: this.#config.rateInterval ?? defaultQueueConfig.rateInterval,
     });
     #circuitBreaker = inject(CircuitBreaker, {
-        key: this.#namespace,
+        namespace: this.#namespace,
         threshold: this.#config.circuitBreakerThreshold ?? defaultQueueConfig.circuitBreakerThreshold,
         resetTimeout: this.#config.circuitBreakerResetTimeout ?? defaultQueueConfig.circuitBreakerResetTimeout,
     });
@@ -616,7 +616,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
         let circuitBreakerResult;
         let rateLimitAcquired = 0;
         if (!forceDequeue) {
-            circuitBreakerResult = await this.#circuitBreaker.check();
+            circuitBreakerResult = await this.#circuitBreaker.check(this.#namespace);
             if (!circuitBreakerResult.allowed) {
                 return [];
             }
@@ -788,7 +788,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 return;
             }
             if (updatedTask.status == TaskStatus.Completed || updatedTask.status == TaskStatus.WaitingChildren) {
-                await this.#circuitBreaker.recordSuccess();
+                await this.#circuitBreaker.recordSuccess(this.#namespace);
             }
             await this.resolveDependencies(task.id, updatedTask.status, { namespace: task.namespace, transaction: tx });
         });
@@ -829,7 +829,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 .from(updated);
             if (updatedRows.length > 0) {
                 if (updatedRows.some((r) => r.status == TaskStatus.Completed || r.status == TaskStatus.WaitingChildren)) {
-                    await this.#circuitBreaker.recordSuccess();
+                    await this.#circuitBreaker.recordSuccess(this.#namespace);
                 }
                 await this.resolveDependenciesMany(updatedRows.map((r) => ({ id: r.id, status: r.status })), { transaction: tx });
             }
@@ -854,7 +854,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
             if (isUndefined(updatedRow)) {
                 return;
             }
-            await this.#circuitBreaker.recordFailure();
+            await this.#circuitBreaker.recordFailure(this.#namespace);
             await this.resolveDependencies(task.id, update.status, { namespace: task.namespace, transaction: tx });
         });
     }
@@ -897,7 +897,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                 .select({ id: updated.id, status: updated.status })
                 .from(updated);
             if (result.length > 0) {
-                await this.#circuitBreaker.recordFailures(result.length);
+                await this.#circuitBreaker.recordFailures(this.#namespace, result.length);
                 await this.resolveDependenciesMany(result.map((r) => ({ id: r.id, status: r.status })), { transaction: tx });
             }
         });
@@ -1171,7 +1171,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
                     .where(inArray(taskTable.id, tx.pgTransaction.select().from(selection)))
                     .returning({ id: taskTable.id, status: taskTable.status });
                 if (updatedRows.length > 0) {
-                    await this.#circuitBreaker.recordFailures(updatedRows.length);
+                    await this.#circuitBreaker.recordFailures(this.#namespace, updatedRows.length);
                     await this.resolveDependenciesMany(updatedRows.map((r) => ({ id: r.id, status: r.status, namespace: this.#namespace })), { transaction: tx });
                 }
                 return updatedRows;

package/testing/integration-setup.js

@@ -191,6 +191,10 @@ export async function setupIsolatedIntegrationTest(options = {}) {
             serviceOptions: {
                 passwordHashing: fastHashDeriveOptions,
                 totp: fastTotpHashingOptions,
+                bruteForceProtection: {
+                    subjectBurstCapacity: 1000000,
+                    ipBurstCapacity: 1000000,
+                },
                 ...options.authentication?.options,
             },
             authenticationAncillaryService: options.authentication?.ancillaryService,