@vendasta/iam 2.0.1 → 2.3.0

package/lib/_internal/objects/subjects.d.ts

@@ -1,26 +1,7 @@
 import * as i from '../interfaces';
+import { StructAttribute } from './attributes';
 import * as e from '../enums';
 export declare function enumStringToValue<E>(enumRef: any, value: string): E;
-export declare class Attribute implements i.AttributeInterface {
-    intAttribute: number;
-    doubleAttribute: number;
-    stringAttribute: string;
-    boolAttribute: boolean;
-    structAttribute: StructAttribute;
-    listAttribute: ListAttribute;
-    timestampAttribute: Date;
-    geopointAttribute: GeoPointAttribute;
-    static fromProto(proto: any): Attribute;
-    constructor(kwargs?: i.AttributeInterface);
-    toApiJson(): object;
-}
-export declare class StructAttributeAttributesEntry implements i.StructAttributeAttributesEntryInterface {
-    key: string;
-    value: Attribute;
-    static fromProto(proto: any): StructAttributeAttributesEntry;
-    constructor(kwargs?: i.StructAttributeAttributesEntryInterface);
-    toApiJson(): object;
-}
 export declare class Context implements i.ContextInterface {
     namespaced: NamespacedContext;
     typed: TypedContext;
@@ -28,19 +9,6 @@ export declare class Context implements i.ContextInterface {
     constructor(kwargs?: i.ContextInterface);
     toApiJson(): object;
 }
-export declare class GeoPointAttribute implements i.GeoPointAttributeInterface {
-    latitude: number;
-    longitude: number;
-    static fromProto(proto: any): GeoPointAttribute;
-    constructor(kwargs?: i.GeoPointAttributeInterface);
-    toApiJson(): object;
-}
-export declare class ListAttribute implements i.ListAttributeInterface {
-    attributes: Attribute[];
-    static fromProto(proto: any): ListAttribute;
-    constructor(kwargs?: i.ListAttributeInterface);
-    toApiJson(): object;
-}
 export declare class MultiValueAttribute implements i.MultiValueAttributeInterface {
     key: string;
     values: string[];
@@ -96,14 +64,6 @@ export declare class SingleValueAttribute implements i.SingleValueAttributeInter
     constructor(kwargs?: i.SingleValueAttributeInterface);
     toApiJson(): object;
 }
-export declare class StructAttribute implements i.StructAttributeInterface {
-    attributes: {
-        [key: string]: Attribute;
-    };
-    static fromProto(proto: any): StructAttribute;
-    constructor(kwargs?: i.StructAttributeInterface);
-    toApiJson(): object;
-}
 export declare class Subject implements i.SubjectInterface {
     subjectId: string;
     email: string;

package/lib/_internal/user-iam.api.service.d.ts

@@ -3,9 +3,11 @@ import { GetImpersonationTokenRequestInterface, GetSessionTokenRequestInterface,
 import { HttpClient, HttpResponse } from '@angular/common/http';
 import { HostService } from '../_generated/host.service';
 import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
 export declare class UserIAMApiService {
     private http;
     private hostService;
+    private _host;
     constructor(http: HttpClient, hostService: HostService);
     private apiOptions;
     getSubjectBySession(r: GetSubjectBySessionRequest | GetSubjectBySessionRequestInterface): Observable<GetSubjectResponse>;
@@ -14,4 +16,6 @@ export declare class UserIAMApiService {
     getSessionToken(r: GetSessionTokenRequest | GetSessionTokenRequestInterface): Observable<GetTokenResponse>;
     resetPasswordWithToken(r: ResetPasswordWithTokenRequest | ResetPasswordWithTokenRequestInterface): Observable<HttpResponse<null>>;
     getImpersonationToken(r: GetImpersonationTokenRequest | GetImpersonationTokenRequestInterface): Observable<GetImpersonationTokenResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserIAMApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserIAMApiService>;
 }

package/lib/http/iam.http.api.service.d.ts

@@ -3,12 +3,16 @@ import { Observable } from 'rxjs';
 import { HostService } from '../_generated/host.service';
 import { LoginRequestInterface, SSOLoginRequestInterface } from './http.interface';
 import { LoginRequest, LoginResponse, LogoutResponse, SSOLoginRequest } from './http';
+import * as i0 from "@angular/core";
 export declare class IamHttpApiService {
     private http;
     private hostService;
+    private _host;
     constructor(http: HttpClient, hostService: HostService);
     private apiOptions;
     login(r: LoginRequest | LoginRequestInterface): Observable<LoginResponse>;
     logout(): Observable<LogoutResponse>;
     ssoLogin(r: SSOLoginRequest | SSOLoginRequestInterface): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IamHttpApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IamHttpApiService>;
 }

package/lib/iam.service.d.ts

@@ -8,6 +8,7 @@ import { PersonaType } from './personas/persona-type.enum';
 import { User } from './_internal/objects/users';
 import { IAMApiService } from './_internal/iam.api.service';
 import { UserIdentifierInterface, UserSortOptionsInterface } from './_internal/interfaces';
+import * as i0 from "@angular/core";
 export declare class IAMService {
     private api;
     private httpApi;
@@ -25,4 +26,6 @@ export declare class IAMService {
     getMultiUsers(userIdentifiers: UserIdentifierInterface[]): Observable<User[]>;
     listSecurityLogs(userId: string, cursor?: string, pageSize?: number, actionId?: string): Observable<ListSecurityLogsResponse>;
     listUsers(namespace: string, email?: string, cursor?: string, pageSize?: number, subjectTypes?: string[], searchTerms?: string[], sortOptions?: UserSortOptionsInterface[]): Observable<ListUsersResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IAMService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IAMService>;
 }

package/lib/personas/base-personas.d.ts

@@ -1,4 +1,4 @@
-import { AttributeInterface, StructAttributeInterface } from '../_internal/interfaces/subjects.interface';
+import { AttributeInterface, StructAttributeInterface } from '../_internal/interfaces/attributes.interface';
 import { Persona } from '../_internal/objects/subjects';
 import { PersonaType } from './persona-type.enum';
 export declare class BasePersona {

package/lib/personas/partner.d.ts

@@ -23,4 +23,5 @@ export declare class PartnerPersona extends TypedPersona {
     canAccessAutomations: boolean;
     canAccessMarketplace: boolean;
     canEnableApps: boolean;
+    canAccessRetailBilling: boolean;
 }

package/package.json

@@ -1,24 +1,37 @@
 {
   "name": "@vendasta/iam",
-  "version": "2.0.1",
+  "version": "2.3.0",
   "peerDependencies": {
-    "@angular/core": "^10.0.0",
-    "@angular/common": "^10.0.0",
-    "@vendasta/core": "^46.0.1",
-    "rxjs": "^6.0.0"
+    "@angular/common": "^13.0.0",
+    "@angular/core": "^13.0.0",
+    "@vendasta/core": "^55.0.2",
+    "rxjs": "^6.6.6"
   },
   "author": "Vendasta R&D",
   "description": "SDK to interact with the iam service",
   "typings": "vendasta-iam.d.ts",
-  "dependencies": {
-    "tslib": "^2.0.0"
-  },
   "license": "ISC",
-  "main": "bundles/vendasta-iam.umd.js",
-  "module": "fesm2015/vendasta-iam.js",
-  "es2015": "fesm2015/vendasta-iam.js",
-  "esm2015": "esm2015/vendasta-iam.js",
-  "fesm2015": "fesm2015/vendasta-iam.js",
-  "metadata": "vendasta-iam.metadata.json",
-  "sideEffects": false
-}
+  "main": "index.js",
+  "module": "fesm2015/vendasta-iam.mjs",
+  "es2020": "fesm2020/vendasta-iam.mjs",
+  "esm2020": "esm2020/vendasta-iam.mjs",
+  "fesm2020": "fesm2020/vendasta-iam.mjs",
+  "fesm2015": "fesm2015/vendasta-iam.mjs",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./vendasta-iam.d.ts",
+      "esm2020": "./esm2020/vendasta-iam.mjs",
+      "es2020": "./fesm2020/vendasta-iam.mjs",
+      "es2015": "./fesm2015/vendasta-iam.mjs",
+      "node": "./fesm2015/vendasta-iam.mjs",
+      "default": "./fesm2020/vendasta-iam.mjs"
+    }
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}

package/src/README.md

@@ -0,0 +1,113 @@
+# IAM SDK
+
+## Login
+`login(email: string, password: string, personaType?: PersonaType, partnerId?: string): Observable<string>`
+
+Login accepts an email and password to use to attempt to auth a user. If `personaType` isn't specified, IAM will attempt to
+auth the email and password combo against any of the associated personas. If `personaType` and optionally `partnerId` are
+specified, IAM will auth against that persona specifically.
+
+## Logout
+`logout(): Observable<boolean>`
+
+Logout will clear the user's cookies on IAM's side. Returns true if successful.
+
+## SSO Login
+`ssoLogin(nextUrl: string, personaType: PersonaType, partnerId?: string): void`
+
+SSOLogin will redirect the user's browser to IAM's SSOLogin page. IAM handles all of the oauth google has in place for
+getting a session using your gmail account (and the whitelabeling of the domain requesting access). Once IAM is done
+handling those requests, IAM will then attempt to find the persona specified in this endpoint (the `personaType` and
+`partnerId` combination). If IAM fails to find a persona, it will redirect to the `nextUrl` with `error` and `status`
+query params indicating why it failed. If IAM is successful in finding the appropriate persona for the request, it
+will redirect to the `nextUrl` with a `session_id` query param. You will then have to take this `session_id` and set up
+the user's session with it, in the same fashion you would have set up the session from the response of the `Login`
+endpoint.
+
+## Get Subject By Session
+`getSubjectBySession(sessionId: string, personaType: PersonaType, partnerId?: string): Observable<BasePersona>`
+
+Specify the `personaType` and optionally the `partnerId` for the persona you'd like to retrieve using the `sessionId`.
+This endpoint returns a `BasePersona` which is the base class that all Personas inherit. To gain access to the attributes
+of a specific persona, you will need to cast the persona as the requested type.
+
+```typescript
+import {BasePersona, PartnerPersona, PersonaType} from '@vendasta/core/iam'
+
+this.iamClient.getSubjectBySession('...sessionId...', PersonaType.partner)
+  .map((persona: BasePersona) => persona as PartnerPersona)
+  .subscribe(...)
+```
+
+## Get Logged In Subject
+`getLoggedInSubject(personaType: PersonaType, partnerId?: string): Observable<BasePersona>`
+
+Works identically to getSubjectBySession except it grabs the current session being served by the SessionService.
+
+## List Personas
+`listPersonas(sessionId: string, personaType?: PersonaType): Observable<BasePersona[]>`
+
+Given a `sessionId`, listPersonas will find and return all available personas for the session. Optionally specify a
+`personaType` to filter the results by only that type of persona. List personas will return a list of all the personas
+it found. This endpoint returns `BasePersona` and thus they will need to be casted to their appropriate PersonaTypes to
+gain access to the attributes.
+
+```typescript
+import {BasePersona, PartnerPersona, PersonaType, SMBPersona} from '@vendasta/core/iam'
+
+this.iamClient.listPersonas('...sessionId...')
+  .subscribe((personas: BasePersona[]) => {
+    for (const persona of personas) {
+      switch(persona.type) {
+        case PartnerType.partner:
+          const p: PartnerPersona = (persona as PartnerPersona);
+          ...
+          break;
+        case PartnerType.smb:
+          const p: SMBPersona = (persona as SMBPersona);
+          ...
+          break;
+        ...
+      }
+    }
+  });
+```
+
+## List Logged In Personas
+`listLoggedInPersonas(personaType?: PersonaType): Observable<BasePersona[]>`
+
+Works identically to listPersonas except it grabs the current session being served by the SessionService.
+
+## Get Token
+`getToken(): Observable<string>`
+
+Get token will refresh the 30 minute temporary session a user may have, returning the new `sessionId`.
+
+## Get Multi Users
+
+`getMultiUsers(userIdentifiers: UserIdentifierInterface[]): Observable<User[]>`
+
+This function takes in an array of user identifiers and converts them (via API) into their respective Users that
+are stored in IAM. UserIdentifiers are an object containing one of the following:
+
+userId - the user id of a user. This directly identifies the user in our system.
+token - a token for a user signed by the platform. These tokens include: the session token from IAM (i.e. the `session` part of the `namespaced_session` UserIdentifier), as well as access token or identity tokens from SSO.
+
+Deprecated identifiers:
+namespacedEmail - an email address scoped to a namespace. A namespace is the id of a partner. Prefer to use user id instead, to avoid handling emails and for a more stable user identifier
+namespacedSession - a session string scoped to a namespace. Use token instead, as sesson is valid token, and namespace is ignored.
+
+## List security logs
+
+`listSecurityLogs(userId: string, cursor?: string, pageSize?: number, actionId = ''): Observable<ListSecurityLogsResponse>`
+
+This function returns security logs for a userId passed in. This is a paged function, but the handling of paged
+information is left to the implementor (for now). Use the cursor to call this function again and retrieve a new
+observable of the response to your call.
+
+## List Users
+
+`listUsers(namespace: string, email?: string, cursor?: string, pageSize?: number): Observable<ListUsersResponse>`
+
+ListUsers returns users for a namespace passed in. This is a paged function, but the handling of paged information
+is left to the implementor (for now). An empty namespace will return users that exist outside of a namespace.

package/vendasta-iam.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@vendasta/iam" />
 export * from './public_api';