@securitydept/session-context-client 0.3.0-beta.3 → 0.3.0-beta.5

package/README.md

@@ -2,4 +2,10 @@
 
 Session Context Client of the SecurityDept TypeScript SDK, a layered authentication and authorization toolkit built as reusable Rust crates, a TypeScript client SDK workspace, and reference server/web apps.
 
+## Documentation
+
+- [Package documentation](https://www.npmjs.com/package/@securitydept/session-context-client)
+- [SecurityDept TypeScript SDK guide](https://github.com/ethaxon/securitydept/blob/main/docs/en/007-CLIENT_SDK_GUIDE.md)
+- [SecurityDept architecture](https://github.com/ethaxon/securitydept/blob/main/docs/en/001-ARCHITECTURE.md)
+
 Repository: [ethaxon/securitydept](https://github.com/ethaxon/securitydept)

package/dist/index.d.mts

@@ -1,56 +1,167 @@
-import { a as SessionPrincipal, i as SessionInfo, n as SessionContextClientConfig, r as SessionContextSource, t as SessionContextClient } from "./client-BRqKhOuj.mjs";
-import { HttpTransport, ReadableSignalTrait } from "@securitydept/client";
+import { CancellationTokenOptions, DisposableTrait, ErrorSummary, EventStreamTrait, FoundationEnvironment, IdentityPrincipal, OperationSpanTrait, ReadableSignalTrait, ResourceSnapshot, ResourceTrait, SYMBOL_DISPOSE, SecuritydeptInjectorTrait, SecuritydeptProvider, SpanTrait } from "@securitydept/client";
+import * as _$arktype from "arktype";
+import * as _$arktype_internal_variants_object_ts0 from "arktype/internal/variants/object.ts";
 
-//#region src/controller.d.ts
-declare const SessionContextControllerStatus: {
-  readonly Idle: "idle";
-  readonly Loading: "loading";
-  readonly Authenticated: "authenticated";
-  readonly Unauthenticated: "unauthenticated";
-  readonly Error: "error";
+//#region src/types.d.ts
+declare const SessionContextErrorCode: {
+  readonly OperationFailed: "session.operation_failed";
+  readonly ClientDisposed: "session.client_disposed";
+  readonly RouterUnavailable: "session.router_unavailable";
+  readonly InvalidSessionPayload: "session.invalid_user_info_payload";
 };
-type SessionContextControllerStatus = (typeof SessionContextControllerStatus)[keyof typeof SessionContextControllerStatus];
-interface SessionContextControllerState {
-  status: SessionContextControllerStatus;
-  session: SessionInfo | null;
-  error: unknown | null;
-}
-interface SessionContextControllerOptions {
-  client: SessionContextClient;
-  transport: HttpTransport;
-}
-declare class SessionContextController {
-  readonly client: SessionContextClient;
-  readonly state: ReadableSignalTrait<SessionContextControllerState>;
-  private readonly transport;
-  private readonly stateSignal;
-  private refreshPromise;
-  private disposed;
-  constructor(options: SessionContextControllerOptions);
-  getState(): SessionContextControllerState;
-  subscribe(listener: () => void): () => void;
-  refresh(): Promise<SessionInfo | null>;
-  rememberPostAuthRedirect(uri: string): Promise<void>;
-  clearPostAuthRedirect(): Promise<void>;
-  resolveLoginUrl(): Promise<string>;
-  logout(): Promise<void>;
-  dispose(): void;
+type SessionContextErrorCode = (typeof SessionContextErrorCode)[keyof typeof SessionContextErrorCode];
+declare const SessionContextSource: {
+  readonly SessionContext: "session-context";
+};
+type SessionContextSource = (typeof SessionContextSource)[keyof typeof SessionContextSource];
+/** Session principal — shared authenticated principal semantics via @securitydept/client. */
+type SessionPrincipal = IdentityPrincipal;
+/** Session info returned from the server. */
+interface SessionInfo {
+  principal: SessionPrincipal;
+  attributes?: Record<string, unknown>;
+  extra?: Record<string, unknown>;
+}
+interface SessionContextClientTracingOptions {
+  target?: string;
+  prefix?: string;
+}
+interface SessionContextOperationOptions extends CancellationTokenOptions {}
+interface SessionLoginWithRedirectOptions extends CancellationTokenOptions {
+  postAuthRedirectUri?: string;
+}
+/** Configuration for the Session Context Client. */
+interface SessionContextClientConfig {
+  id?: string;
+  /** Base URL of the SecurityDept server. */
+  baseUrl: string;
+  /** Login path (default: "/auth/session/login"). */
+  loginPath?: string;
+  /** Logout path (default: "/auth/session/logout"). */
+  logoutPath?: string;
+  /** User info endpoint path (default: "/auth/session/user-info"). */
+  userInfoPath?: string;
+  autoStart?: boolean;
+  tracing?: SessionContextClientTracingOptions;
+}
+interface ResolvedSessionContextClientConfig {
+  id: string;
+  baseUrl: string;
+  loginPath: string;
+  logoutPath: string;
+  userInfoPath: string;
+  tracing: Required<SessionContextClientTracingOptions>;
+}
+declare const SessionContextEventType: {
+  readonly SessionRefreshStarted: "session.refresh.started";
+  readonly SessionRefreshSucceeded: "session.refresh.succeeded";
+  readonly SessionRefreshFailed: "session.refresh.failed";
+  readonly SessionLogoutStarted: "session.logout.started";
+  readonly SessionLogoutSucceeded: "session.logout.succeeded";
+  readonly SessionLogoutFailed: "session.logout.failed";
+};
+type SessionContextEventType = (typeof SessionContextEventType)[keyof typeof SessionContextEventType];
+interface SessionContextEvent {
+  type: SessionContextEventType;
+  at: number;
+  client: {
+    id: string;
+  };
+  session?: SessionInfo | null;
+  errorSummary?: ErrorSummary;
 }
 //#endregion
-//#region src/schemas.d.ts
-/**
- * Schema for the canonical SessionInfo shape (camelCase principal).
- *
- * This is the preferred shape once normalized.
- */
-declare const SessionInfoSchema: any;
+//#region src/client.d.ts
+interface SessionContextOperationSignals {
+  readonly startPending: ReadableSignalTrait<boolean>;
+  readonly refreshPending: ReadableSignalTrait<boolean>;
+  readonly logoutPending: ReadableSignalTrait<boolean>;
+  readonly loginRedirectPending: ReadableSignalTrait<boolean>;
+}
 /**
- * Schema for the Rust server session user-info response shape.
+ * Session Context Client.
  *
- * Validates the real `/auth/session/user-info` wire payload and normalizes it
- * into SessionInfo in one step.
+ * Owns session state, lifecycle, login/logout navigation, and tracing.
+ * Host capabilities are resolved once through FoundationEnvironment at
+ * construction time.
  */
+declare class SessionContextClient implements DisposableTrait {
+  [SYMBOL_DISPOSE]: () => void;
+  static defaultOptions: {
+    readonly loginPath: "/auth/session/login";
+    readonly logoutPath: "/auth/session/logout";
+    readonly userInfoPath: "/auth/session/user-info";
+    readonly tracing: {
+      readonly target: "session-context-client";
+      readonly prefix: "session_context";
+    };
+  };
+  private readonly _environment;
+  private readonly _config;
+  private readonly _span;
+  private readonly _rootCancellation;
+  private readonly _destroyed;
+  private readonly destroyed$;
+  private readonly _sessionSnapshotSignal;
+  private readonly _operationSignals;
+  private readonly _eventSubject;
+  private readonly _refreshCommandSubject;
+  private readonly _refreshResponseSubject;
+  private readonly _logoutCommandSubject;
+  private readonly _logoutResponseSubject;
+  private readonly _startOnce;
+  readonly id: string;
+  readonly sessionSnapshot: ReadableSignalTrait<ResourceSnapshot<SessionInfo | null>>;
+  readonly sessionResource: ResourceTrait<SessionInfo | null>;
+  readonly isAuthenticated: ResourceTrait<boolean>;
+  readonly sessionOperations: SessionContextOperationSignals;
+  readonly events: EventStreamTrait<SessionContextEvent>;
+  protected get environment(): FoundationEnvironment;
+  protected get span(): SpanTrait;
+  protected get config(): ResolvedSessionContextClientConfig;
+  static fromEnvironmentConfig(options: {
+    readonly config: SessionContextClientConfig;
+    readonly environment: FoundationEnvironment;
+  }): SessionContextClient;
+  static fromInjector(injector: SecuritydeptInjectorTrait): SessionContextClient;
+  protected constructor(config: SessionContextClientConfig, environment: FoundationEnvironment);
+  start(operationSpan?: OperationSpanTrait): Promise<SessionInfo | null>;
+  refresh(options?: SessionContextOperationOptions): Promise<SessionInfo | null>;
+  private _refresh;
+  logout(options?: SessionContextOperationOptions): Promise<void>;
+  private _logout;
+  loginWithRedirect(options?: SessionLoginWithRedirectOptions): Promise<void>;
+  private _loginWithRedirect;
+  dispose(): void;
+  private _dispatchRefresh;
+  private _dispatchLogout;
+  private _executeRefresh;
+  private _executeLogout;
+  private _fetchSessionInfo;
+  private _createLoginRedirectUrl;
+  private _createLogoutUrl;
+  private _readCurrentSession;
+  private _emitSessionEvent;
+}
+//#endregion
+//#region src/contracts/parsers.d.ts
+declare function parseSessionInfoPayload(body: unknown): SessionInfo;
+//#endregion
+//#region src/contracts/schemas.d.ts
+declare const SessionInfoSchema: _$arktype_internal_variants_object_ts0.ObjectType<(In: {
+  [x: string]: any;
+}) => _$arktype.Out<SessionInfo>, {}>;
 declare const SessionUserInfoResponseSchema: any;
 //#endregion
-export { SessionContextClient, type SessionContextClientConfig, SessionContextController, type SessionContextControllerOptions, type SessionContextControllerState, SessionContextControllerStatus, type SessionContextControllerStatus as SessionContextControllerStatusType, SessionContextSource, type SessionInfo, SessionInfoSchema, type SessionPrincipal, SessionUserInfoResponseSchema };
+//#region src/providers.d.ts
+interface ProvideSessionContextOptions {
+  readonly config: SessionContextClientConfig;
+}
+declare function provideSessionContext(options: ProvideSessionContextOptions): readonly SecuritydeptProvider[];
+//#endregion
+//#region src/tokens.d.ts
+declare const SESSION_CONTEXT_CLIENT: any;
+declare const SESSION_CONTEXT_CLIENT_CONFIG: any;
+//#endregion
+export { type ProvideSessionContextOptions, SESSION_CONTEXT_CLIENT, SESSION_CONTEXT_CLIENT_CONFIG, SessionContextClient, type SessionContextClientConfig, type SessionContextClientTracingOptions, SessionContextErrorCode, type SessionContextEvent, SessionContextEventType, type SessionContextOperationOptions, SessionContextSource, type SessionInfo, SessionInfoSchema, type SessionLoginWithRedirectOptions, type SessionPrincipal, SessionUserInfoResponseSchema, parseSessionInfoPayload, provideSessionContext };
 //# sourceMappingURL=index.d.mts.map