@thelllabs/winehaus-sdk 0.0.1

package/dist/types/api/api.d.ts

@@ -0,0 +1,282 @@
+export interface CreateTenantUserDto {
+    /** @example "user@example.com" */
+    email: string;
+    /**
+     * Password should include lowercase, uppercase and digits and have between 8 and 32 digits. (This will be only used if the user has any account created in other tenants)
+     * @example "P@ssw0rd"
+     */
+    password?: string;
+    /** @example ["operator"] */
+    roles: CreateTenantUserDtoRolesEnum[];
+}
+export declare enum CreateTenantUserDtoRolesEnum {
+    Operator = "operator",
+    Admin = "admin",
+    Owner = "owner"
+}
+export interface HttpExceptionDto {
+    /** @example null */
+    data?: object;
+    error: string;
+    /** @example "Something went wrong" */
+    message: object;
+    /** @example "/api/foo/bar" */
+    path: string;
+    /** @example 500 */
+    statusCode: number;
+    /** @example "2022-07-25T17:24:07.042Z" */
+    timestamp: string;
+}
+export interface RequestPasswordResetDto {
+    email: string;
+}
+export interface ResetPasswordDto {
+    /** @example "user@example.com" */
+    email: string;
+    /**
+     * Password should include lowercase, uppercase and digits and have between 8 and 32 digits
+     * @example "P@ssw0rd"
+     */
+    password: string;
+    /** @example "P@ssw0rd" */
+    passwordConfirmation: string;
+    token: string;
+}
+export interface SigninDto {
+    /** @example "user@example.com" */
+    email: string;
+    /** @example "P@ssw0rd" */
+    password: string;
+}
+export interface SigninResponseDto {
+    token: string;
+    user: UserEntityDto;
+}
+export interface TenantUserEntityDto {
+    roles: TenantUserEntityDtoRolesEnum[];
+    /** @example "enabled" */
+    status: TenantUserEntityDtoStatusEnum;
+    /** @format uuid */
+    tenantId: string;
+    user: UserEntityDto;
+    /** @format uuid */
+    userId: string;
+}
+export declare enum TenantUserEntityDtoRolesEnum {
+    Operator = "operator",
+    Admin = "admin",
+    Owner = "owner"
+}
+/** @example "enabled" */
+export declare enum TenantUserEntityDtoStatusEnum {
+    Enabled = "enabled",
+    Blocked = "blocked"
+}
+export interface UserEntityDto {
+    /** @format date-time */
+    createdAt?: string;
+    /** @format date-time */
+    deletedAt?: string | null;
+    email: string;
+    /** @format uuid */
+    id: string;
+    name: string;
+    /** @format date-time */
+    updatedAt: string;
+}
+export declare namespace Auth {
+    /**
+     * No description
+     * @tags Authentication
+     * @name Logout
+     * @request POST:/auth/logout
+     * @secure
+     * @response `204` `void`
+     */
+    namespace Logout {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = void;
+    }
+    /**
+     * No description
+     * @tags Authentication
+     * @name RequestPasswordReset
+     * @request POST:/auth/request-password-reset
+     * @secure
+     * @response `204` `void`
+     */
+    namespace RequestPasswordReset {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = RequestPasswordResetDto;
+        type RequestHeaders = {};
+        type ResponseBody = void;
+    }
+    /**
+     * No description
+     * @tags Authentication
+     * @name ResetPassword
+     * @request PATCH:/auth/reset-password
+     * @secure
+     * @response `200` `SigninResponseDto`
+     */
+    namespace ResetPassword {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = ResetPasswordDto;
+        type RequestHeaders = {};
+        type ResponseBody = SigninResponseDto;
+    }
+    /**
+     * No description
+     * @tags Authentication
+     * @name SignIn
+     * @request POST:/auth/signin
+     * @secure
+     * @response `200` `SigninResponseDto`
+     */
+    namespace SignIn {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = SigninDto;
+        type RequestHeaders = {};
+        type ResponseBody = SigninResponseDto;
+    }
+}
+export declare namespace Admin {
+    /**
+     * @description Gives some user access to the tenant. If there's no account attached to this users, it creates a new one
+     * @tags Admin Users
+     * @name CreateTenantUser
+     * @request POST:/admin/tenants/{tenantId}/users
+     * @secure
+     * @response `201` `TenantUserEntityDto`
+     * @response `403` `HttpExceptionDto` Need user with one of these roles: owner, admin
+     */
+    namespace CreateTenantUser {
+        type RequestParams = {
+            tenantId: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = CreateTenantUserDto;
+        type RequestHeaders = {};
+        type ResponseBody = TenantUserEntityDto;
+    }
+}
+import type { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from "axios";
+export type QueryParamsType = Record<string | number, any>;
+export interface FullRequestParams extends Omit<AxiosRequestConfig, "data" | "params" | "url" | "responseType"> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseType;
+    /** request body */
+    body?: unknown;
+}
+export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
+export interface ApiConfig<SecurityDataType = unknown> extends Omit<AxiosRequestConfig, "data" | "cancelToken"> {
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
+    secure?: boolean;
+    format?: ResponseType;
+}
+export declare enum ContentType {
+    Json = "application/json",
+    JsonApi = "application/vnd.api+json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    instance: AxiosInstance;
+    private securityData;
+    private securityWorker?;
+    private secure?;
+    private format?;
+    constructor({ securityWorker, secure, format, ...axiosConfig }?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected mergeRequestParams(params1: AxiosRequestConfig, params2?: AxiosRequestConfig): AxiosRequestConfig;
+    protected stringifyFormItem(formItem: unknown): string;
+    protected createFormData(input: Record<string, unknown>): FormData;
+    request: <T = any, _E = any>({ secure, path, type, query, format, body, ...params }: FullRequestParams) => Promise<AxiosResponse<T, any>>;
+}
+/**
+ * @title winehaus-api
+ * @version 0.0.1
+ * @baseUrl http://localhost:3000
+ * @contact
+ */
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    /**
+     * No description
+     *
+     * @tags App
+     * @name Index
+     * @request GET:/
+     * @response `200` `void`
+     */
+    index: (params?: RequestParams) => Promise<AxiosResponse<void, any>>;
+    auth: {
+        /**
+         * No description
+         *
+         * @tags Authentication
+         * @name Logout
+         * @request POST:/auth/logout
+         * @secure
+         * @response `204` `void`
+         */
+        logout: (params?: RequestParams) => Promise<AxiosResponse<void, any>>;
+        /**
+         * No description
+         *
+         * @tags Authentication
+         * @name RequestPasswordReset
+         * @request POST:/auth/request-password-reset
+         * @secure
+         * @response `204` `void`
+         */
+        requestPasswordReset: (data: RequestPasswordResetDto, params?: RequestParams) => Promise<AxiosResponse<void, any>>;
+        /**
+         * No description
+         *
+         * @tags Authentication
+         * @name ResetPassword
+         * @request PATCH:/auth/reset-password
+         * @secure
+         * @response `200` `SigninResponseDto`
+         */
+        resetPassword: (data: ResetPasswordDto, params?: RequestParams) => Promise<AxiosResponse<SigninResponseDto, any>>;
+        /**
+         * No description
+         *
+         * @tags Authentication
+         * @name SignIn
+         * @request POST:/auth/signin
+         * @secure
+         * @response `200` `SigninResponseDto`
+         */
+        signIn: (data: SigninDto, params?: RequestParams) => Promise<AxiosResponse<SigninResponseDto, any>>;
+    };
+    admin: {
+        /**
+         * @description Gives some user access to the tenant. If there's no account attached to this users, it creates a new one
+         *
+         * @tags Admin Users
+         * @name CreateTenantUser
+         * @request POST:/admin/tenants/{tenantId}/users
+         * @secure
+         * @response `201` `TenantUserEntityDto`
+         * @response `403` `HttpExceptionDto` Need user with one of these roles: owner, admin
+         */
+        createTenantUser: (tenantId: string, data: CreateTenantUserDto, params?: RequestParams) => Promise<AxiosResponse<TenantUserEntityDto, any>>;
+    };
+}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { WinehausSDK } from './sdk';
+export * from './api/api';
+export * from './interfaces';

package/dist/types/interfaces.d.ts

@@ -0,0 +1,16 @@
+export interface SDKOptions {
+    baseURL: string;
+    autoRefresh?: boolean;
+    tokenExpireOffset?: number;
+}
+export type ApiSecurityDataType = {
+    bearer: string;
+};
+export type SDKEvents = {
+    connecting: void;
+    connected: void;
+    authChanged: {
+        authToken: string;
+        refreshToken: string;
+    };
+};

package/dist/types/sdk.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { SDKOptions, ApiSecurityDataType, SDKEvents } from './interfaces';
+import { JwtPayload } from 'jwt-decode';
+import { Api, SigninDto } from './api/api';
+import { Emitter } from 'mitt';
+export declare class WinehausSDK {
+    api: Api<ApiSecurityDataType>;
+    protected authToken: string;
+    protected authTokenDecoded: JwtPayload | undefined;
+    protected refreshTokenDecoded: JwtPayload | undefined;
+    protected refreshToken: string;
+    protected options: SDKOptions;
+    protected autoRefreshTimer: NodeJS.Timeout | undefined;
+    protected credential: SigninDto | undefined;
+    emitter: Emitter<SDKEvents>;
+    protected defaultOptions: Partial<SDKOptions>;
+    constructor(options: SDKOptions);
+    enableAutoRefresh(force?: boolean): void;
+    disableAutoRefresh(): void;
+    private hookTimer;
+    private hookInterceptors;
+    clearTokens(): void;
+    authenticate(credential: SigninDto, opts?: {
+        avoidEvents?: boolean;
+    }): Promise<void>;
+    reAuthenticate(): Promise<void>;
+    isAuthenticated(): boolean;
+    protected setAuthToken(token: string): void;
+    triggerRefreshToken(): Promise<void>;
+    isTokenExpired(): boolean;
+    getAuthToken(): string;
+    protected setRefreshToken(refreshToken: string): void;
+    getRefreshToken(): string;
+    refreshTokens(): Promise<void>;
+    private authenticateAsUser;
+    private setTokens;
+    getAuthTokenDecoded(): JwtPayload | undefined;
+    getRefreshTokenDecoded(): JwtPayload | undefined;
+    static decodeToken(token: string): JwtPayload | undefined;
+}