@tstdl/base 0.93.187 → 0.93.188

package/circuit-breaker/circuit-breaker.d.ts

@@ -15,20 +15,32 @@ export type CircuitBreakerCheckResult = {
     state: CircuitBreakerState;
     isProbe: boolean;
 };
-export type CircuitBreakerArgument = string | (CircuitBreakerConfig & {
-    key: string;
+export type CircuitBreakerArgument = string | (Partial<CircuitBreakerConfig> & {
+    namespace: string;
 });
 export declare abstract class CircuitBreaker implements Resolvable<CircuitBreakerArgument> {
     readonly [resolveArgumentType]: CircuitBreakerArgument;
+    abstract readonly namespace: string;
     /**
-     * Checks if execution is allowed.
+     * Checks if execution is allowed for a resource.
      * Transitions from Open to Half-Open automatically if timeout passed.
+     * @param resource The resource to check.
      */
-    abstract check(): Promise<CircuitBreakerCheckResult>;
-    /** Records a success, resetting the breaker to Closed. */
-    abstract recordSuccess(): Promise<void>;
-    /** Records a failure, potentially tripping the breaker to Open. */
-    abstract recordFailure(): Promise<void>;
-    /** Records multiple failures at once. */
-    abstract recordFailures(count: number): Promise<void>;
+    abstract check(resource: string): Promise<CircuitBreakerCheckResult>;
+    /**
+     * Records a success for a resource, resetting its breaker to Closed.
+     * @param resource The resource to record success for.
+     */
+    abstract recordSuccess(resource: string): Promise<void>;
+    /**
+     * Records a failure for a resource, potentially tripping its breaker to Open.
+     * @param resource The resource to record failure for.
+     */
+    abstract recordFailure(resource: string): Promise<void>;
+    /**
+     * Records multiple failures for a resource at once.
+     * @param resource The resource to record failures for.
+     * @param count The number of failures to record.
+     */
+    abstract recordFailures(resource: string, count: number): Promise<void>;
 }

package/circuit-breaker/postgres/circuit-breaker.d.ts

@@ -1,9 +1,10 @@
 import { CircuitBreaker, type CircuitBreakerCheckResult } from '../circuit-breaker.js';
 export declare class PostgresCircuitBreakerService extends CircuitBreaker {
     #private;
-    check(): Promise<CircuitBreakerCheckResult>;
-    recordSuccess(): Promise<void>;
-    recordFailure(): Promise<void>;
-    recordFailures(count: number): Promise<void>;
+    readonly namespace: string;
+    check(resource: string): Promise<CircuitBreakerCheckResult>;
+    recordSuccess(resource: string): Promise<void>;
+    recordFailure(resource: string): Promise<void>;
+    recordFailures(resource: string, count: number): Promise<void>;
     private getPreparedCheckStatement;
 }

package/circuit-breaker/postgres/circuit-breaker.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { and, eq, lte, sql, isNotNull as sqlIsNotNull } from 'drizzle-orm';
 import { injectArgument, provide, Singleton } from '../../injector/index.js';
-import { coalesce, interval, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { CLOCK_TIMESTAMP, coalesce, interval } from '../../orm/index.js';
 import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
 import { isString, isUndefined } from '../../utils/type-guards.js';
 import { millisecondsPerSecond } from '../../utils/units.js';
@@ -17,12 +17,12 @@ import { circuitBreaker } from './schemas.js';
 let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends CircuitBreaker {
     #repository = injectRepository(PostgresCircuitBreaker);
     #arg = injectArgument(this);
-    #key = isString(this.#arg) ? this.#arg : this.#arg.key;
     #threshold = (isString(this.#arg) ? undefined : this.#arg.threshold) ?? 5;
     #resetTimeout = (isString(this.#arg) ? undefined : this.#arg.resetTimeout) ?? 30 * millisecondsPerSecond;
     #checkStatement = this.getPreparedCheckStatement();
-    async check() {
-        const [result] = await this.#checkStatement.execute({ key: this.#key });
+    namespace = isString(this.#arg) ? this.#arg : this.#arg.namespace;
+    async check(resource) {
+        const [result] = await this.#checkStatement.execute({ namespace: this.namespace, resource });
         // 1. Breaker doesn't exist or is Closed
         if (isUndefined(result) || (result.state === CircuitBreakerState.Closed)) {
             return { allowed: true, state: CircuitBreakerState.Closed, isProbe: false };
@@ -38,20 +38,21 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
         // 4. Fallback: Catch-all for Open state where timeout hasn't expired. Reject
         return { allowed: false, state: result.state, isProbe: false };
     }
-    async recordSuccess() {
-        await this.#repository.tryDeleteByQuery({ key: this.#key });
+    async recordSuccess(resource) {
+        await this.#repository.tryDeleteByQuery({ namespace: this.namespace, resource });
     }
-    async recordFailure() {
-        await this.recordFailures(1);
+    async recordFailure(resource) {
+        await this.recordFailures(resource, 1);
     }
-    async recordFailures(count) {
+    async recordFailures(resource, count) {
         const initialTrip = count >= this.#threshold;
         const initialState = initialTrip ? CircuitBreakerState.Open : CircuitBreakerState.Closed;
         const initialResetTimestamp = initialTrip
-            ? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}`
+            ? sql `${CLOCK_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}`
             : null;
-        await this.#repository.upsert(['key'], {
-            key: this.#key,
+        await this.#repository.upsert(['namespace', 'resource'], {
+            namespace: this.namespace,
+            resource,
             state: initialState,
             failureCount: count,
             resetTimestamp: initialResetTimestamp,
@@ -62,7 +63,7 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
           ELSE ${circuitBreaker.state}
         END`,
             resetTimestamp: sql `CASE
-          WHEN ${circuitBreaker.failureCount} + ${count} >= ${this.#threshold} THEN ${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}
+          WHEN ${circuitBreaker.failureCount} + ${count} >= ${this.#threshold} THEN ${CLOCK_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}
           ELSE ${circuitBreaker.resetTimestamp}
         END`,
         });
@@ -72,26 +73,27 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
         const attemptUpdate = session.$with('attempt_update').as(() => session
             .update(circuitBreaker)
             .set({ state: CircuitBreakerState.HalfOpen })
-            .where(and(eq(circuitBreaker.key, sql.placeholder('key')), eq(circuitBreaker.state, CircuitBreakerState.Open), lte(circuitBreaker.resetTimestamp, TRANSACTION_TIMESTAMP)))
+            .where(and(eq(circuitBreaker.namespace, sql.placeholder('namespace')), eq(circuitBreaker.resource, sql.placeholder('resource')), eq(circuitBreaker.state, CircuitBreakerState.Open), lte(circuitBreaker.resetTimestamp, CLOCK_TIMESTAMP)))
             .returning({
-            key: circuitBreaker.key,
+            namespace: circuitBreaker.namespace,
+            resource: circuitBreaker.resource,
             state: circuitBreaker.state,
         }));
         return session
             .with(attemptUpdate)
             .select({
             state: coalesce(attemptUpdate.state, circuitBreaker.state),
-            isProbe: sqlIsNotNull(attemptUpdate.key),
+            isProbe: sqlIsNotNull(attemptUpdate.resource),
         })
             .from(circuitBreaker)
-            .leftJoin(attemptUpdate, eq(circuitBreaker.key, attemptUpdate.key))
-            .where(eq(circuitBreaker.key, sql.placeholder('key')))
+            .leftJoin(attemptUpdate, and(eq(circuitBreaker.namespace, attemptUpdate.namespace), eq(circuitBreaker.resource, attemptUpdate.resource)))
+            .where(and(eq(circuitBreaker.namespace, sql.placeholder('namespace')), eq(circuitBreaker.resource, sql.placeholder('resource'))))
             .prepare('circuit_breaker_check');
     }
 };
 PostgresCircuitBreakerService = __decorate([
     Singleton({
-        argumentIdentityProvider: (arg) => isString(arg) ? arg : arg.key,
+        argumentIdentityProvider: (arg) => isString(arg) ? arg : arg.namespace,
         providers: [
             provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresCircuitBreakerModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: true }) }),
         ],

package/circuit-breaker/postgres/drizzle/{0000_same_captain_cross.sql → 0000_dapper_hercules.sql}

@@ -1,9 +1,10 @@
 CREATE TYPE "circuit_breaker"."circuit_breaker_state" AS ENUM('closed', 'open', 'half-open');--> statement-breakpoint
 CREATE TABLE "circuit_breaker"."circuit_breaker" (
 	"id" uuid PRIMARY KEY DEFAULT uuidv7() NOT NULL,
-	"key" text NOT NULL,
+	"namespace" text NOT NULL,
+	"resource" text NOT NULL,
 	"state" "circuit_breaker"."circuit_breaker_state" NOT NULL,
 	"failure_count" integer NOT NULL,
 	"reset_timestamp" timestamp with time zone,
-	CONSTRAINT "circuit_breaker_key_unique" UNIQUE("key")
+	CONSTRAINT "circuit_breaker_namespace_resource_unique" UNIQUE("namespace","resource")
 );

package/circuit-breaker/postgres/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "fb39f2b0-2e0e-4ebc-bd1c-dc9f97925626",
+  "id": "d6defc88-8e78-4652-bce7-95d26f93e753",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -15,8 +15,14 @@
           "notNull": true,
           "default": "uuidv7()"
         },
-        "key": {
-          "name": "key",
+        "namespace": {
+          "name": "namespace",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resource": {
+          "name": "resource",
           "type": "text",
           "primaryKey": false,
           "notNull": true
@@ -45,11 +51,12 @@
       "foreignKeys": {},
       "compositePrimaryKeys": {},
       "uniqueConstraints": {
-        "circuit_breaker_key_unique": {
-          "name": "circuit_breaker_key_unique",
+        "circuit_breaker_namespace_resource_unique": {
+          "name": "circuit_breaker_namespace_resource_unique",
           "nullsNotDistinct": false,
           "columns": [
-            "key"
+            "namespace",
+            "resource"
           ]
         }
       },

package/circuit-breaker/postgres/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1774646420943,
-      "tag": "0000_same_captain_cross",
+      "when": 1775138615813,
+      "tag": "0000_dapper_hercules",
       "breakpoints": true
     }
   ]

package/circuit-breaker/postgres/model.d.ts

@@ -2,7 +2,8 @@ import { BaseEntity, type Timestamp } from '../../orm/index.js';
 import { CircuitBreakerState } from '../circuit-breaker.js';
 export declare class PostgresCircuitBreaker extends BaseEntity {
     static readonly entityName = "CircuitBreaker";
-    key: string;
+    namespace: string;
+    resource: string;
     state: CircuitBreakerState;
     failureCount: number;
     resetTimestamp: Timestamp | null;

package/circuit-breaker/postgres/model.js

@@ -12,16 +12,20 @@ import { Enumeration, Integer, StringProperty } from '../../schema/index.js';
 import { CircuitBreakerState } from '../circuit-breaker.js';
 let PostgresCircuitBreaker = class PostgresCircuitBreaker extends BaseEntity {
     static entityName = 'CircuitBreaker';
-    key;
+    namespace;
+    resource;
     state;
     failureCount;
     resetTimestamp;
 };
 __decorate([
     StringProperty(),
-    Unique(),
     __metadata("design:type", String)
-], PostgresCircuitBreaker.prototype, "key", void 0);
+], PostgresCircuitBreaker.prototype, "namespace", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], PostgresCircuitBreaker.prototype, "resource", void 0);
 __decorate([
     Enumeration(CircuitBreakerState),
     __metadata("design:type", String)
@@ -35,6 +39,7 @@ __decorate([
     __metadata("design:type", Object)
 ], PostgresCircuitBreaker.prototype, "resetTimestamp", void 0);
 PostgresCircuitBreaker = __decorate([
-    Table('circuit_breaker', { schema: 'circuit_breaker' })
+    Table('circuit_breaker', { schema: 'circuit_breaker' }),
+    Unique(['namespace', 'resource'])
 ], PostgresCircuitBreaker);
 export { PostgresCircuitBreaker };

package/circuit-breaker/postgres/provider.d.ts

@@ -2,5 +2,5 @@ import type { CircuitBreaker, CircuitBreakerConfig } from '../circuit-breaker.js
 import { CircuitBreakerProvider } from '../provider.js';
 export declare class PostgresCircuitBreakerProvider extends CircuitBreakerProvider {
     #private;
-    provide(key: string, config?: CircuitBreakerConfig): CircuitBreaker;
+    provide(namespace: string, config?: CircuitBreakerConfig): CircuitBreaker;
 }

package/circuit-breaker/postgres/provider.js

@@ -10,8 +10,8 @@ import { CircuitBreakerProvider } from '../provider.js';
 import { PostgresCircuitBreakerService } from './circuit-breaker.js';
 let PostgresCircuitBreakerProvider = class PostgresCircuitBreakerProvider extends CircuitBreakerProvider {
     #injector = inject(Injector);
-    provide(key, config) {
-        const argument = config ? { key, ...config } : key;
+    provide(namespace, config) {
+        const argument = config ? { namespace, ...config } : namespace;
         return this.#injector.resolve(PostgresCircuitBreakerService, argument);
     }
 };

package/circuit-breaker/provider.d.ts

@@ -1,4 +1,9 @@
 import type { CircuitBreaker, CircuitBreakerConfig } from './circuit-breaker.js';
 export declare abstract class CircuitBreakerProvider {
-    abstract provide(key: string, config?: CircuitBreakerConfig): CircuitBreaker;
+    /**
+     * Provides a CircuitBreaker for a namespace.
+     * @param namespace The namespace for the circuit breaker.
+     * @param config The configuration for the circuit breaker.
+     */
+    abstract provide(namespace: string, config?: CircuitBreakerConfig): CircuitBreaker;
 }

package/orm/sqls/sqls.d.ts

@@ -55,11 +55,13 @@ export type TsHeadlineOptions = {
      */
     fragmentDelimiter?: string;
 };
-/** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
+/** Get the current transaction's timestamp. */
 export declare const TRANSACTION_TIMESTAMP: SQL<Date>;
-/** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
+/** Get the current clock timestamp (real time, even within transaction). */
+export declare const CLOCK_TIMESTAMP: SQL<Date>;
+/** Generate a random UUID (v4). */
 export declare const RANDOM_UUID_V4: SQL<Uuid>;
-/** Drizzle SQL helper for generating a random UUID (v7). Returns a Uuid string. */
+/** Generate a random UUID (v7). */
 export declare const RANDOM_UUID_V7: SQL<Uuid>;
 export declare const SQL_TRUE: SQL<boolean>;
 export declare const SQL_FALSE: SQL<boolean>;

package/orm/sqls/sqls.js

@@ -25,11 +25,13 @@ function isJsonb(value) {
     }
     return false;
 }
-/** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
+/** Get the current transaction's timestamp. */
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
-/** Drizzle SQL helper for generating a random UUID (v4). Returns a Uuid string. */
+/** Get the current clock timestamp (real time, even within transaction). */
+export const CLOCK_TIMESTAMP = sql `clock_timestamp()`;
+/** Generate a random UUID (v4). */
 export const RANDOM_UUID_V4 = sql `gen_random_uuid()`;
-/** Drizzle SQL helper for generating a random UUID (v7). Returns a Uuid string. */
+/** Generate a random UUID (v7). */
 export const RANDOM_UUID_V7 = sql `uuidv7()`;
 export const SQL_TRUE = sql `TRUE`;
 export const SQL_FALSE = sql `FALSE`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.187",
+  "version": "0.93.188",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -153,8 +153,8 @@
     "type-fest": "^5.5"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.1021",
-    "@aws-sdk/s3-request-presigner": "^3.1021",
+    "@aws-sdk/client-s3": "^3.1022",
+    "@aws-sdk/s3-request-presigner": "^3.1022",
     "@genkit-ai/google-genai": "^1.31",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",
@@ -174,7 +174,7 @@
     "preact": "^10.29",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
-    "undici": "^7.24",
+    "undici": "^8.0",
     "urlpattern-polyfill": "^10.1",
     "zod": "^3.25"
   },

package/rate-limit/postgres/drizzle/{0000_serious_sauron.sql → 0000_previous_zeigeist.sql}

@@ -1,7 +1,8 @@
 CREATE TABLE "rate_limit"."rate_limit" (
 	"id" uuid PRIMARY KEY DEFAULT uuidv7() NOT NULL,
+	"namespace" text NOT NULL,
 	"resource" text NOT NULL,
 	"tokens" double precision NOT NULL,
 	"last_refill_timestamp" timestamp with time zone NOT NULL,
-	CONSTRAINT "rate_limit_resource_unique" UNIQUE("resource")
+	CONSTRAINT "rate_limit_namespace_resource_unique" UNIQUE("namespace","resource")
 );

package/rate-limit/postgres/drizzle/meta/0000_snapshot.json

@@ -1,5 +1,5 @@
 {
-  "id": "7e627538-45f2-41c1-991c-f40ad4f76787",
+  "id": "e46716f4-2778-4a99-b7ac-731d9efead2c",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
@@ -15,6 +15,12 @@
           "notNull": true,
           "default": "uuidv7()"
         },
+        "namespace": {
+          "name": "namespace",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
         "resource": {
           "name": "resource",
           "type": "text",
@@ -38,10 +44,11 @@
       "foreignKeys": {},
       "compositePrimaryKeys": {},
       "uniqueConstraints": {
-        "rate_limit_resource_unique": {
-          "name": "rate_limit_resource_unique",
+        "rate_limit_namespace_resource_unique": {
+          "name": "rate_limit_namespace_resource_unique",
           "nullsNotDistinct": false,
           "columns": [
+            "namespace",
             "resource"
           ]
         }

package/rate-limit/postgres/drizzle/meta/_journal.json

@@ -5,8 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1774646421753,
-      "tag": "0000_serious_sauron",
+      "when": 1775138616730,
+      "tag": "0000_previous_zeigeist",
       "breakpoints": true
     }
   ]

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

@@ -4,6 +4,7 @@ type PostgresRateLimiterContext = {
 };
 export declare class PostgresRateLimiter extends RateLimiter {
     #private;
+    readonly namespace: string;
     readonly burstCapacity: number;
     readonly refillInterval: number;
     readonly refillRate: number;

package/rate-limit/postgres/postgres-rate-limiter.js

@@ -16,6 +16,7 @@ import { rateLimit } from './schemas.js';
 let PostgresRateLimiter = class PostgresRateLimiter extends RateLimiter {
     #repository = injectRepository(PostgresRateLimit);
     #config = this.transactionalContextData?.config ?? injectArgument(this);
+    namespace = isString(this.#config) ? this.#config : this.#config.namespace;
     burstCapacity = isString(this.#config) ? 100 : this.#config.burstCapacity;
     refillInterval = isString(this.#config) ? 1000 : this.#config.refillInterval;
     refillRate = this.burstCapacity / this.refillInterval;
@@ -38,7 +39,7 @@ let PostgresRateLimiter = class PostgresRateLimiter extends RateLimiter {
         const lastRefillMs = sql `(EXTRACT(EPOCH FROM ${rateLimit.lastRefillTimestamp}) * 1000)`;
         const tokensToAdd = sql `(${nowMs} - ${lastRefillMs}) * ${refillRate}`;
         const newTokensExpression = least(burstCapacity, sql `${rateLimit.tokens} + ${tokensToAdd}`);
-        const result = await this.#repository.tryUpsert('resource', { resource, tokens: burstCapacity - cost, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { tokens: sql `${newTokensExpression} - ${cost}`, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { set: gte(newTokensExpression, cost) });
+        const result = await this.#repository.tryUpsert(['namespace', 'resource'], { namespace: this.namespace, resource, tokens: burstCapacity - cost, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { tokens: sql `${newTokensExpression} - ${cost}`, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { set: gte(newTokensExpression, cost) });
         return isDefined(result);
     }
     async refund(resource, amount = 1, options) {
@@ -46,7 +47,7 @@ let PostgresRateLimiter = class PostgresRateLimiter extends RateLimiter {
             return;
         }
         const burstCapacity = options?.burstCapacity ?? this.burstCapacity;
-        await this.#repository.updateByQuery({ resource }, { tokens: least(burstCapacity, sql `${rateLimit.tokens} + ${amount}`) });
+        await this.#repository.updateByQuery({ namespace: this.namespace, resource }, { tokens: least(burstCapacity, sql `${rateLimit.tokens} + ${amount}`) });
     }
     getTransactionalContextData() {
         return { config: this.#config };

package/rate-limit/postgres/rate-limit.model.d.ts

@@ -2,6 +2,7 @@ import { BaseEntity } from '../../orm/index.js';
 import type { Timestamp } from '../../orm/types.js';
 export declare class PostgresRateLimit extends BaseEntity {
     static readonly entityName = "RateLimit";
+    namespace: string;
     resource: string;
     tokens: number;
     lastRefillTimestamp: Timestamp;

package/rate-limit/postgres/rate-limit.model.js

@@ -12,10 +12,15 @@ import { TimestampProperty } from '../../orm/schemas/timestamp.js';
 import { NumberProperty, StringProperty } from '../../schema/index.js';
 let PostgresRateLimit = class PostgresRateLimit extends BaseEntity {
     static entityName = 'RateLimit';
+    namespace;
     resource;
     tokens;
     lastRefillTimestamp;
 };
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], PostgresRateLimit.prototype, "namespace", void 0);
 __decorate([
     StringProperty(),
     __metadata("design:type", String)
@@ -30,6 +35,6 @@ __decorate([
 ], PostgresRateLimit.prototype, "lastRefillTimestamp", void 0);
 PostgresRateLimit = __decorate([
     Table('rate_limit', { schema: 'rate_limit' }),
-    Unique(['resource'])
+    Unique(['namespace', 'resource'])
 ], PostgresRateLimit);
 export { PostgresRateLimit };

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

@@ -2,5 +2,5 @@ import { RateLimiterProvider } from '../provider.js';
 import { RateLimiter, type RateLimiterConfig } from '../rate-limiter.js';
 export declare class PostgresRateLimiterProvider extends RateLimiterProvider {
     #private;
-    get(resource: string, config: RateLimiterConfig): RateLimiter;
+    get(namespace: string, config: RateLimiterConfig): RateLimiter;
 }

package/rate-limit/postgres/rate-limiter.provider.js

@@ -11,8 +11,8 @@ import { RateLimiter } from '../rate-limiter.js';
 import { PostgresRateLimiter } from './postgres-rate-limiter.js';
 let PostgresRateLimiterProvider = class PostgresRateLimiterProvider extends RateLimiterProvider {
     #injector = inject(Injector);
-    get(resource, config) {
-        return this.#injector.resolve(PostgresRateLimiter, { ...config, resource });
+    get(namespace, config) {
+        return this.#injector.resolve(PostgresRateLimiter, { ...config, namespace });
     }
 };
 PostgresRateLimiterProvider = __decorate([

package/rate-limit/provider.d.ts

@@ -1,9 +1,9 @@
 import type { RateLimiter, RateLimiterConfig } from './rate-limiter.js';
 export declare abstract class RateLimiterProvider {
     /**
-     * Gets a RateLimiter instance for the specified resource and configuration.
-     * @param resource The unique name of the rate limiter.
+     * Gets a RateLimiter instance for the specified namespace and configuration.
+     * @param namespace The namespace of the rate limiter.
      * @param config The configuration for the rate limiter.
      */
-    abstract get(resource: string, config: RateLimiterConfig): RateLimiter;
+    abstract get(namespace: string, config: RateLimiterConfig): RateLimiter;
 }

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/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, () => {