@meowinc/meow-sdk 0.14.2 → 0.15.0

package/dist/account/sessions/create-one-time.d.ts

@@ -0,0 +1,13 @@
+import { AuthorizationProvider } from "../..";
+import { MeowResult } from "../../types";
+export interface Payload {
+    appId?: string;
+    permissions: string[];
+    removeOldSessions: boolean;
+    isOneTime: true;
+}
+export interface Response {
+    affectedSessions?: number;
+    accessToken: string;
+}
+export declare function request(payload: Payload, auth: AuthorizationProvider): Promise<MeowResult<Response>>;

package/dist/account/sessions/create-one-time.js

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

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

@@ -1,11 +1,13 @@
 import { AuthorizationProvider } from "../../auth-provider";
 import { type Payload as CreateSessionPayload } from "./create";
 import { type Payload as RequestTokenPayload } from "./request-token";
+import { type Payload as CreateOneTimeSessionPayload } from "./create-one-time";
 export declare class SessionsRequests {
     private readonly authProvider;
     constructor(authProvider: AuthorizationProvider);
     requestToken(payload: RequestTokenPayload): Promise<import("../../types").MeowResult<import("./request-token").Response>>;
     noVerificationRequtestToken(): Promise<import("../../types").MeowResult<import("./request-token").Response>>;
     createSession(payload: CreateSessionPayload): Promise<import("../../types").MeowResult<import("./create").Response>>;
+    createOneTimeSession(payload: CreateOneTimeSessionPayload): Promise<import("../../types").MeowResult<import("./create-one-time").Response>>;
     getCurrentSessions(): Promise<import("../../types").MeowResult<import("./get-current").Response>>;
 }

package/dist/account/sessions/index.js

@@ -1,6 +1,7 @@
 import { request as createSession } from "./create";
 import { request as requestToken } from "./request-token";
 import { request as getCurrentSessions } from "./get-current";
+import { request as createOneTimeSession } from "./create-one-time";
 export class SessionsRequests {
     authProvider;
     constructor(authProvider) {
@@ -17,6 +18,9 @@ export class SessionsRequests {
     async createSession(payload) {
         return await createSession(payload, this.authProvider);
     }
+    async createOneTimeSession(payload) {
+        return await createOneTimeSession(payload, this.authProvider);
+    }
     async getCurrentSessions() {
         return getCurrentSessions(this.authProvider);
     }

package/dist/http-client.d.ts

@@ -2,13 +2,16 @@ import type { AuthorizationProvider } from "./auth-provider";
 import { HttpError, type AppError } from "./error";
 import { Result } from "@meowinc/result";
 export declare class HttpClient {
+    private timeout?;
     private url;
     private headers;
     private method;
     private body;
     private params;
     private authorization?;
+    static setGlobalTimeout(timeout?: number): void;
     withUrl(url: string): this;
+    withTimeout(timeout: number): this;
     withParam(key: string, value?: string | number | boolean): this;
     withMethodGet(): this;
     withMethodPost(): this;

package/dist/http-client.js

@@ -2,17 +2,27 @@ import { HttpError } from "./error";
 import { AccessToken } from "./token";
 import { ACCOUNT_API } from "./account";
 import { Result } from "@meowinc/result";
+import { MeowUtils } from "./utils";
+let MEOW_GLOBAL_TIMEOUT = undefined;
 export class HttpClient {
+    timeout;
     url = "";
     headers = {};
     method = "GET";
     body = null;
     params = {};
     authorization;
+    static setGlobalTimeout(timeout) {
+        MEOW_GLOBAL_TIMEOUT = timeout;
+    }
     withUrl(url) {
         this.url = url;
         return this;
     }
+    withTimeout(timeout) {
+        this.timeout = timeout;
+        return this;
+    }
     withParam(key, value) {
         if (value === undefined) {
             return this;
@@ -82,11 +92,25 @@ export class HttpClient {
                     this.setHeader("Authorization", `Bearer ${accessToken}`);
                 }
             }
-            const response = await fetch(this.url, {
+            const responsePromise = fetch(this.url, {
                 method: this.method,
                 headers: this.headers,
                 body: this.body,
             });
+            let timeout;
+            if (this.timeout !== undefined) {
+                timeout = this.timeout;
+            }
+            else if (MEOW_GLOBAL_TIMEOUT !== undefined) {
+                timeout = MEOW_GLOBAL_TIMEOUT;
+            }
+            let response;
+            if (timeout !== undefined) {
+                response = await MeowUtils.timeout(responsePromise, timeout);
+            }
+            else {
+                response = await responsePromise;
+            }
             if (response.ok) {
                 const contentType = response.headers.get("content-type");
                 if (contentType && contentType.includes("application/json")) {

package/dist/utils/index.d.ts

@@ -3,4 +3,5 @@ export { BrowserUtils, CookieStorage } from "./browser";
 export declare class MeowUtils {
     static createAuthorizationSession(login: string, password: string): AuthorizationSession;
     static checkRequiredPermissions(expected: string[], permissions: string[]): boolean;
+    static timeout<T>(promise: Promise<T>, ms: number): Promise<T>;
 }

package/dist/utils/index.js

@@ -7,4 +7,21 @@ export class MeowUtils {
     static checkRequiredPermissions(expected, permissions) {
         return permissions.every((permission) => expected.includes(permission));
     }
+    static timeout(promise, ms) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Timeout after ${ms}ms`));
+            }, ms);
+            promise
+                .then((result) => {
+                resolve(result);
+            })
+                .catch((error) => {
+                reject(error);
+            })
+                .finally(() => {
+                clearTimeout(timer);
+            });
+        });
+    }
 }

package/package.json

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