@meowinc/meow-sdk 0.9.2 → 0.10.0

package/dist/account/user/get-user-by-login.d.ts

@@ -5,6 +5,7 @@ export interface Response {
     name: string;
     role: UserRole;
     status: string;
+    avatar?: string;
     registrationDate: Date;
 }
 export declare function request(login: string): Promise<import("@meowinc/result").Result<Response, string>>;

package/dist/auth-provider.d.ts

@@ -8,8 +8,8 @@ export interface AuthorizationProvider {
     updateTokens(accessToken?: string, refreshToken?: string): void;
     onUpdate(callback: AuthorizationUpdateHandler): void;
 }
-type StorageType = "localStorage" | "sessionStorage";
-export declare class BrowserAuthhorizationProvider implements AuthorizationProvider {
+type StorageType = "localStorage" | "sessionStorage" | "cookie";
+export declare class BrowserAuthorizationProvider implements AuthorizationProvider {
     private readonly storageType;
     private readonly accessTokenKey;
     private readonly refreshTokenKey;

package/dist/auth-provider.js

@@ -1,4 +1,5 @@
-export class BrowserAuthhorizationProvider {
+import { CookieStorage } from "./utils/browser";
+export class BrowserAuthorizationProvider {
     storageType;
     accessTokenKey;
     refreshTokenKey;
@@ -44,6 +45,8 @@ export class BrowserAuthhorizationProvider {
                 return localStorage;
             case "sessionStorage":
                 return sessionStorage;
+            case "cookie":
+                return new CookieStorage();
         }
     }
 }

package/dist/utils/auth.d.ts

@@ -0,0 +1,28 @@
+import { LogInResponse } from "../account/auth/log-in";
+import { MeowResult, UndefinedString } from "../types";
+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;
+    }>>;
+}

package/dist/utils/auth.js

@@ -0,0 +1,85 @@
+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);
+    }
+}

package/dist/utils/browser.d.ts

@@ -0,0 +1,15 @@
+import { UndefinedString } from "../types";
+export declare class BrowserUtils {
+    static getCookie(name: string): UndefinedString;
+    static setCookie(name: string, value: string, days: number): void;
+}
+export declare class CookieStorage implements Storage {
+    [name: string]: any;
+    length: number;
+    constructor();
+    clear(): void;
+    getItem(key: string): string | null;
+    key(_: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string, days?: number): void;
+}

package/dist/utils/browser.js

@@ -0,0 +1,50 @@
+export class BrowserUtils {
+    static getCookie(name) {
+        if (!window.document) {
+            throw new Error("Window not exits, you execute code not in browser?");
+        }
+        const nameEQ = name + "=";
+        const ca = document.cookie.split(";");
+        for (let i = 0; i < ca.length; i++) {
+            let c = ca[i];
+            while (c.charAt(0) === " ")
+                c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) === 0) {
+                return c.substring(nameEQ.length, c.length);
+            }
+        }
+        return undefined;
+    }
+    static setCookie(name, value, days) {
+        if (!window.document) {
+            throw new Error("Window not exits, you execute code not in browser?");
+        }
+        let expires = "";
+        const date = new Date();
+        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+        expires = date.toUTCString();
+        document.cookie = `${name}=${value}; expires=${expires}; path=/; secure`;
+    }
+}
+export class CookieStorage {
+    length;
+    constructor() {
+        console.warn("used untested unstable feature `CookieStorage`");
+        this.length = 0;
+    }
+    clear() {
+        throw new Error("Method not implemented.");
+    }
+    getItem(key) {
+        return BrowserUtils.getCookie(key) ?? null;
+    }
+    key(_) {
+        throw new Error("Method not implemented.");
+    }
+    removeItem(key) {
+        this.setItem(key, "", -1);
+    }
+    setItem(key, value, days = 30) {
+        BrowserUtils.setCookie(key, value, days);
+    }
+}

package/dist/utils/index.d.ts

@@ -1,31 +1,5 @@
-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;
-    }>>;
-}
+import { AuthorizationSession } from "./auth";
+export { BrowserUtils, CookieStorage } from "./browser";
 export declare class MeowUtils {
     static createAuthorizationSession(login: string, password: string): AuthorizationSession;
     static checkRequiredPermissions(expected: string[], permissions: string[]): boolean;

package/dist/utils/index.js

@@ -1,88 +1,5 @@
-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);
-    }
-}
+import { AuthorizationSession } from "./auth";
+export { BrowserUtils, CookieStorage } from "./browser";
 export class MeowUtils {
     static createAuthorizationSession(login, password) {
         return new AuthorizationSession(login, password);

package/package.json

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