gdc-sdk-node-ts 2.2.2 → 2.3.1

package/dist/simple-smart-token.d.ts

@@ -1,58 +0,0 @@
-import type { PollOptions, SubmitAndPollResult } from './orchestration/client-port.js';
-import type { RouteContext } from './simple-individual-onboarding.js';
-export type SmartTokenRequestInput = {
-    tenantId?: string;
-    jurisdiction?: string;
-    sector?: string;
-    idToken: string;
-    scopes: string[];
-    subjectDid?: string;
-    vpToken?: string;
-    clientId?: string;
-    audience?: string;
-    issuer?: string;
-    redirectUri?: string;
-    acrValues?: string;
-    codeChallenge?: string;
-    codeChallengeMethod?: 'S256';
-    presentationSubmission?: Record<string, unknown>;
-    purpose?: string;
-    requestBodyClaims?: Record<string, unknown>;
-    smartTokenKind?: 'token-exchange' | 'openid-smart';
-    tokenCacheKey?: string;
-    endpointId?: string;
-    timeoutSeconds?: number;
-    intervalSeconds?: number;
-    additionalClaims?: Record<string, unknown>;
-};
-export type SmartTokenExchangeResult = {
-    status: 'fetched' | 'cached' | 'failed';
-    accessToken?: string;
-    tokenType?: string;
-    scopes?: string[];
-    statusCode?: number;
-    response?: unknown;
-};
-type CachedTokenWrite = {
-    accessToken: string;
-    tokenType: string;
-    scopes: string[];
-    expiresAt: number;
-};
-type RequestSmartTokenDeps = {
-    input: SmartTokenRequestInput;
-    routeCtx: RouteContext;
-    baseUrl: string;
-    defaultTimeoutMs?: number;
-    defaultIntervalMs?: number;
-    identityTokenExchangePath: (ctx: RouteContext) => string;
-    identityTokenExchangePollPath: (ctx: RouteContext) => string;
-    identityOpenIdSmartTokenPath: (ctx: RouteContext) => string;
-    identityOpenIdSmartTokenPollPath: (ctx: RouteContext) => string;
-    submitAndPoll: (submitPath: string, pollPath: string, payload: {
-        thid?: string;
-    } & Record<string, unknown>, options?: PollOptions) => Promise<SubmitAndPollResult>;
-    setTokenCache: (tokenCacheKey: string, token: CachedTokenWrite) => void;
-};
-export declare function requestSmartTokenWithDeps(deps: RequestSmartTokenDeps): Promise<SmartTokenExchangeResult>;
-export {};

package/dist/simple-smart-token.js

@@ -1,85 +0,0 @@
-// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { resolvePollOptionsFromSeconds } from './simple-poll-options.js';
-export async function requestSmartTokenWithDeps(deps) {
-    const normalizedScopes = Array.from(new Set((deps.input.scopes || []).filter(Boolean))).sort();
-    const tokenCacheKey = String(deps.input.tokenCacheKey || deps.input.endpointId || `smart:${deps.routeCtx.tenantId}:${normalizedScopes.join(',')}`).trim();
-    if (!tokenCacheKey) {
-        throw new Error('requestSmartToken requires tokenCacheKey (or non-empty scopes).');
-    }
-    const pollOptions = resolvePollOptionsFromSeconds(deps.input.timeoutSeconds, deps.input.intervalSeconds, {
-        timeoutMs: deps.defaultTimeoutMs,
-        intervalMs: deps.defaultIntervalMs,
-    });
-    if (deps.input.smartTokenKind === 'openid-smart') {
-        const smartPayload = {
-            thid: `smart-${createRuntimeUuid()}`,
-            iss: deps.input.issuer || deps.input.clientId || deps.routeCtx.tenantId,
-            aud: deps.input.audience || deps.routeCtx.tenantId,
-            body: {
-                client_id: deps.input.clientId || deps.input.subjectDid || deps.routeCtx.tenantId,
-                redirect_uri: deps.input.redirectUri || `${deps.baseUrl}/callback`,
-                code_challenge: deps.input.codeChallenge || 'demo-code-challenge',
-                code_challenge_method: deps.input.codeChallengeMethod || 'S256',
-                acr_values: deps.input.acrValues || 'urn:antifraud:acr:openid4vp:employee',
-                vp_token: deps.input.vpToken || deps.input.idToken,
-                presentation_submission: deps.input.presentationSubmission,
-                expires_in: 300,
-                token_type: 'Bearer',
-                sub: deps.input.subjectDid || deps.input.issuer || deps.input.clientId || deps.routeCtx.tenantId,
-                purpose: deps.input.purpose || 'TREAT',
-                scope: normalizedScopes.join(' '),
-                ...(deps.input.requestBodyClaims || {}),
-            },
-            ...(deps.input.additionalClaims || {}),
-        };
-        const exchange = await deps.submitAndPoll(deps.identityOpenIdSmartTokenPath(deps.routeCtx), deps.identityOpenIdSmartTokenPollPath(deps.routeCtx), smartPayload, pollOptions);
-        return resolveTokenExchangeResult(exchange, normalizedScopes, tokenCacheKey, deps.setTokenCache);
-    }
-    const payload = {
-        thid: `exchange-${createRuntimeUuid()}`,
-        grant_type: 'urn:ietf:params:oauth:grant-type:token-exchange',
-        subject_token_type: 'urn:ietf:params:oauth:token-type:id_token',
-        subject_token: deps.input.idToken,
-        scope: normalizedScopes.join(' '),
-        organization: deps.routeCtx.tenantId,
-        ...(deps.input.additionalClaims || {}),
-    };
-    const exchange = await deps.submitAndPoll(deps.identityTokenExchangePath(deps.routeCtx), deps.identityTokenExchangePollPath(deps.routeCtx), payload, pollOptions);
-    return resolveTokenExchangeResult(exchange, normalizedScopes, tokenCacheKey, deps.setTokenCache);
-}
-function resolveTokenExchangeResult(exchange, normalizedScopes, tokenCacheKey, setTokenCache) {
-    const exchangeBody = exchange.poll.body ?? {};
-    const accessToken = String(exchangeBody.access_token || '').trim();
-    if (exchange.poll.status >= 400 || !accessToken) {
-        return {
-            status: 'failed',
-            statusCode: exchange.poll.status,
-            response: exchange.poll.body,
-        };
-    }
-    const tokenType = String(exchangeBody.token_type || 'Bearer');
-    const grantedScopes = String(exchangeBody.scope || '').trim().split(' ').filter(Boolean);
-    const resolvedScopes = grantedScopes.length ? grantedScopes : normalizedScopes;
-    const expiresIn = Number(exchangeBody.expires_in ?? 0);
-    setTokenCache(tokenCacheKey, {
-        accessToken,
-        tokenType,
-        scopes: resolvedScopes,
-        expiresAt: Date.now() + expiresIn * 1000,
-    });
-    return {
-        status: 'fetched',
-        accessToken,
-        tokenType,
-        scopes: resolvedScopes,
-        statusCode: exchange.poll.status,
-        response: exchange.poll.body,
-    };
-}
-function createRuntimeUuid() {
-    const fromCrypto = globalThis.crypto?.randomUUID?.();
-    if (fromCrypto) {
-        return fromCrypto;
-    }
-    return `fallback-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-}