@meowinc/meow-sdk 0.0.1

package/.prettierrc

@@ -0,0 +1,3 @@
+{
+    "tabWidth": 4,
+}

package/dist/account/app/create.d.ts

@@ -0,0 +1,10 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult } from "../../types";
+interface Payload {
+    displayId: string;
+    name: string;
+    type: AppType;
+}
+type AppType = "web" | "mobile";
+export declare function request(payload: Payload, authProviver: AuthorizationProvider): Promise<MeowResult<void>>;
+export {};

package/dist/account/app/create.js

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

package/dist/account/app/get-app-list.d.ts

@@ -0,0 +1,7 @@
+export interface Response {
+    items: {
+        id: string;
+        name: string;
+    }[];
+}
+export declare function request(): Promise<import("ts-result-meow").Result<Response, string>>;

package/dist/account/app/get-app-list.js

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

package/dist/account/app/get-by-display-id.d.ts

@@ -0,0 +1,10 @@
+import { MeowResult } from "../../types";
+export interface Response {
+    id: string;
+    name: string;
+    owner: {
+        id: number;
+        name: string;
+    };
+}
+export declare function request(displayId: string): Promise<MeowResult<Response>>;

package/dist/account/app/get-by-display-id.js

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

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

@@ -0,0 +1,8 @@
+import { AuthorizationProvider } from "../../auth-provider";
+export declare class AppRequests {
+    private readonly authProvider;
+    constructor(authProvider: AuthorizationProvider);
+    create(displayId: string, name: string, type: "web" | "mobile"): Promise<import("../../types").MeowResult<void>>;
+    getAppList(): Promise<import("ts-result-meow").Result<import("./get-app-list").Response, string>>;
+    getByDisplayId(displayId: string): Promise<import("../../types").MeowResult<import("./get-by-display-id").Response>>;
+}

package/dist/account/app/index.js

@@ -0,0 +1,22 @@
+import { request as create } from "./create";
+import { request as getAppList } from "./get-app-list";
+import { request as getByDisplayId } from "./get-by-display-id";
+export class AppRequests {
+    authProvider;
+    constructor(authProvider) {
+        this.authProvider = authProvider;
+    }
+    async create(displayId, name, type) {
+        return create({
+            displayId,
+            name,
+            type,
+        }, this.authProvider);
+    }
+    async getAppList() {
+        return await getAppList();
+    }
+    async getByDisplayId(displayId) {
+        return await getByDisplayId(displayId);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { VerificationType } from "..";
+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>>;
+    signIn(login: string, password: string, verificationType: VerificationType): Promise<import("../../types").MeowResult<void>>;
+}

package/dist/account/auth/index.js

@@ -0,0 +1,29 @@
+import { request as signIn } from "./sign-in";
+import { request as logIn } from "./log-in";
+export class AuthRequests {
+    authProvider;
+    constructor(authProvider) {
+        this.authProvider = authProvider;
+    }
+    async baseLogIn(login, password) {
+        return await logIn({
+            login,
+            password,
+            type: "base",
+        });
+    }
+    async twoFactorLogIn(code, requestId) {
+        return await logIn({
+            code,
+            requestId,
+            type: "twoFactor",
+        });
+    }
+    async signIn(login, password, verificationType) {
+        return await signIn({
+            login,
+            password,
+            verificationType,
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import { MeowResult } from "../../types";
+type Payload = {
+    login: string;
+    password: string;
+    type: "base";
+} | {
+    requestId: string;
+    code: string;
+    type: "twoFactor";
+};
+export interface Response {
+    accessToken: string;
+    refreshToken: string;
+}
+export declare function request(payload: Payload): Promise<MeowResult<Response>>;
+export {};

package/dist/account/auth/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/sign-in.d.ts

@@ -0,0 +1,9 @@
+import { MeowResult } from "../../types";
+import { VerificationType } from "../types";
+interface Payload {
+    login: string;
+    password: string;
+    verificationType: VerificationType;
+}
+export declare function request(payload: Payload): Promise<MeowResult<void>>;
+export {};

package/dist/account/auth/sign-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/sign-in`)
+        .withJsonBody(payload)
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

package/dist/account/index.d.ts

@@ -0,0 +1,18 @@
+import { AuthRequests } from "./auth";
+import { AppRequests } from "./app";
+import type { AuthorizationProvider } from "../auth-provider";
+import { SessionsRequests } from "./sessions";
+import { UserRequests } from "./user";
+import { ServiceRequests } from "./service";
+import { ServicesPermissionsRequests } from "./services-permissions";
+export { type VerificationType } from "./types";
+export declare const ACCOUNT_API = "https://account.meowinc.tech/api";
+export declare class AccountClient {
+    app: AppRequests;
+    auth: AuthRequests;
+    user: UserRequests;
+    service: ServiceRequests;
+    servicePermissions: ServicesPermissionsRequests;
+    sessions: SessionsRequests;
+    constructor(authorizationProvider: AuthorizationProvider);
+}

package/dist/account/index.js

@@ -0,0 +1,31 @@
+import { AuthRequests } from "./auth";
+import { AppRequests } from "./app";
+import { SessionsRequests } from "./sessions";
+import { UserRequests } from "./user";
+import { ServiceRequests } from "./service";
+import { ServicesPermissionsRequests } from "./services-permissions";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const permissions = [
+    "account.getAccountInformation",
+    "account.getSecurityAccountInformation",
+    "account.requestPermissions",
+    "account.changePassword",
+    "account.appsManagement",
+];
+export const ACCOUNT_API = "https://account.meowinc.tech/api";
+export class AccountClient {
+    app;
+    auth;
+    user;
+    service;
+    servicePermissions;
+    sessions;
+    constructor(authorizationProvider) {
+        this.auth = new AuthRequests(authorizationProvider);
+        this.app = new AppRequests(authorizationProvider);
+        this.user = new UserRequests(authorizationProvider);
+        this.service = new ServiceRequests(authorizationProvider);
+        this.servicePermissions = new ServicesPermissionsRequests(authorizationProvider);
+        this.sessions = new SessionsRequests(authorizationProvider);
+    }
+}

package/dist/account/service/create-service.d.ts

@@ -0,0 +1,13 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult } from "../../types";
+export interface Response {
+    displayId: number;
+    name: string;
+    description: string;
+}
+export interface Payload {
+    displayId: string;
+    name: string;
+    description: string;
+}
+export declare function request(payload: Payload, authProvider: AuthorizationProvider): Promise<MeowResult<Response>>;

package/dist/account/service/create-service.js

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

package/dist/account/service/get-service-list.d.ts

@@ -0,0 +1,11 @@
+import { MeowResult } from "../../types";
+export interface Response {
+    items: {
+        createdAt: Date;
+        description: string;
+        displayId: string;
+        id: number;
+        name: string;
+    }[];
+}
+export declare function request(): Promise<MeowResult<Response>>;

package/dist/account/service/get-service-list.js

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

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

@@ -0,0 +1,8 @@
+import { Payload as CreateServicePayload } from "./create-service";
+import { AuthorizationProvider } from "../../auth-provider";
+export declare class ServiceRequests {
+    private readonly authProvider;
+    constructor(authProvider: AuthorizationProvider);
+    getServiceList(): Promise<import("../../types").MeowResult<import("./get-service-list").Response>>;
+    createService(payload: CreateServicePayload): Promise<import("../../types").MeowResult<import("./create-service").Response>>;
+}

package/dist/account/service/index.js

@@ -0,0 +1,14 @@
+import { request as getServiceList } from "./get-service-list";
+import { request as createService, } from "./create-service";
+export class ServiceRequests {
+    authProvider;
+    constructor(authProvider) {
+        this.authProvider = authProvider;
+    }
+    async getServiceList() {
+        return await getServiceList();
+    }
+    async createService(payload) {
+        return await createService(payload, this.authProvider);
+    }
+}

package/dist/account/services-permissions/create-permission.d.ts

@@ -0,0 +1,8 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult, UserRole } from "../../types";
+export interface Payload {
+    code: string;
+    description: string;
+    roles: UserRole[];
+}
+export declare function request(serviceId: string, payload: Payload, authProvider: AuthorizationProvider): Promise<MeowResult<void>>;

package/dist/account/services-permissions/create-permission.js

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

package/dist/account/services-permissions/get-service-permission.d.ts

@@ -0,0 +1,10 @@
+import { MeowResult, UserRole } from "../../types";
+export interface Response {
+    items: {
+        id: number;
+        code: string;
+        description: string;
+        availableRoles: UserRole[];
+    }[];
+}
+export declare function request(serviceId: string): Promise<MeowResult<Response>>;

package/dist/account/services-permissions/get-service-permission.js

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

package/dist/account/services-permissions/index.d.ts

@@ -0,0 +1,10 @@
+import { Response as GetServicePermissionsResponse } from "./get-service-permission";
+import { Payload as CreateServicePermissionPayload } from "./create-permission";
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult } from "../../types";
+export declare class ServicesPermissionsRequests {
+    authProvider: AuthorizationProvider;
+    constructor(authProvider: AuthorizationProvider);
+    getServicePermissions(serviceId: string): Promise<MeowResult<GetServicePermissionsResponse>>;
+    createServicePermissions(serviceId: string, payload: CreateServicePermissionPayload): Promise<MeowResult<void>>;
+}

package/dist/account/services-permissions/index.js

@@ -0,0 +1,14 @@
+import { request as getServicePermissions, } from "./get-service-permission";
+import { request as createServicePermission, } from "./create-permission";
+export class ServicesPermissionsRequests {
+    authProvider;
+    constructor(authProvider) {
+        this.authProvider = authProvider;
+    }
+    async getServicePermissions(serviceId) {
+        return await getServicePermissions(serviceId);
+    }
+    async createServicePermissions(serviceId, payload) {
+        return await createServicePermission(serviceId, payload, this.authProvider);
+    }
+}

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

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

package/dist/account/sessions/create.js

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

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

@@ -0,0 +1,8 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { type Payload as CreateSessionPayload } from "./create";
+export declare class SessionsRequests {
+    private readonly authProvider;
+    constructor(authProvider: AuthorizationProvider);
+    noVerificationRequtestToken(): Promise<import("../../types").MeowResult<import("./request-token").Response>>;
+    createSession(payload: CreateSessionPayload): Promise<import("../../types").MeowResult<import("./create").Response>>;
+}

package/dist/account/sessions/index.js

@@ -0,0 +1,16 @@
+import { request as createSession, } from "./create";
+import { request as requestToken } from "./request-token";
+export class SessionsRequests {
+    authProvider;
+    constructor(authProvider) {
+        this.authProvider = authProvider;
+    }
+    async noVerificationRequtestToken() {
+        return await requestToken({
+            type: "noVerification",
+        }, this.authProvider);
+    }
+    async createSession(payload) {
+        return await createSession(payload, this.authProvider);
+    }
+}

package/dist/account/sessions/request-token.d.ts

@@ -0,0 +1,19 @@
+import { AuthorizationProvider } from "../../auth-provider";
+import { MeowResult } from "../../types";
+type Payload = {
+    type: "noVerification";
+} | {
+    type: "loginPassword";
+    login: string;
+    password: string;
+} | {
+    type: "twoFactor";
+    requestId: string;
+    code: string;
+};
+export interface Response {
+    type: "success";
+    token: string;
+}
+export declare function request(payload: Payload, authProvider: AuthorizationProvider): Promise<MeowResult<Response>>;
+export {};

package/dist/account/sessions/request-token.js

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

package/dist/account/types.d.ts

@@ -0,0 +1 @@
+export type VerificationType = "noVerification" | "loginPassword";

package/dist/account/types.js

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

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

@@ -0,0 +1,11 @@
+type UserRole = "root" | "admin" | "user" | "inActive";
+export interface Response {
+    id: number;
+    login: string;
+    name: string;
+    role: UserRole;
+    status: string;
+    registrationDate: Date;
+}
+export declare function request(login: string): Promise<import("ts-result-meow").Result<Response, string>>;
+export {};

package/dist/account/user/get-user-by-login.js

@@ -0,0 +1,10 @@
+import { ACCOUNT_API } from "..";
+import { ErrorToMessage } from "../../error";
+import { HttpClient } from "../../http-client";
+export async function request(login) {
+    return new HttpClient()
+        .withUrl(`${ACCOUNT_API}/v1/user/${login}`)
+        .withMethodGet()
+        .send()
+        .then((r) => r.mapError(ErrorToMessage));
+}

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

@@ -0,0 +1,6 @@
+import { AuthorizationProvider } from "../../auth-provider";
+export declare class UserRequests {
+    private readonly authProvider;
+    constructor(authProvider: AuthorizationProvider);
+    getUserByLogin(login: string): Promise<import("ts-result-meow").Result<import("./get-user-by-login").Response, string>>;
+}

package/dist/account/user/index.js

@@ -0,0 +1,10 @@
+import { request as getUserByLoginRequest } from "./get-user-by-login";
+export class UserRequests {
+    authProvider;
+    constructor(authProvider) {
+        this.authProvider = authProvider;
+    }
+    async getUserByLogin(login) {
+        return await getUserByLoginRequest(login);
+    }
+}

package/dist/auth-provider.d.ts

@@ -0,0 +1,28 @@
+import type { UndefinedString } from "./types";
+export interface AuthorizationProvider {
+    getAccessToken(): UndefinedString;
+    setAccessToken(token: string): void;
+    getRefreshToken(): UndefinedString;
+    setRefreshToken(token: string): void;
+}
+type StorageType = "localStorage" | "sessionStorage";
+export declare class BrowserAuthhorizationProvider implements AuthorizationProvider {
+    private readonly storageType;
+    private readonly accessTokenKey;
+    private readonly refreshTokenKey;
+    constructor(storageType: StorageType, accessTokenKey: string, refreshTokenKey: string);
+    getAccessToken(): UndefinedString;
+    setAccessToken(token: string): void;
+    getRefreshToken(): UndefinedString;
+    setRefreshToken(token: string): void;
+}
+export declare class InPlaceAuthorizationProvider implements AuthorizationProvider {
+    private accessToken;
+    private refreshToken;
+    constructor(accessToken: UndefinedString, refreshToken: UndefinedString);
+    getAccessToken(): UndefinedString;
+    setAccessToken(token: string): void;
+    getRefreshToken(): UndefinedString;
+    setRefreshToken(token: string): void;
+}
+export {};

package/dist/auth-provider.js

@@ -0,0 +1,62 @@
+export class BrowserAuthhorizationProvider {
+    storageType;
+    accessTokenKey;
+    refreshTokenKey;
+    constructor(storageType, accessTokenKey, refreshTokenKey) {
+        this.storageType = storageType;
+        this.accessTokenKey = accessTokenKey;
+        this.refreshTokenKey = refreshTokenKey;
+    }
+    getAccessToken() {
+        switch (this.storageType) {
+            case "localStorage":
+                return localStorage.getItem(this.accessTokenKey) ?? undefined;
+            case "sessionStorage":
+                return sessionStorage.getItem(this.accessTokenKey) ?? undefined;
+        }
+    }
+    setAccessToken(token) {
+        switch (this.storageType) {
+            case "localStorage":
+                return localStorage.setItem(this.accessTokenKey, token);
+            case "sessionStorage":
+                return sessionStorage.setItem(this.accessTokenKey, token);
+        }
+    }
+    getRefreshToken() {
+        switch (this.storageType) {
+            case "localStorage":
+                return localStorage.getItem(this.refreshTokenKey) ?? undefined;
+            case "sessionStorage":
+                return (sessionStorage.getItem(this.refreshTokenKey) ?? undefined);
+        }
+    }
+    setRefreshToken(token) {
+        switch (this.storageType) {
+            case "localStorage":
+                return localStorage.setItem(this.refreshTokenKey, token);
+            case "sessionStorage":
+                return sessionStorage.setItem(this.refreshTokenKey, token);
+        }
+    }
+}
+export class InPlaceAuthorizationProvider {
+    accessToken;
+    refreshToken;
+    constructor(accessToken, refreshToken) {
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
+    }
+    getAccessToken() {
+        return this.accessToken;
+    }
+    setAccessToken(token) {
+        this.accessToken = token;
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setRefreshToken(token) {
+        this.refreshToken = token;
+    }
+}

package/dist/error.d.ts

@@ -0,0 +1,30 @@
+export type AppError = {
+    type: "internalServerError";
+} | {
+    type: "validationError";
+    errors: {
+        field: string;
+        message: string;
+    }[];
+} | {
+    type: "anyError";
+    message: string;
+} | {
+    type: "notFound";
+    message?: string;
+} | {
+    type: "authorization";
+    message: string;
+};
+export declare class HttpError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare function ErrorToMessage(err: HttpError | AppError | Error): string;
+export declare function isAuthorizationError(obj: {
+    type?: string;
+    message?: string;
+}): obj is {
+    type: "authorization";
+    message: string;
+};

package/dist/error.js

@@ -0,0 +1,34 @@
+export class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "HttpError";
+        this.status = status;
+    }
+}
+export function ErrorToMessage(err) {
+    if (err instanceof HttpError) {
+        return `${err.status}: ${err.message}`;
+    }
+    if ("type" in err) {
+        const appError = err;
+        switch (appError.type) {
+            case "internalServerError":
+                return "Внутренняя ошибка сервера";
+            case "validationError":
+                return appError.errors
+                    .map((e) => `${e.field}: ${e.message}`)
+                    .join(", ");
+            case "anyError":
+                return appError.message;
+            case "notFound":
+                return appError.message ?? "Не найдено";
+            case "authorization":
+                return appError.message;
+        }
+    }
+    return err.message || "Неизвестная ошибка";
+}
+export function isAuthorizationError(obj) {
+    return obj.type === "authorization" && obj.message != undefined;
+}

package/dist/http-client.d.ts

@@ -0,0 +1,21 @@
+import type { AuthorizationProvider } from "./auth-provider";
+import { Result } from "ts-result-meow";
+import { HttpError, type AppError } from "./error";
+export declare class HttpClient {
+    private url;
+    private headers;
+    private method;
+    private body;
+    private params;
+    private authorization?;
+    withUrl(url: string): this;
+    withParam(key: string, value: string): this;
+    withMethodGet(): this;
+    withMethodPost(): this;
+    withMethodPut(): this;
+    withMethodDelete(): this;
+    setHeader(key: string, value: string): this;
+    withAuthorization(authProvider: AuthorizationProvider): this;
+    withJsonBody(body: object): this;
+    send<T>(): Promise<Result<T, HttpError | AppError | Error>>;
+}

package/dist/http-client.js

@@ -0,0 +1,130 @@
+import { Result } from "ts-result-meow";
+import { HttpError } from "./error";
+import { AccessToken } from "./token";
+import { ACCOUNT_API } from "./account";
+export class HttpClient {
+    url = "";
+    headers = {};
+    method = "GET";
+    body = null;
+    params = {};
+    authorization;
+    withUrl(url) {
+        this.url = url;
+        return this;
+    }
+    withParam(key, value) {
+        this.params[key] = value;
+        return this;
+    }
+    withMethodGet() {
+        this.method = "GET";
+        return this;
+    }
+    withMethodPost() {
+        this.method = "POST";
+        return this;
+    }
+    withMethodPut() {
+        this.method = "PUT";
+        return this;
+    }
+    withMethodDelete() {
+        this.method = "DELETE";
+        return this;
+    }
+    setHeader(key, value) {
+        this.headers[key] = value;
+        return this;
+    }
+    withAuthorization(authProvider) {
+        this.authorization = authProvider;
+        return this;
+    }
+    withJsonBody(body) {
+        this.body = JSON.stringify(body);
+        this.setHeader("Content-Type", "application/json");
+        return this;
+    }
+    async send() {
+        try {
+            if (Object.keys(this.params).length > 0) {
+                let params = "?";
+                for (const [key, value] of Object.entries(this.params)) {
+                    params += `${key}=${value}&`;
+                }
+                this.url += params;
+            }
+            // if authorization required
+            if (this.authorization) {
+                const accessToken = this.authorization.getAccessToken();
+                if (!accessToken || new AccessToken(accessToken).isExpired()) {
+                    const refreshToken = this.authorization.getRefreshToken();
+                    if (!refreshToken) {
+                        return Result.withError({
+                            type: "authorization",
+                            message: "Authorization error",
+                        });
+                    }
+                    const updateAuth = await fetch(`${ACCOUNT_API}/v1/sessions/update-session`, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({
+                            refreshToken: refreshToken,
+                        }),
+                    });
+                    if (!updateAuth.ok) {
+                        return Result.withError({
+                            type: "authorization",
+                            message: "Update authorization error. Please login first",
+                        });
+                    }
+                    const tokens = (await updateAuth.json());
+                    this.authorization.setRefreshToken(tokens.refreshToken);
+                    this.authorization.setAccessToken(tokens.accessToken);
+                    this.setHeader("Authorization", tokens.accessToken);
+                }
+                else {
+                    this.setHeader("Authorization", accessToken);
+                }
+            }
+            const response = await fetch(this.url, {
+                method: this.method,
+                headers: this.headers,
+                body: this.body,
+            });
+            if (response.ok) {
+                const contentType = response.headers.get("content-type");
+                if (contentType && contentType.includes("application/json")) {
+                    const data = await response.json();
+                    return Result.withOk(data);
+                }
+                const text = await response.text();
+                return Result.withOk(text);
+            }
+            else {
+                const contentType = response.headers.get("content-type");
+                if (contentType && contentType.includes("application/json")) {
+                    const appErrorTypes = [
+                        "anyError",
+                        "validationError",
+                        "internalServerError",
+                        "notFound",
+                        "authorization",
+                    ];
+                    const errorData = await response.json().catch(() => null);
+                    if (errorData &&
+                        appErrorTypes.includes(errorData?.type ?? "")) {
+                        return Result.withError(errorData);
+                    }
+                }
+                return Result.withError(new HttpError(response.status, response.statusText));
+            }
+        }
+        catch (err) {
+            return Result.withError(err);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { AccountClient } from "./account";
+import type { AuthorizationProvider } from "./auth-provider";
+import type { UndefinedString } from "./types";
+export declare class MeowSdkClient<T extends AuthorizationProvider> {
+    readonly account: AccountClient;
+    private readonly authProvider;
+    protected constructor(authProvider: T);
+    isAuthorizationExist(): boolean;
+    updateAccessToken(accessToken: string): void;
+    updateRefreshToken(refreshToken: string): void;
+    getAccessToken(): UndefinedString;
+    static fromAuthorizationProvider<T extends AuthorizationProvider>(provider: AuthorizationProvider): MeowSdkClient<T>;
+}

package/dist/index.js

@@ -0,0 +1,25 @@
+import { AccountClient } from "./account";
+export class MeowSdkClient {
+    account;
+    authProvider;
+    constructor(authProvider) {
+        this.authProvider = authProvider;
+        this.account = new AccountClient(authProvider);
+    }
+    isAuthorizationExist() {
+        return (this.authProvider.getAccessToken() != undefined ||
+            this.authProvider.getRefreshToken() != undefined);
+    }
+    updateAccessToken(accessToken) {
+        this.authProvider.setAccessToken(accessToken);
+    }
+    updateRefreshToken(refreshToken) {
+        this.authProvider.setRefreshToken(refreshToken);
+    }
+    getAccessToken() {
+        return this.authProvider.getAccessToken();
+    }
+    static fromAuthorizationProvider(provider) {
+        return new MeowSdkClient(provider);
+    }
+}

package/dist/token.d.ts

@@ -0,0 +1,8 @@
+export declare class AccessToken {
+    private payload;
+    private token;
+    constructor(token: string);
+    isExpired(): boolean;
+    userLogin(): string;
+    raw(): string;
+}

package/dist/token.js

@@ -0,0 +1,20 @@
+import { jwtDecode } from "jwt-decode";
+export class AccessToken {
+    payload;
+    token;
+    constructor(token) {
+        this.payload = jwtDecode(token);
+        this.token = token;
+    }
+    isExpired() {
+        const now = new Date();
+        const expiredAt = new Date(this.payload.lifetime.expired_at);
+        return now > expiredAt;
+    }
+    userLogin() {
+        return this.payload.user.login;
+    }
+    raw() {
+        return this.token;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import { Result } from "ts-result-meow";
+export type UndefinedString = string | undefined;
+export type UserRole = "root" | "admin" | "user" | "inactive";
+type MeowError = string;
+export declare class MeowResult<TRes> extends Result<TRes, MeowError> {
+}
+export {};

package/dist/types.js

@@ -0,0 +1,3 @@
+import { Result } from "ts-result-meow";
+export class MeowResult extends Result {
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@meowinc/meow-sdk",
+    "version": "0.0.1",
+    "description": "Meow SDK",
+    "keywords": [
+        "sdk"
+    ],
+    "homepage": "https://github.com/ProjectMeowInc/meow-sdk-ts#readme",
+    "bugs": {
+        "url": "https://github.com/ProjectMeowInc/meow-sdk-ts/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/ProjectMeowInc/meow-sdk-ts.git"
+    },
+    "license": "MIT",
+    "author": "BlackSoulHub",
+    "type": "module",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc"
+    },
+    "dependencies": {
+        "ts-result-meow": ">=0.0.13",
+        "jwt-decode": ">=4"
+    },
+    "devDependencies": {
+        "typescript": "^5.9.3"
+    }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        // File Layout
+        "rootDir": "./src",
+        "outDir": "./dist",
+
+        "module": "ES2022",
+        "moduleResolution": "bundler",
+        "target": "ES2024",
+        "declaration": true,
+
+        "strict": true,
+        "noImplicitAny": true,
+        "esModuleInterop": true,
+        "strictNullChecks": true,
+    },
+    "exclude": ["node_modules"],
+    "include": ["src/**/*"],
+}