@meowinc/meow-sdk 0.3.0 → 0.4.0

package/dist/account/auth/2FA/get-my-two-factor.d.ts

@@ -0,0 +1,10 @@
+import { AuthorizationProvider } from "../../..";
+import { MeowResult } from "../../../types";
+export type Response = {
+    id: number;
+    createdAt: string;
+} & {
+    type: "email";
+    mailbox: string;
+};
+export declare function request(auth: AuthorizationProvider): Promise<MeowResult<Response>>;

package/dist/account/auth/2FA/get-my-two-factor.js

@@ -0,0 +1,11 @@
+import { ACCOUNT_API } from "../..";
+import { ErrorToMessage } from "../../../error";
+import { HttpClient } from "../../../http-client";
+export async function request(auth) {
+    return await new HttpClient()
+        .withMethodGet()
+        .withUrl(`${ACCOUNT_API}/v1/auth/2fa/my`)
+        .withAuthorization(auth)
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/account/auth/2FA/get-two-factor-by-login-password.d.ts

@@ -0,0 +1,8 @@
+import { GetTwoFactorResponse } from ".";
+import { MeowResult } from "../../../types";
+export interface Payload {
+    login: string;
+    password: string;
+}
+export type Response = GetTwoFactorResponse;
+export declare function request(payload: Payload): Promise<MeowResult<Response>>;

package/dist/account/auth/2FA/get-two-factor-by-login-password.js

@@ -0,0 +1,11 @@
+import { ACCOUNT_API } from "../..";
+import { ErrorToMessage } from "../../../error";
+import { HttpClient } from "../../../http-client";
+export async function request(payload) {
+    return await new HttpClient()
+        .withMethodPost()
+        .withUrl(`${ACCOUNT_API}/v1/auth/2fa/my/login-password`)
+        .withJsonBody(payload)
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/account/auth/2FA/index.d.ts

@@ -0,0 +1,7 @@
+export type GetTwoFactorResponse = {
+    id: number;
+    createdAt: string;
+} & {
+    type: "email";
+    mailbox: string;
+};

package/dist/account/auth/2FA/index.js

@@ -0,0 +1 @@
+export {};

package/dist/account/auth/email/add-email.d.ts

@@ -0,0 +1,6 @@
+import { AuthorizationProvider } from "../../..";
+import { MeowResult } from "../../../types";
+export interface Response {
+    sessionId: string;
+}
+export declare function request(mailbox: string, authorizationProvider: AuthorizationProvider): Promise<MeowResult<Response>>;

package/dist/account/auth/email/add-email.js

@@ -0,0 +1,14 @@
+import { ACCOUNT_API } from "../..";
+import { ErrorToMessage } from "../../../error";
+import { HttpClient } from "../../../http-client";
+export async function request(mailbox, authorizationProvider) {
+    return await new HttpClient()
+        .withUrl(`${ACCOUNT_API}/v1/auth/2fa/email`)
+        .withAuthorization(authorizationProvider)
+        .withMethodPost()
+        .withJsonBody({
+        mailbox,
+    })
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/account/auth/email/submit-add-email.d.ts

@@ -0,0 +1,3 @@
+import { AuthorizationProvider } from "../../..";
+import { MeowResult } from "../../../types";
+export declare function request(sessionId: string, code: string, authorizationProvider: AuthorizationProvider): Promise<MeowResult<void>>;

package/dist/account/auth/email/submit-add-email.js

@@ -0,0 +1,15 @@
+import { ACCOUNT_API } from "../..";
+import { ErrorToMessage } from "../../../error";
+import { HttpClient } from "../../../http-client";
+export async function request(sessionId, code, authorizationProvider) {
+    return await new HttpClient()
+        .withUrl(`${ACCOUNT_API}/v1/auth/2fa/email/submit`)
+        .withMethodPost()
+        .withAuthorization(authorizationProvider)
+        .withJsonBody({
+        sessionId,
+        code,
+    })
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/account/auth/index.d.ts

@@ -3,9 +3,12 @@ import { AuthorizationProvider } from "../../auth-provider";
 export declare class AuthRequests {
     private readonly authProvider;
     constructor(authProvider: AuthorizationProvider);
-    baseLogIn(login: string, password: string): Promise<import("../../types").MeowResult<import("./log-in").Response>>;
-    twoFactorLogIn(code: string, requestId: string): Promise<import("../../types").MeowResult<import("./log-in").Response>>;
+    baseLogIn(login: string, password: string): Promise<import("../../types").MeowResult<import("./log-in").LogInResponse>>;
     signIn(login: string, password: string, verificationType: VerificationType): Promise<import("../../types").MeowResult<void>>;
-    addTwoFactorEmail(email: string): Promise<import("../../types").MeowResult<import("./add-email").Response>>;
+    addTwoFactorEmail(email: string): Promise<import("../../types").MeowResult<import("./email/add-email").Response>>;
     submitTwoFactorEmail(sessionId: string, code: string): Promise<import("../../types").MeowResult<void>>;
+    setTwoFactorSession(sessionId: string, twoFactorId: number): Promise<import("../../types").MeowResult<void>>;
+    submitTwoFactorSession(code: string, sessionId: string): Promise<import("../../types").MeowResult<import("./log-in").LogInResponse>>;
+    getMyTwoFactor(): Promise<import("../../types").MeowResult<import("./2FA/get-my-two-factor").Response>>;
+    getTwoFactorByLoginPassword(login: string, password: string): Promise<import("../../types").MeowResult<import("./2FA").GetTwoFactorResponse>>;
 }

package/dist/account/auth/index.js

@@ -1,7 +1,11 @@
 import { request as signIn } from "./sign-in";
-import { request as logIn } from "./log-in";
-import { request as addEmail } from "./add-email";
-import { request as submitAddEmail } from "./submit-add-email";
+import { request as logIn } from "./log-in/log-in";
+import { request as addEmail } from "./email/add-email";
+import { request as submitAddEmail } from "./email/submit-add-email";
+import { request as setTwoFactorSession } from "./log-in/set-two-factor-session";
+import { request as submitTwoFactorSession } from "./log-in/submit-two-factor-session";
+import { request as getMyTwoFactor } from "./2FA/get-my-two-factor";
+import { request as getTwoFactorByLoginPassword } from "./2FA/get-two-factor-by-login-password";
 export class AuthRequests {
     authProvider;
     constructor(authProvider) {
@@ -11,14 +15,6 @@ export class AuthRequests {
         return await logIn({
             login,
             password,
-            type: "base",
-        });
-    }
-    async twoFactorLogIn(code, requestId) {
-        return await logIn({
-            code,
-            requestId,
-            type: "twoFactor",
         });
     }
     async signIn(login, password, verificationType) {
@@ -34,4 +30,16 @@ export class AuthRequests {
     async submitTwoFactorEmail(sessionId, code) {
         return await submitAddEmail(sessionId, code, this.authProvider);
     }
+    async setTwoFactorSession(sessionId, twoFactorId) {
+        return await setTwoFactorSession({ sessionId, twoFactorId });
+    }
+    async submitTwoFactorSession(code, sessionId) {
+        return await submitTwoFactorSession({ code, sessionId });
+    }
+    async getMyTwoFactor() {
+        return await getMyTwoFactor(this.authProvider);
+    }
+    async getTwoFactorByLoginPassword(login, password) {
+        return await getTwoFactorByLoginPassword({ login, password });
+    }
 }

package/dist/account/auth/log-in/index.d.ts

@@ -0,0 +1,8 @@
+export type LogInResponse = {
+    type: "success";
+    accessToken: string;
+    refreshToken: string;
+} | {
+    type: "requireTwoFactor";
+    sessionId: string;
+};

package/dist/account/auth/log-in/index.js

@@ -0,0 +1 @@
+export {};

package/dist/account/auth/log-in/log-in.d.ts

@@ -0,0 +1,8 @@
+import { LogInResponse } from ".";
+import { MeowResult } from "../../../types";
+export interface Payload {
+    login: string;
+    password: string;
+}
+export type Response = LogInResponse;
+export declare function request(payload: Payload): Promise<MeowResult<Response>>;

package/dist/account/auth/log-in/log-in.js

@@ -0,0 +1,11 @@
+import { ACCOUNT_API } from "../..";
+import { ErrorToMessage } from "../../../error";
+import { HttpClient } from "../../../http-client";
+export async function request(payload) {
+    return await new HttpClient()
+        .withMethodPost()
+        .withUrl(`${ACCOUNT_API}/v1/auth/log-in`)
+        .withJsonBody(payload)
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/account/auth/log-in/set-two-factor-session.d.ts

@@ -0,0 +1,6 @@
+import { MeowResult } from "../../../types";
+export interface Payload {
+    sessionId: string;
+    twoFactorId: number;
+}
+export declare function request(payload: Payload): Promise<MeowResult<void>>;

package/dist/account/auth/log-in/set-two-factor-session.js

@@ -0,0 +1,11 @@
+import { ACCOUNT_API } from "../..";
+import { ErrorToMessage } from "../../../error";
+import { HttpClient } from "../../../http-client";
+export async function request(payload) {
+    return await new HttpClient()
+        .withMethodPost()
+        .withUrl(`${ACCOUNT_API}/v1/auth/2fa/session/set-up`)
+        .withJsonBody(payload)
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/account/auth/log-in/submit-two-factor-session.d.ts

@@ -0,0 +1,8 @@
+import { LogInResponse } from ".";
+import { MeowResult } from "../../../types";
+export interface Payload {
+    code: string;
+    sessionId: string;
+}
+export type Response = LogInResponse;
+export declare function request(payload: Payload): Promise<MeowResult<Response>>;

package/dist/account/auth/log-in/submit-two-factor-session.js

@@ -0,0 +1,11 @@
+import { ACCOUNT_API } from "../..";
+import { ErrorToMessage } from "../../../error";
+import { HttpClient } from "../../../http-client";
+export async function request(payload) {
+    return await new HttpClient()
+        .withMethodPost()
+        .withUrl(`${ACCOUNT_API}/v1/auth/2fa/session/submit`)
+        .withJsonBody(payload)
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/auth-provider.d.ts

@@ -35,4 +35,12 @@ export declare class InPlaceAuthorizationProvider implements AuthorizationProvid
     updateTokens(accessToken?: string, refreshToken?: string): void;
     onUpdate(callback: AuthorizationUpdateHandler): void;
 }
+export declare class EmptyAuthorizationProvider implements AuthorizationProvider {
+    getAccessToken(): UndefinedString;
+    setAccessToken(): void;
+    getRefreshToken(): UndefinedString;
+    setRefreshToken(): void;
+    updateTokens(): void;
+    onUpdate(): void;
+}
 export {};

package/dist/auth-provider.js

@@ -83,3 +83,15 @@ export class InPlaceAuthorizationProvider {
         this.updateCallbacks.push(callback);
     }
 }
+export class EmptyAuthorizationProvider {
+    getAccessToken() {
+        return undefined;
+    }
+    setAccessToken() { }
+    getRefreshToken() {
+        return undefined;
+    }
+    setRefreshToken() { }
+    updateTokens() { }
+    onUpdate() { }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,32 @@
+import { MeowResult, UndefinedString } from "../types";
+import { Response as LogInResponse } from "./../account/auth/log-in/log-in";
+export declare class AuthorizationSession {
+    private login;
+    private password;
+    constructor(login: string, password: string);
+    startAuth(): Promise<BaseAuthorizationResult>;
+}
+export declare class BaseAuthorizationResult {
+    private content?;
+    private error?;
+    constructor(result: MeowResult<LogInResponse>);
+    hasError(): boolean;
+    getError(): UndefinedString;
+    isRequireTwoFactor(): boolean;
+    startTwoFactor(twoFactorId: number): Promise<TwoFactorAuthorizationResult>;
+    private _startTwoFactor;
+}
+export declare class TwoFactorAuthorizationResult {
+    private sessionId?;
+    private error?;
+    constructor(result: MeowResult<string>);
+    hasError(): boolean;
+    passCode(code: string): Promise<MeowResult<{
+        accessToken: string;
+        refreshToken: string;
+    }>>;
+}
+export declare class MeowUtils {
+    static createAuthorizationSession(login: string, password: string): AuthorizationSession;
+    static checkRequiredPermissions(expected: string[], permissions: string[]): boolean;
+}

package/dist/utils/index.js

@@ -0,0 +1,93 @@
+import { MeowSdkClient } from "..";
+import { EmptyAuthorizationProvider } from "../auth-provider";
+import { MeowResult } from "../types";
+export class AuthorizationSession {
+    login;
+    password;
+    constructor(login, password) {
+        this.login = login;
+        this.password = password;
+    }
+    async startAuth() {
+        const client = MeowSdkClient.fromAuthorizationProvider(new EmptyAuthorizationProvider());
+        const result = await client.account.auth.baseLogIn(this.login, this.password);
+        return new BaseAuthorizationResult(result);
+    }
+}
+export class BaseAuthorizationResult {
+    content;
+    error;
+    constructor(result) {
+        if (result.hasError()) {
+            this.error = result.getError();
+        }
+        else {
+            this.content = result.unwrap();
+        }
+    }
+    hasError() {
+        return this.error !== undefined;
+    }
+    getError() {
+        return this.error;
+    }
+    isRequireTwoFactor() {
+        return this.content ? this.content.type === "requireTwoFactor" : false;
+    }
+    async startTwoFactor(twoFactorId) {
+        return new TwoFactorAuthorizationResult(await this._startTwoFactor(twoFactorId));
+    }
+    async _startTwoFactor(twoFactorId) {
+        if (!this.content) {
+            return MeowResult.withError("Content not provided. Handle error!");
+        }
+        if (this.content.type !== "requireTwoFactor") {
+            return MeowResult.withError("Two factor auth not required");
+        }
+        const client = MeowSdkClient.fromAuthorizationProvider(new EmptyAuthorizationProvider());
+        const result = await client.account.auth.setTwoFactorSession(this.content.sessionId, twoFactorId);
+        if (result.hasError()) {
+            return MeowResult.withError(result.getError());
+        }
+        return MeowResult.withOk(this.content.sessionId);
+    }
+}
+export class TwoFactorAuthorizationResult {
+    sessionId;
+    error;
+    constructor(result) {
+        if (result.hasError()) {
+            this.error = result.getError();
+        }
+        else {
+            this.sessionId = result.unwrap();
+        }
+    }
+    hasError() {
+        return this.error !== undefined;
+    }
+    async passCode(code) {
+        if (!this.sessionId) {
+            return MeowResult.withError("Session Id not provided. Handle error!");
+        }
+        const client = MeowSdkClient.fromAuthorizationProvider(new EmptyAuthorizationProvider());
+        const result = await client.account.auth.submitTwoFactorSession(code, this.sessionId);
+        if (result.hasError()) {
+            return MeowResult.withError(result.getError());
+        }
+        const content = result.unwrap();
+        // imposible
+        if (content.type === "requireTwoFactor") {
+            return MeowResult.withError("Returned 'requireTwoFactor' response");
+        }
+        return MeowResult.withOk(content);
+    }
+}
+export class MeowUtils {
+    static createAuthorizationSession(login, password) {
+        return new AuthorizationSession(login, password);
+    }
+    static checkRequiredPermissions(expected, permissions) {
+        return permissions.every((permission) => expected.includes(permission));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meowinc/meow-sdk",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "Meow SDK",
     "keywords": [
         "sdk"