@tstdl/base 0.93.150 → 0.93.151

package/authentication/client/authentication.service.d.ts

@@ -1,4 +1,3 @@
-import { type Observable } from 'rxjs';
 import type { AfterResolve } from '../../injector/index.js';
 import { afterResolve } from '../../injector/index.js';
 import type { Record } from '../../types/index.js';
@@ -36,7 +35,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
      * Observable for authentication errors.
      * Emits when a refresh fails.
      */
-    readonly error$: Observable<Error>;
+    readonly error$: import("rxjs").Observable<Error>;
     /** Current token */
     readonly token: import("../../signals/api.js").WritableSignal<TokenPayload<AdditionalTokenPayload> | undefined>;
     /** Current raw token */
@@ -58,23 +57,23 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     /** Whether the user is impersonated */
     readonly impersonated: import("../../signals/api.js").Signal<boolean>;
     /** Current token */
-    readonly token$: Observable<TokenPayload<AdditionalTokenPayload> | undefined>;
+    readonly token$: import("rxjs").Observable<TokenPayload<AdditionalTokenPayload> | undefined>;
     /** Emits when token is available (not undefined) */
-    readonly definedToken$: Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;
+    readonly definedToken$: import("rxjs").Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;
     /** Emits when a valid token is available (not undefined and not expired) */
-    readonly validToken$: Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;
+    readonly validToken$: import("rxjs").Observable<Exclude<TokenPayload<AdditionalTokenPayload>, void | undefined>>;
     /** Current subject */
-    readonly subjectId$: Observable<string | undefined>;
+    readonly subjectId$: import("rxjs").Observable<string | undefined>;
     /** Emits when subject is available */
-    readonly definedSubjectId$: Observable<string>;
+    readonly definedSubjectId$: import("rxjs").Observable<string>;
     /** Current session id */
-    readonly sessionId$: Observable<string | undefined>;
+    readonly sessionId$: import("rxjs").Observable<string | undefined>;
     /** Emits when session id is available */
-    readonly definedSessionId$: Observable<string>;
+    readonly definedSessionId$: import("rxjs").Observable<string>;
     /** Whether the user is logged in */
-    readonly isLoggedIn$: Observable<boolean>;
+    readonly isLoggedIn$: import("rxjs").Observable<boolean>;
     /** Emits when the user logs out */
-    readonly loggedOut$: Observable<void>;
+    readonly loggedOut$: import("rxjs").Observable<void>;
     private get authenticationData();
     private set authenticationData(value);
     private get impersonatorAuthenticationData();

package/authentication/client/authentication.service.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Subject, filter, firstValueFrom, from, map, race, skip, takeUntil, timer } from 'rxjs';
+import { Subject, filter, firstValueFrom, from, race, skip, takeUntil, timer } from 'rxjs';
 import { CancellationSignal } from '../../cancellation/token.js';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { ForbiddenError } from '../../errors/forbidden.error.js';
@@ -398,76 +398,60 @@ let AuthenticationClientService = class AuthenticationClientService {
         if (this.isLoggedIn()) {
             await this.syncClock();
         }
+        // Helper to sleep until the delay passes OR a vital state change occurs
+        const waitForNextAction = async (delayMs, referenceExp) => await firstValueFrom(race([
+            timer(Math.max(10, delayMs)),
+            from(this.disposeSignal),
+            this.token$.pipe(filter((t) => t?.exp !== referenceExp)),
+            this.forceRefreshRequested$.pipe(filter(Boolean), 
+            // Skip the current value if already true to prevent infinite tight loops
+            skip(this.forceRefreshRequested() ? 1 : 0)),
+        ]), { defaultValue: undefined });
         while (this.disposeSignal.isUnset) {
-            const iterationToken = this.token();
+            const token = this.token();
+            // 1. Wait for login/token if none is present
+            if (isUndefined(token)) {
+                await firstValueFrom(race([this.definedToken$, from(this.disposeSignal)]), { defaultValue: undefined });
+                continue;
+            }
             try {
-                const token = iterationToken;
-                if (isUndefined(token)) {
-                    // Wait for login or dispose.
-                    // We ignore forceRefreshToken here because we can't refresh without a token.
-                    await firstValueFrom(race([this.definedToken$, from(this.disposeSignal)]), { defaultValue: undefined });
-                    continue;
-                }
                 const now = this.estimatedServerTimestampSeconds();
-                const forceRefresh = this.forceRefreshRequested();
-                const refreshBufferSeconds = calculateRefreshBufferSeconds(token);
-                const needsRefresh = forceRefresh || (now >= (token.exp - refreshBufferSeconds));
+                const buffer = calculateRefreshBufferSeconds(token);
+                const needsRefresh = this.forceRefreshRequested() || (now >= token.exp - buffer);
+                // 2. Handle token refresh
                 if (needsRefresh) {
                     const lockResult = await this.lock.tryUse(undefined, async () => {
                         const currentToken = this.token();
+                        if (isUndefined(currentToken)) {
+                            return;
+                        }
+                        // Passive Sync: Verify if refresh is still needed once lock is acquired
                         const currentNow = this.estimatedServerTimestampSeconds();
-                        const currentRefreshBufferSeconds = isDefined(currentToken) ? calculateRefreshBufferSeconds(currentToken) : 0;
-                        // Passive Sync: Check if another tab refreshed the token while we were waiting for the lock (or trying to get it)
-                        const stillNeedsRefresh = isDefined(currentToken) && (this.forceRefreshRequested() || (currentNow >= (currentToken.exp - currentRefreshBufferSeconds)));
+                        const currentBuffer = calculateRefreshBufferSeconds(currentToken);
+                        const stillNeedsRefresh = this.forceRefreshRequested() || (currentNow >= currentToken.exp - currentBuffer);
                         if (stillNeedsRefresh) {
                             await this.refresh();
                         }
-                        if (this.forceRefreshRequested() && (this.token()?.jti != currentToken?.jti)) {
-                            this.forceRefreshRequested.set(false);
-                        }
+                        this.forceRefreshRequested.set(false);
                     });
+                    // If lock is held by another instance/tab, wait briefly for it to finish (passive sync)
                     if (!lockResult.success) {
-                        // Lock held by another instance, wait 5 seconds or until token changes (Passive Sync)
-                        const changeReason = await firstValueFrom(race([
-                            timer(5000).pipe(map(() => 'timer')),
-                            this.token$.pipe(filter((t) => t?.jti != token.jti), map(() => 'token')),
-                            from(this.disposeSignal),
-                        ]), { defaultValue: undefined });
-                        if (changeReason == 'token') {
+                        await waitForNextAction(5000, token.exp);
+                        // If another tab successfully refreshed, the expiration will have changed
+                        if (this.token()?.exp !== token.exp) {
                             this.forceRefreshRequested.set(false);
                         }
-                        continue;
                     }
+                    continue; // Re-evaluate the loop with the newly refreshed (or synced) token
                 }
-                const currentToken = this.token();
-                if (isUndefined(currentToken)) {
-                    continue;
-                }
-                const currentRefreshBufferSeconds = calculateRefreshBufferSeconds(currentToken);
-                const delay = clamp((currentToken.exp - this.estimatedServerTimestampSeconds() - currentRefreshBufferSeconds) * millisecondsPerSecond, minRefreshDelay, maxRefreshDelay);
-                const wakeUpSignals = [
-                    from(this.disposeSignal),
-                    this.token$.pipe(filter((t) => t?.jti != currentToken.jti)),
-                ];
-                if (!forceRefresh) {
-                    wakeUpSignals.push(this.forceRefreshRequested$.pipe(filter((requested) => requested)));
-                }
-                if (delay > 0) {
-                    await firstValueFrom(race([timer(delay), ...wakeUpSignals]), { defaultValue: undefined });
-                }
-                else {
-                    await firstValueFrom(race([timer(2500), ...wakeUpSignals]), { defaultValue: undefined });
-                }
+                // 3. Calculate delay and sleep until the next scheduled refresh window
+                const timeUntilRefreshMs = (token.exp - this.estimatedServerTimestampSeconds() - buffer) * millisecondsPerSecond;
+                const delay = clamp(timeUntilRefreshMs, minRefreshDelay, maxRefreshDelay);
+                await waitForNextAction(delay, token.exp);
             }
             catch (error) {
                 this.logger.error(error);
-                const currentToken = this.token();
-                await firstValueFrom(race([
-                    timer(2500),
-                    from(this.disposeSignal),
-                    this.token$.pipe(filter((t) => t?.jti != currentToken?.jti)),
-                    this.forceRefreshRequested$.pipe(filter((requested) => requested), skip(this.forceRefreshRequested() ? 1 : 0)),
-                ]), { defaultValue: undefined });
+                await waitForNextAction(2500, token.exp);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.150",
+  "version": "0.93.151",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/schema/converters/open-api-converter.js

@@ -1,7 +1,7 @@
 import { NotSupportedError } from '../../errors/not-supported.error.js';
 import { filterUndefinedObjectProperties, fromEntries, hasOwnProperty, objectEntries } from '../../utils/object/object.js';
 import { isDefined, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
-import { ArraySchema, BooleanSchema, DateSchema, DefaultSchema, EnumerationSchema, LiteralSchema, nullable, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema, TransformSchema, Uint8ArraySchema, UnionSchema } from '../schemas/index.js';
+import { AnySchema, ArraySchema, BooleanSchema, DateSchema, DefaultSchema, EnumerationSchema, LiteralSchema, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
 import { schemaTestableToSchema } from '../testable.js';
 export function convertToOpenApiSchema(testable) {
     const schema = schemaTestableToSchema(testable);
@@ -17,7 +17,7 @@ export function convertToOpenApiSchema(testable) {
 function convertToOpenApiSchemaBase(schema) {
     if (schema instanceof ObjectSchema) {
         const entries = objectEntries(schema.properties);
-        const convertedEntries = entries.map(([property, propertySchema]) => [property, convertToOpenApiSchema(stripOptional(propertySchema))]);
+        const convertedEntries = entries.map(([property, propertySchema]) => [property, convertToOpenApiSchema(propertySchema)]);
         const required = entries
             .filter(([, propertySchema]) => !(propertySchema instanceof OptionalSchema) && !((propertySchema instanceof NullableSchema) && (propertySchema.schema instanceof OptionalSchema)))
             .map(([property]) => property);
@@ -29,13 +29,13 @@ function convertToOpenApiSchemaBase(schema) {
             maxProperties: isNumber(schema.maximumPropertiesCount) ? schema.maximumPropertiesCount : undefined,
         });
     }
-    if (schema instanceof DefaultSchema) { // You'd need to import DefaultedSchema
+    if (schema instanceof DefaultSchema) {
         return {
             ...convertToOpenApiSchema(schema.schema),
             default: schema.defaultValue,
         };
     }
-    if (schema instanceof TransformSchema) { // You'd need to import TransformSchema
+    if (schema instanceof TransformSchema) {
         return convertToOpenApiSchema(schema.schema);
     }
     if (schema instanceof StringSchema) {
@@ -114,19 +114,16 @@ function convertToOpenApiSchemaBase(schema) {
             nullable: true,
         };
     }
+    if (schema instanceof OptionalSchema) {
+        return convertToOpenApiSchema(schema.schema);
+    }
     if (schema instanceof UnionSchema) {
         return {
             anyOf: schema.schemas.map((innerSchema) => convertToOpenApiSchema(innerSchema)),
         };
     }
-    throw new NotSupportedError(`Schema "${schema.name}" not supported.`);
-}
-function stripOptional(schema) {
-    if ((schema instanceof OptionalSchema)) {
-        return schema.schema;
-    }
-    if ((schema instanceof NullableSchema) && (schema.schema instanceof OptionalSchema)) {
-        return nullable(schema.schema.schema);
+    if ((schema instanceof AnySchema) || (schema instanceof UnknownSchema)) {
+        return {};
     }
-    return schema;
+    throw new NotSupportedError(`Schema "${schema.name}" not supported.`);
 }