@meowinc/meow-sdk 0.0.7 → 0.0.9

package/dist/http-client.d.ts

@@ -9,7 +9,7 @@ export declare class HttpClient {
     private params;
     private authorization?;
     withUrl(url: string): this;
-    withParam(key: string, value?: string): this;
+    withParam(key: string, value?: string | number | boolean): this;
     withMethodGet(): this;
     withMethodPost(): this;
     withMethodPut(): this;

package/dist/http-client.js

@@ -14,10 +14,10 @@ export class HttpClient {
         return this;
     }
     withParam(key, value) {
-        if (!value) {
+        if (value === undefined) {
             return this;
         }
-        this.params[key] = value;
+        this.params[key] = value.toString();
         return this;
     }
     withMethodGet() {
@@ -54,7 +54,7 @@ export class HttpClient {
             if (Object.keys(this.params).length > 0) {
                 let params = "?";
                 for (const [key, value] of Object.entries(this.params)) {
-                    params += `${key}=${value}&`;
+                    params += `${key}=${encodeURIComponent(value)}&`;
                 }
                 this.url += params;
             }
@@ -87,10 +87,10 @@ export class HttpClient {
                     const tokens = (await updateAuth.json());
                     this.authorization.setRefreshToken(tokens.refreshToken);
                     this.authorization.setAccessToken(tokens.accessToken);
-                    this.setHeader("Authorization", tokens.accessToken);
+                    this.setHeader("Authorization", `Bearer ${tokens.accessToken}`);
                 }
                 else {
-                    this.setHeader("Authorization", accessToken);
+                    this.setHeader("Authorization", `Bearer ${accessToken}`);
                 }
             }
             const response = await fetch(this.url, {

package/dist/mail/email/get-emails.d.ts

@@ -0,0 +1,12 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult } from "../../types";
+import { EmailModel } from "../types";
+export interface Response {
+    totalCount: number;
+    items: EmailModel[];
+}
+export declare function request(queryParameters: {
+    subject?: string;
+    offset?: number;
+    emailsPerPage?: number;
+}, authorizationProvider: AuthorizationProvider): Promise<MeowResult<Response>>;

package/dist/mail/email/get-emails.js

@@ -0,0 +1,15 @@
+import { MAIL_API } from "..";
+import { ErrorToMessage } from "../../error";
+import { HttpClient } from "../../http-client";
+export async function request(queryParameters, authorizationProvider) {
+    const { subject, offset, emailsPerPage } = queryParameters;
+    return await new HttpClient()
+        .withAuthorization(authorizationProvider)
+        .withMethodGet()
+        .withParam("subject", subject)
+        .withParam("offset", offset)
+        .withParam("emailsPerPage", emailsPerPage)
+        .withUrl(`${MAIL_API}/v1/email/filter`)
+        .send()
+        .then((res) => res.mapError(ErrorToMessage));
+}

package/dist/mail/email/index.d.ts

@@ -6,10 +6,9 @@ export declare class EmailRequests {
     deleteEmailById(id: number): Promise<import("../../types").MeowResult<void>>;
     sendEmail(to: string, subject: string, content: string): Promise<import("../../types").MeowResult<void>>;
     setReadStatus(id: number, isRead: boolean): Promise<import("../../types").MeowResult<void>>;
-    getEmailWithFilter(queryParameters: {
-        isBase64?: boolean;
-        isReceived?: boolean;
-        page: number;
+    getEmails(queryParameters: {
         subject?: string;
-    }): Promise<import("../../types").MeowResult<import("./get-email-with-filter").Response>>;
+        offset?: number;
+        emailsPerPage?: number;
+    }): Promise<import("../../types").MeowResult<import("./get-emails").Response>>;
 }

package/dist/mail/email/index.js

@@ -1,8 +1,8 @@
 import { request as getEmailById } from "./get-email-by-id";
 import { request as deleteEmailById } from "./delete-email-by-id";
 import { request as sendEmail } from "./send-message";
-import { request as setReadStatus } from "./set-read-status";
-import { request as getEmailWithFilter } from "./get-email-with-filter";
+import { request as setReadStatus } from "./set-read";
+import { request as getEmailWithFilter } from "./get-emails";
 export class EmailRequests {
     authorizationProvider;
     constructor(authorizationProvider) {
@@ -20,7 +20,7 @@ export class EmailRequests {
     async setReadStatus(id, isRead) {
         return await setReadStatus(id, isRead, this.authorizationProvider);
     }
-    async getEmailWithFilter(queryParameters) {
-        return await getEmailWithFilter(this.authorizationProvider, queryParameters);
+    async getEmails(queryParameters) {
+        return await getEmailWithFilter(queryParameters, this.authorizationProvider);
     }
 }

package/dist/mail/email/set-read.d.ts

@@ -0,0 +1,3 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult } from "../../types";
+export declare function request(id: number, isRead: boolean, authorizationProvider: AuthorizationProvider): Promise<MeowResult<void>>;

package/dist/mail/email/set-read.js

@@ -0,0 +1,12 @@
+import { MAIL_API } from "..";
+import { ErrorToMessage } from "../../error";
+import { HttpClient } from "../../http-client";
+export async function request(id, isRead, authorizationProvider) {
+    return new HttpClient()
+        .withMethodPut()
+        .withUrl(`${MAIL_API}/v1/email/${id}/set-read`)
+        .withAuthorization(authorizationProvider)
+        .withJsonBody({ isRead })
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/mail/index.d.ts

@@ -1,10 +1,10 @@
 import { AuthorizationProvider } from "../auth-provider";
-import { AuthRequests } from "./auth";
+import { MailboxRequests } from "./mailbox";
 import { EmailRequests } from "./email";
 import { AdminRequests } from "./admin";
 export declare const MAIL_API = "https://mail.meowinc.tech/api";
 export declare class MailClient {
-    auth: AuthRequests;
+    mailbox: MailboxRequests;
     email: EmailRequests;
     admin: AdminRequests;
     constructor(authorizationProvider: AuthorizationProvider);

package/dist/mail/index.js

@@ -1,13 +1,13 @@
-import { AuthRequests } from "./auth";
+import { MailboxRequests } from "./mailbox";
 import { EmailRequests } from "./email";
 import { AdminRequests } from "./admin";
 export const MAIL_API = "https://mail.meowinc.tech/api";
 export class MailClient {
-    auth;
+    mailbox;
     email;
     admin;
     constructor(authorizationProvider) {
-        this.auth = new AuthRequests(authorizationProvider);
+        this.mailbox = new MailboxRequests(authorizationProvider);
         this.email = new EmailRequests(authorizationProvider);
         this.admin = new AdminRequests(authorizationProvider);
     }

package/dist/mail/mailbox/create.d.ts

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

package/dist/mail/mailbox/create.js

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

package/dist/mail/mailbox/index.d.ts

@@ -0,0 +1,7 @@
+import { AuthorizationProvider } from "../../auth-provider";
+export declare class MailboxRequests {
+    private authorizationProvider;
+    constructor(authorizationProvider: AuthorizationProvider);
+    getMyMailbox(): Promise<import("../../types").MeowResult<import("./my").Response>>;
+    createMailbox(): Promise<import("../../types").MeowResult<import("./create").Response>>;
+}

package/dist/mail/mailbox/index.js

@@ -0,0 +1,14 @@
+import { request as myRequest } from "./my";
+import { request as createMailbox } from "./create";
+export class MailboxRequests {
+    authorizationProvider;
+    constructor(authorizationProvider) {
+        this.authorizationProvider = authorizationProvider;
+    }
+    async getMyMailbox() {
+        return await myRequest(this.authorizationProvider);
+    }
+    async createMailbox() {
+        return await createMailbox(this.authorizationProvider);
+    }
+}

package/dist/mail/mailbox/my.d.ts

@@ -0,0 +1,9 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult } from "../../types";
+export interface Response {
+    mailbox: {
+        address: string;
+        id: number;
+    };
+}
+export declare function request(authProvider: AuthorizationProvider): Promise<MeowResult<Response>>;

package/dist/mail/mailbox/my.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meowinc/meow-sdk",
-    "version": "0.0.7",
+    "version": "0.0.9",
     "description": "Meow SDK",
     "keywords": [
         "sdk"
@@ -20,7 +20,7 @@
     "types": "dist/index.d.ts",
     "scripts": {
         "build": "tsc",
-        "prettier":"prettier ./src --write"
+        "prettier": "prettier ./src --write"
     },
     "dependencies": {
         "ts-result-meow": ">=0.0.13",