@securitydept/session-context-client 0.3.0-beta.1 → 0.3.0-beta.11

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,19 +1,185 @@
-import { a as SessionPrincipal, i as SessionInfo, n as SessionContextClientConfig, r as SessionContextSource, t as SessionContextClient } from "./client-Dzfx3BXp.mjs";
-
-//#region src/schemas.d.ts
-/**
- * Schema for the canonical SessionInfo shape (camelCase principal).
- *
- * This is the preferred shape once normalized.
- */
-declare const SessionInfoSchema: any;
+import { CancellationTokenOptions, ClientError, DisposableTrait, EventStreamTrait, FoundationEnvironment, IdentityPrincipal, OperationSpanTrait, ReadableSignalTrait, ResourceSnapshot, ResourceTrait, SYMBOL_DISPOSE, SecuritydeptInjectorTrait, SecuritydeptProvider, SpanTrait } from "@securitydept/client";
+//#region src/types.d.ts
+/** 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 SessionContextEventBase {
+  readonly at: number;
+  readonly client: {
+    readonly id: string;
+  };
+}
+type SessionContextEventData = {
+  readonly type: typeof SessionContextEventType.SessionRefreshStarted;
+  readonly session: SessionInfo | null;
+} | {
+  readonly type: typeof SessionContextEventType.SessionRefreshSucceeded;
+  readonly session: SessionInfo | null;
+} | {
+  readonly type: typeof SessionContextEventType.SessionRefreshFailed;
+  readonly session: SessionInfo | null;
+  readonly error: ClientError;
+} | {
+  readonly type: typeof SessionContextEventType.SessionLogoutStarted;
+  readonly session: SessionInfo | null;
+} | {
+  readonly type: typeof SessionContextEventType.SessionLogoutSucceeded;
+  readonly session: null;
+} | {
+  readonly type: typeof SessionContextEventType.SessionLogoutFailed;
+  readonly session: SessionInfo | null;
+  readonly error: ClientError;
+};
+type SessionContextEvent = SessionContextEventBase & SessionContextEventData;
+//#endregion
+//#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: import("arktype/internal/variants/object.ts").ObjectType<(In: {
+  [x: string]: any;
+}) => import("arktype").Out<SessionInfo>, {}>;
 declare const SessionUserInfoResponseSchema: any;
 //#endregion
-export { SessionContextClient, type SessionContextClientConfig, SessionContextSource, type SessionInfo, SessionInfoSchema, type SessionPrincipal, SessionUserInfoResponseSchema };
+//#region src/error.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 SessionContextErrorCode = (typeof SessionContextErrorCode)[keyof typeof SessionContextErrorCode];
+declare const SessionContextSource: {
+  readonly SessionContext: "session-context";
+};
+type SessionContextSource = (typeof SessionContextSource)[keyof typeof SessionContextSource];
+//#endregion
+//#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