@asgardeo/javascript 0.0.1 → 0.1.1

package/dist/models/token.d.ts

@@ -31,11 +31,11 @@ export interface TokenResponse {
      */
     accessToken: string;
     /**
-     * JSON Web Token (JWT) containing user identity information.
-     * This token can be decoded to access user claims and metadata
-     * without additional server requests.
+     * Unix timestamp (in seconds) when the token was created.
+     * Used in combination with expiresIn to determine when
+     * the token needs to be refreshed.
      */
-    idToken: string;
+    createdAt: number;
     /**
      * Duration in seconds until the access token expires.
      * Applications should refresh the token before this time
@@ -43,29 +43,29 @@ export interface TokenResponse {
      */
     expiresIn: string;
     /**
-     * Space-separated list of OAuth scopes granted to the application.
-     * These scopes determine what resources and actions the application
-     * has permission to access.
+     * JSON Web Token (JWT) containing user identity information.
+     * This token can be decoded to access user claims and metadata
+     * without additional server requests.
      */
-    scope: string;
+    idToken: string;
     /**
      * Token used to obtain new access tokens without re-authentication.
      * Store this securely as it enables long-term access to the user's
      * account through the refresh flow.
      */
     refreshToken: string;
+    /**
+     * Space-separated list of OAuth scopes granted to the application.
+     * These scopes determine what resources and actions the application
+     * has permission to access.
+     */
+    scope: string;
     /**
      * The type of token issued, typically "Bearer".
      * This indicates how the token should be used in
      * API request Authorization headers.
      */
     tokenType: string;
-    /**
-     * Unix timestamp (in seconds) when the token was created.
-     * Used in combination with expiresIn to determine when
-     * the token needs to be refreshed.
-     */
-    createdAt: number;
 }
 /**
  * Represents the raw token response received directly from the authentication server.
@@ -82,18 +82,18 @@ export interface AccessTokenApiResponse {
      * before any processing or validation.
      */
     access_token: string;
-    /**
-     * Raw expiration time in seconds.
-     * Indicates how long the access token will be valid
-     * from the time it was issued.
-     */
-    expires_in: string;
     /**
      * Server-provided creation timestamp in Unix seconds.
      * Used to track when the token was originally issued
      * and calculate absolute expiration time.
      */
     created_at: number;
+    /**
+     * Raw expiration time in seconds.
+     * Indicates how long the access token will be valid
+     * from the time it was issued.
+     */
+    expires_in: string;
     /**
      * Raw ID token string containing encoded user information.
      * This JWT can be decoded to access standardized claims
@@ -119,3 +119,62 @@ export interface AccessTokenApiResponse {
      */
     token_type: string;
 }
+/**
+ * Interface for the standard (required) claims of an ID Token payload.
+ */
+export interface KnownIdToken {
+    /**
+     * The audience for which this token is intended.
+     */
+    aud: string | string[];
+    /**
+     * The email of the user.
+     */
+    email?: string;
+    /**
+     * The issuer identifier for the issuer of the response.
+     */
+    iss: string;
+    /**
+     * The unique human readable slug of the organization to which the user belongs.
+     */
+    org_handle?: string;
+    /**
+     * The unique identifier of the organization to which the user belongs.
+     */
+    org_id?: string;
+    /**
+     * The human readable name of the organization to which the user belongs.
+     */
+    org_name?: string;
+    /**
+     * The username the user prefers to be called.
+     */
+    preferred_username?: string;
+    /**
+     * The unique identifier of the user to whom the ID token belongs.
+     */
+    sub: string;
+    /**
+     * The tenant domain of the user.
+     */
+    tenant_domain?: string;
+}
+/**
+ * Interface for ID Token payload including custom claims.
+ */
+export interface IdToken extends KnownIdToken {
+    /**
+     * Other custom claims.
+     */
+    [claim: string]: any;
+}
+export interface TokenExchangeRequestConfig {
+    attachToken: boolean;
+    data: any;
+    id: string;
+    returnsSession: boolean;
+    shouldReplayAfterRefresh?: boolean;
+    signInRequired: boolean;
+    tokenEndpoint?: string;
+}

package/dist/models/user.d.ts

@@ -16,91 +16,18 @@
  * under the License.
  */
 import { Schema } from './scim2-schema';
-/**
- * Type for the Meta object in SCIM2 responses
- */
-export interface UserMeta {
-    created: string;
-    location: string;
-    lastModified: string;
-    resourceType: string;
+export interface KnownUser {
+    username?: string;
+    email?: string;
+    givenName?: string;
+    familyName?: string;
+    displayName?: string;
 }
-/**
- * Type for the Role object in SCIM2 responses
- */
-export interface UserRole {
-    audienceValue: string;
-    display: string;
-    audienceType: string;
-    value: string;
-    $ref: string;
-    audienceDisplay: string;
-}
-/**
- * Type for the Name object in SCIM2 responses
- */
-export interface UserName {
-    formatted: string;
-    givenName: string;
-    familyName: string;
+export interface User extends KnownUser {
+    [key: string]: any;
 }
-/**
- * Represents a user in the Asgardeo system.
- *
- * @remarks
- * This interface defines the user properties based on the SCIM2 schema.
- * WSO2 specific properties are flattened to the root level for easier access.
- *
- * @example
- * ```typescript
- * const user: User = {
- *   emails: ["user@example.com"],
- *   profileUrl: "https://gravatar.com/avatar/123",
- *   meta: {
- *     created: "2021-06-21T11:28:21.800618Z",
- *     location: "https://api.asgardeo.io/scim2/Users/123",
- *     lastModified: "2025-04-30T06:46:48.520896Z",
- *     resourceType: "User"
- *   },
- *   name: {
- *     formatted: "John Smith",
- *     givenName: "John",
- *     familyName: "Smith"
- *   },
- *   userName: "john@example.com",
- *   id: "123",
- *   // Flattened WSO2 schema properties
- *   accountState: "UNLOCKED",
- *   accountLocked: "false",
- *   photoUrl: "https://gravatar.com/avatar/123",
- *   emailVerified: "true",
- *   lastLogonTime: "1749098996152"
- * };
- * ```
- */
-export interface User {
-    emails: string[];
-    profileUrl?: string;
-    meta: UserMeta;
+export interface UserProfile {
     schemas: Schema[];
-    roles?: UserRole[];
-    name: UserName;
-    id: string;
-    userName: string;
-    accountState?: string;
-    accountLocked?: string;
-    failedLoginLockoutCount?: string;
-    failedTOTPAttempts?: string;
-    failedLoginAttempts?: string;
-    totpEnabled?: string;
-    photoUrl?: string;
-    emailVerified?: string;
-    backupCodeEnabled?: string;
-    lastLogonTime?: string;
-    signedUpRegion?: string;
-    unlockTime?: string;
-    isReadOnlyUser?: string;
-    failedLoginAttemptsBeforeSuccess?: string;
-    [key: string]: any;
+    profile: User;
+    flattenedProfile: User;
 }
-export default User;

package/dist/theme/createTheme.d.ts

@@ -15,7 +15,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { RecursivePartial } from '../models/utility-types';
 import { Theme, ThemeConfig } from './types';
+import { RecursivePartial } from '../models/utility-types';
 declare const createTheme: (config?: RecursivePartial<ThemeConfig>, isDark?: boolean) => Theme;
 export default createTheme;

package/dist/theme/types.d.ts

@@ -16,41 +16,53 @@
  * under the License.
  */
 export interface ThemeColors {
-    primary: {
+    background: {
+        body: {
+            main: string;
+        };
+        disabled: string;
+        surface: string;
+    };
+    border: string;
+    error: {
+        contrastText: string;
         main: string;
+    };
+    primary: {
         contrastText: string;
+        main: string;
     };
     secondary: {
-        main: string;
         contrastText: string;
+        main: string;
     };
-    background: {
-        surface: string;
-        disabled: string;
-        body: {
-            main: string;
-        };
+    success: {
+        contrastText: string;
+        main: string;
     };
-    surface: string;
     text: {
         primary: string;
         secondary: string;
     };
-    border: string;
-    error: {
-        main: string;
+    warning: {
         contrastText: string;
+        main: string;
     };
 }
 export interface ThemeConfig {
-    colors: ThemeColors;
-    spacing: {
-        unit: number;
-    };
     borderRadius: {
-        small: string;
+        large: string;
         medium: string;
+        small: string;
+    };
+    colors: ThemeColors;
+    shadows: {
         large: string;
+        medium: string;
+        small: string;
+    };
+    spacing: {
+        unit: number;
     };
 }
 export interface Theme extends ThemeConfig {

package/dist/utils/deepMerge.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Recursively merges the properties of source objects into a target object.
+ * Similar to Lodash's merge function, this creates a deep copy and merges
+ * nested objects recursively. Arrays and non-plain objects are replaced entirely.
+ *
+ * @param target - The target object to merge into
+ * @param sources - One or more source objects to merge from
+ * @returns A new object with merged properties
+ *
+ * @example
+ * ```typescript
+ * const obj1 = { a: 1, b: { x: 1, y: 2 } };
+ * const obj2 = { b: { y: 3, z: 4 }, c: 3 };
+ * const result = deepMerge(obj1, obj2);
+ * // Result: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 3 }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const config = { theme: { colors: { primary: 'blue' } } };
+ * const userPrefs = { theme: { colors: { secondary: 'red' } } };
+ * const merged = deepMerge(config, userPrefs);
+ * // Result: { theme: { colors: { primary: 'blue', secondary: 'red' } } }
+ * ```
+ */
+declare const deepMerge: <T extends Record<string, any>>(target: T, ...sources: Array<Record<string, any> | undefined | null>) => T;
+export default deepMerge;

package/dist/utils/extractTenantDomainFromIdTokenPayload.d.ts

@@ -15,7 +15,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { IdTokenPayload } from '../models/id-token';
+import { IdToken } from '../models/token';
 /**
  * Extracts the tenant domain from the ID token payload.
  *
@@ -27,5 +27,5 @@ import { IdTokenPayload } from '../models/id-token';
  *
  * Consider extracting the tenant domain using a dedicated claim (e.g., `tenant_domain`) when available.
  */
-declare const extractTenantDomainFromIdTokenPayload: (payload: IdTokenPayload, subjectSeparator?: string) => string;
+declare const extractTenantDomainFromIdTokenPayload: (payload: IdToken, subjectSeparator?: string) => string;
 export default extractTenantDomainFromIdTokenPayload;

package/dist/utils/extractUserClaimsFromIdToken.d.ts

@@ -15,7 +15,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { IdTokenPayload } from '../models/id-token';
+import { IdToken } from '../models/token';
 /**
  * Removes standard protocol-specific claims from the ID token payload
  * and returns a camelCased object of user-specific claims.
@@ -40,5 +40,5 @@ import { IdTokenPayload } from '../models/id-token';
  * // }
  * ```
  */
-declare const extractUserClaimsFromIdToken: (payload: IdTokenPayload) => Record<string, unknown>;
+declare const extractUserClaimsFromIdToken: (payload: IdToken) => Record<string, unknown>;
 export default extractUserClaimsFromIdToken;

package/dist/utils/flattenUserSchema.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Schema, FlattenedSchema } from '../models/scim2-schema';
+/**
+ * Flattens nested schema attributes into a flat structure for easier processing
+ *
+ * This function processes SCIM2 schemas and creates a flattened representation by:
+ * - Processing sub-attributes and creating dot-notation names (e.g., 'name.givenName')
+ * - Adding schema ID reference to each flattened attribute
+ * - Preserving all original attribute properties while adding schema context
+ * - Only including leaf-level attributes (sub-attributes) and top-level simple attributes
+ *
+ * @param schemas - Array of SCIM2 schemas containing nested attribute structures
+ * @returns Array of flattened schema attributes with dot-notation names and schema references
+ *
+ * @example
+ * ```typescript
+ * const schemas = [
+ *   {
+ *     id: 'urn:ietf:params:scim:schemas:core:2.0:User',
+ *     attributes: [
+ *       {
+ *         name: 'userName',
+ *         type: 'string',
+ *         multiValued: false
+ *       },
+ *       {
+ *         name: 'name',
+ *         type: 'complex',
+ *         multiValued: false,
+ *         subAttributes: [
+ *           { name: 'givenName', type: 'string', multiValued: false },
+ *           { name: 'familyName', type: 'string', multiValued: false }
+ *         ]
+ *       }
+ *     ]
+ *   }
+ * ];
+ *
+ * const flattened = flattenUserSchema(schemas);
+ * // Result: [
+ * //   { name: 'userName', type: 'string', multiValued: false, schemaId: 'urn:ietf:params:scim:schemas:core:2.0:User' },
+ * //   { name: 'name.givenName', type: 'string', multiValued: false, schemaId: 'urn:ietf:params:scim:schemas:core:2.0:User' },
+ * //   { name: 'name.familyName', type: 'string', multiValued: false, schemaId: 'urn:ietf:params:scim:schemas:core:2.0:User' }
+ * // ]
+ * ```
+ */
+declare const flattenUserSchema: (schemas: Schema[]) => FlattenedSchema[];
+export default flattenUserSchema;

package/dist/utils/generateFlattenedUserProfile.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { User } from '../models/user';
+/**
+ * Generates a flattened user profile from a response object and schema definitions.
+ *
+ * This function processes user data according to schema specifications, creating
+ * a flat object with dot notation keys instead of nested objects. Multi-valued
+ * properties and type-specific defaults are handled appropriately.
+ *
+ * Additionally, any fields present in the response but not defined in the schema
+ * will be included to ensure no user data is lost during flattening.
+ *
+ * @param meResponse - The response object containing user data
+ * @param processedSchemas - Array of schema objects defining field properties
+ * @param processedSchemas[].name - The field name/path for the property
+ * @param processedSchemas[].type - The data type of the field (e.g., 'STRING')
+ * @param processedSchemas[].multiValued - Whether the field can contain multiple values
+ *
+ * @returns A flattened user profile object with dot notation keys
+ *
+ * @example
+ * ```typescript
+ * const schemas = [
+ *   { name: 'name.givenName', type: 'STRING', multiValued: false },
+ *   { name: 'emails', type: 'STRING', multiValued: true }
+ * ];
+ * const response = {
+ *   name: { givenName: 'John' },
+ *   emails: 'john@example.com',
+ *   country: 'US' // This will be included even if not in schema
+ * };
+ * const profile = generateFlattenedUserProfile(response, schemas);
+ * // Result: { "name.givenName": 'John', emails: ['john@example.com'], country: 'US' }
+ * ```
+ */
+declare const generateFlattenedUserProfile: (meResponse: any, processedSchemas: any[]) => User;
+export default generateFlattenedUserProfile;

package/dist/utils/generateUserProfile.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { User } from '../models/user';
+/**
+ * Creates a profile structure from ME response based on processed schemas
+ *
+ * This function processes each schema attribute and populates the profile dynamically by:
+ * - Extracting values from the ME response using the schema attribute names
+ * - Handling multi-valued attributes by converting single values to arrays when needed
+ * - Setting appropriate default values based on schema type and multiValued properties
+ * - Using dynamic property setting to build the final profile object
+ *
+ * @param meResponse - The ME API response containing user data
+ * @param processedSchemas - The processed and flattened schemas with name, type, and multiValued properties
+ * @returns Flat profile object with dynamically populated user attributes
+ *
+ * @example
+ * ```typescript
+ * const meResponse = {
+ *   userName: 'john.doe',
+ *   emails: ['john@example.com', 'john.doe@work.com'],
+ *   name: { givenName: 'John', familyName: 'Doe' }
+ * };
+ *
+ * const schemas = [
+ *   { name: 'userName', type: 'STRING', multiValued: false },
+ *   { name: 'emails', type: 'STRING', multiValued: true },
+ *   { name: 'name.givenName', type: 'STRING', multiValued: false }
+ * ];
+ *
+ * const profile = generateUserProfile(meResponse, schemas);
+ * // Result: {
+ * //   userName: 'john.doe',
+ * //   emails: ['john@example.com', 'john.doe@work.com'],
+ * //   'name.givenName': 'John'
+ * // }
+ * ```
+ */
+declare const generateUserProfile: (meResponse: any, processedSchemas: any[]) => User;
+export default generateUserProfile;

package/dist/utils/get.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Gets the value at path of object. If the resolved value is undefined,
+ * the defaultValue is returned in its place.
+ * Similar to Lodash's get() function
+ *
+ * @param object - The object to query
+ * @param path - The path of the property to get
+ * @param defaultValue - The value returned for undefined resolved values
+ * @returns The resolved value
+ */
+declare const get: (object: any, path: string | string[], defaultValue?: any) => any;
+export default get;

package/dist/utils/getAuthorizeRequestUrlParams.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { ExtendedAuthorizeRequestUrlParams } from '../models/oauth-request';
+/**
+ * Generates a map of authorization request URL parameters for OIDC authorization requests.
+ *
+ * This utility ensures the `openid` scope is always included, handles both string and array forms of the `scope` parameter,
+ * and supports PKCE and custom parameters. Throws if a code challenge is provided without a code challenge method.
+ *
+ * @param options - The main options for the authorization request, including redirectUri, clientId, scope, responseMode, codeChallenge, codeChallengeMethod, and prompt.
+ * @param pkceOptions - PKCE options, including the PKCE key for state correlation.
+ * @param customParams - Optional custom parameters to include in the request (excluding the `state` param, which is handled separately).
+ * @returns A Map of key-value pairs representing the authorization request URL parameters.
+ *
+ * @throws {AsgardeoRuntimeError} If a code challenge is provided without a code challenge method.
+ *
+ * @example
+ * const params = getAuthorizeRequestUrlParams({
+ *   options: {
+ *     redirectUri: 'https://app/callback',
+ *     clientId: 'client123',
+ *     scope: ['openid', 'profile'],
+ *     responseMode: 'query',
+ *     codeChallenge: 'abc',
+ *     codeChallengeMethod: 'S256',
+ *     prompt: 'login'
+ *   },
+ *   pkceOptions: { key: 'pkce_code_verifier_1' },
+ *   customParams: { foo: 'bar' }
+ * });
+ * // Returns a Map with all required OIDC params, PKCE, and custom params.
+ */
+declare const getAuthorizeRequestUrlParams: (options: {
+    redirectUri: string;
+    clientId: string;
+    scopes?: string;
+    responseMode?: string;
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
+    prompt?: string;
+} & ExtendedAuthorizeRequestUrlParams, pkceOptions: {
+    key: string;
+}, customParams: Record<string, string | number | boolean>) => Map<string, string>;
+export default getAuthorizeRequestUrlParams;