rowt-console-sdk
Version:
SDK for interacting with Rowt Server API from a client-side application.
195 lines (194 loc) • 7.45 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const axios_1 = __importDefault(require("axios"));
class RowtConsole {
constructor(baseURL) {
this.isRefreshing = false;
this.refreshSubscribers = [];
this.client = axios_1.default.create({
baseURL,
headers: {
"Content-Type": "application/json",
},
});
// Request interceptor to attach token
this.client.interceptors.request.use((config) => {
const token = localStorage.getItem("access_token");
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
return config;
});
// Response interceptor to handle 401 errors
this.client.interceptors.response.use((response) => response, (error) => {
const { config, response } = error;
if (response && response.status === 401 && !config._retry) {
console.log("401 detected, initiating token refresh...");
config._retry = true;
if (!this.isRefreshing) {
this.isRefreshing = true;
console.log("Refreshing token...");
this.refreshToken()
.then((newToken) => {
console.log("Token refresh successful.");
this.onRefreshed(newToken);
})
.catch(() => {
console.log("Token refresh failed, clearing tokens.");
this.clearTokens();
})
.finally(() => {
this.isRefreshing = false;
});
}
return new Promise((resolve, reject) => {
this.subscribeTokenRefresh((token) => {
console.log("Retrying request with new token...");
config.headers.Authorization = `Bearer ${token}`;
resolve(this.client(config));
});
});
}
return Promise.reject(error);
});
}
subscribeTokenRefresh(callback) {
this.refreshSubscribers.push(callback);
}
onRefreshed(newToken) {
this.refreshSubscribers.forEach((callback) => callback(newToken));
this.refreshSubscribers = [];
}
async refreshToken() {
const refreshToken = localStorage.getItem("refresh_token");
if (!refreshToken) {
throw new Error("No refresh token available");
}
const response = await this.client.post("/auth/refresh", { refresh_token: refreshToken }, {
headers: {
"Content-Type": "application/json",
Authorization: undefined,
},
});
const { access_token, refresh_token } = response.data;
if (!access_token || !refresh_token) {
throw new Error("Invalid token response");
}
localStorage.setItem("access_token", access_token);
localStorage.setItem("refresh_token", refresh_token);
return access_token;
}
clearTokens() {
localStorage.removeItem("access_token");
localStorage.removeItem("refresh_token");
}
async login(credentials) {
const response = await this.client.post("/auth/login", credentials);
this.storeTokens(response.data.tokens);
return response.data.user;
}
async logout() {
try {
const tokens = {
access_token: localStorage.getItem("access_token"),
refresh_token: localStorage.getItem("refresh_token"),
};
await this.client.post("/auth/logout", tokens, {
headers: {
"Content-Type": "application/json",
Authorization: undefined,
},
});
}
finally {
this.clearTokens();
return "Logout successful";
}
}
async validateUser(RowtLoginDTO) {
console.log("Validating user with credentials:", RowtLoginDTO);
const response = await this.client.post("/auth/validate", RowtLoginDTO);
console.log("Validation response:", response.data);
const { isValid } = response.data;
console.log("User validation result:", isValid);
return isValid;
}
async createUser(email, password) {
const response = await this.client.post("/users/create", {
email,
password,
});
return response.data;
}
async getProfile() {
const response = await this.client.get("/auth/profile");
return response.data;
}
async getCurrentUser() {
const response = await this.client.get("/users/currentUser");
return response.data;
}
async updatePassword(updatePasswordDTO) {
const response = await this.client.post("/auth/updatepassword", updatePasswordDTO);
return response.data;
}
async getLinksByProjectId(projectId, includeInteractions = false) {
if (!projectId) {
throw new Error("Missing projectId");
}
const payload = { projectId, includeInteractions };
const response = await this.client.post("/link/byProjectId", payload);
return response.data;
}
async getProjectById(projectId, options) {
if (!projectId) {
throw new Error("Missing projectId");
}
const defaultOptions = {
includeLinks: false,
includeInteractions: false,
startDate: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
endDate: new Date(),
};
const mergedOptions = { ...defaultOptions, ...options };
const payload = { id: projectId, options: mergedOptions };
const response = await this.client.post(`/projects/getById`, payload);
return response.data;
}
storeTokens(tokens) {
localStorage.setItem("access_token", tokens.access_token);
localStorage.setItem("refresh_token", tokens.refresh_token);
}
async getUserProjects() {
const response = await this.client.post("/projects/getUserProjects");
return response.data;
}
async updateProject(project) {
console.log("Updating project:", project);
const response = await this.client.post(`/projects/update`, project);
return response.data;
}
async createProject(project) {
const response = await this.client.post(`/projects/create`, project);
return response.data;
}
async regenerateApiKey(projectId) {
if (!projectId) {
throw new Error("Missing projectId");
}
const response = await this.client.post("/projects/generateApiKey", { projectId });
return response.data.apiKey;
}
async getUserUsage(userId) {
const response = await this.client.post("/users/usage", { userId });
return response.data;
}
async getUserTier(userId) {
const response = await this.client.post("/users/tier", { userId });
return response.data;
}
}
exports.default = RowtConsole;