@excali-boards/boards-api-client 1.0.30 → 1.1.1-dev.0

package/dist/{classes → cjs/classes}/admin.d.ts

@@ -1,18 +1,17 @@
-import { BoardPermissionType } from '../../prisma/generated/default';
 import { BoardsManager } from '../core/manager';
+import { GetUsersOutput } from './users';
 export declare class APIAdmin {
     private web;
     constructor(web: BoardsManager);
+    getUsers({ auth }: AdminFunctionsInput['getUsers']): Promise<import("..").WebResponse<GetUsersOutput[]>>;
     getActiveRooms({ auth }: AdminFunctionsInput['getActiveRooms']): Promise<import("..").WebResponse<GetRoomsOutput<number>[]>>;
-    updateUserPermissions({ auth, body }: AdminFunctionsInput['updateUserPermissions']): Promise<import("..").WebResponse<string>>;
 }
 export type AdminFunctionsInput = {
-    'getActiveRooms': {
+    'getUsers': {
         auth: string;
     };
-    'updateUserPermissions': {
+    'getActiveRooms': {
         auth: string;
-        body: UpdateUserPermissionsInput;
     };
 };
 export type GetRoomsOutput<T> = {
@@ -25,11 +24,3 @@ export type GetRoomsOutput<T> = {
         avatarUrl: string | null;
     }[];
 };
-export type UpdateUserPermissionsInput = {
-    userId: string;
-    isBoardsAdmin?: boolean;
-    permissions?: {
-        boardId: string;
-        permissionType: BoardPermissionType;
-    }[];
-};

package/dist/{classes → cjs/classes}/admin.js

@@ -8,16 +8,16 @@ class APIAdmin {
         this.web = web;
     }
     // Methods.
-    async getActiveRooms({ auth }) {
+    async getUsers({ auth }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp('/admin/rooms'),
+            endpoint: this.web.qp('/users'),
         });
     }
-    async updateUserPermissions({ auth, body }) {
+    async getActiveRooms({ auth }) {
         return await this.web.request({
-            method: 'POST', auth, body,
-            endpoint: this.web.qp('/admin/permissions'),
+            method: 'GET', auth,
+            endpoint: this.web.qp('/admin/rooms'),
         });
     }
 }

package/dist/{classes → cjs/classes}/boards.d.ts

@@ -1,11 +1,10 @@
-import { BoardPermissionType } from '../../prisma/generated/default';
-import { NameInput, SingleOutput } from '../external/types';
+import { AccessLevel, NameInput, SingleOutput } from '../external/types';
 import { BoardsManager } from '../core/manager';
 import { GetRoomsOutput } from './admin';
 export declare class APIBoards {
     private web;
     constructor(web: BoardsManager);
-    getBoards({ auth, categoryId, groupId }: BoardsFunctionsInput['getBoards']): Promise<import("..").WebResponse<GetBoardsOutput>>;
+    getBoards({ auth, categoryId, groupId }: BoardsFunctionsInput['getBoards']): Promise<import("..").WebResponse<GetBoardOutput[]>>;
     getBoard({ auth, categoryId, groupId, boardId }: BoardsFunctionsInput['getBoard']): Promise<import("..").WebResponse<GetBoardOutput>>;
     updateBoard({ auth, categoryId, groupId, boardId, body }: BoardsFunctionsInput['updateBoard']): Promise<import("..").WebResponse<string>>;
     scheduleBoardDeletion({ auth, categoryId, groupId, boardId }: BoardsFunctionsInput['scheduleBoardDeletion']): Promise<import("..").WebResponse<string>>;
@@ -58,26 +57,21 @@ export type BoardsFunctionsInput = {
         userId: string;
     };
 };
-export type GetBoardsOutput = {
-    isAdmin: boolean;
-    boards: {
-        group: SingleOutput;
-        category: SingleOutput;
-        board: SingleOutput & {
-            dataUrl: string;
+export type GetBoardOutput = {
+    group: SingleOutput;
+    category: SingleOutput;
+    board: SingleOutput & {
+        dataUrl: string;
+        totalSizeBytes: number;
+        accessLevel: AccessLevel;
+        scheduledForDeletion: Date | null;
+        files: {
+            fileId: string;
+            mimeType: string;
+            createdAt: Date;
             sizeBytes: number;
-            accessLevel: BoardPermissionType;
-            scheduledForDeletion: Date | null;
-            files: {
-                fileId: string;
-                mimeType: string;
-                createdAt: Date;
-                fileUrl: string;
-            }[];
-        };
-    }[];
-};
-export type GetBoardOutput = GetBoardsOutput['boards'][number] & {
-    isAdmin: boolean;
+            fileUrl: string;
+        }[];
+    };
 };
 export type GetFileOutput = ReadableStream | Blob;

package/dist/{classes → cjs/classes}/boards.js

@@ -9,7 +9,7 @@ class APIBoards {
     async getBoards({ auth, categoryId, groupId }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp(`/data/groups/${groupId}/categories/${categoryId}/boards`),
+            endpoint: this.web.qp(`/data/groups/${groupId}/categories/${categoryId}`),
         });
     }
     async getBoard({ auth, categoryId, groupId, boardId }) {

package/dist/{classes → cjs/classes}/categories.d.ts

@@ -1,6 +1,6 @@
 import { NameInput, SingleOutput } from '../external/types';
 import { BoardsManager } from '../core/manager';
-import { GetBoardsOutput } from './boards';
+import { GetBoardOutput } from './boards';
 export declare class APICategories {
     private web;
     constructor(web: BoardsManager);
@@ -45,16 +45,12 @@ export type CategoriesFunctionsInput = {
         categoryId: string;
     };
 };
-export type GetCategoriesOutput = {
-    isAdmin: boolean;
-    categories: (SingleOutput & {
-        boards: number;
-        group: SingleOutput;
-    })[];
-};
+export type GetCategoriesOutput = (SingleOutput & {
+    boards: number;
+    group: SingleOutput;
+})[];
 export type GetCategoryOutput = {
-    isAdmin: boolean;
     group: SingleOutput;
     category: SingleOutput;
-    boards: Omit<GetBoardsOutput['boards'][number]['board'], 'files'>[];
+    boards: Omit<GetBoardOutput['board'], 'files'>[];
 };

package/dist/{classes → cjs/classes}/categories.js

@@ -11,7 +11,7 @@ class APICategories {
     async getCategories({ auth, groupId }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp(`/data/groups/${groupId}/categories`),
+            endpoint: this.web.qp(`/data/groups/${groupId}`),
         });
     }
     async getCategory({ auth, groupId, categoryId }) {

package/dist/{classes → cjs/classes}/groups.d.ts

@@ -52,30 +52,23 @@ export type GroupsFunctionsInput = {
         groupId: string;
     };
 };
-export type GetGroupsOutput = {
-    isAdmin: boolean;
-    groups: (SingleOutput & {
-        categories: number;
-        isDefault: boolean;
-        sizeBytes: number;
-    })[];
-};
+export type GetGroupsOutput = (SingleOutput & {
+    categories: number;
+    isDefault: boolean;
+    sizeBytes: number;
+})[];
 export type GetGroupOutput = {
-    isAdmin: boolean;
     group: SingleOutput;
     categories: (SingleOutput & {
         boards: number;
-        sizeBytes: number;
+        totalSizeBytes: number;
     })[];
 };
-export type GetAllSortedOutput = {
-    isAdmin: boolean;
-    list: (SingleOutput & {
-        categories: (SingleOutput & {
-            boards: (SingleOutput & {
-                sizeBytes: number;
-                scheduledForDeletion: Date | null;
-            })[];
+export type GetAllSortedOutput = (SingleOutput & {
+    categories: (SingleOutput & {
+        boards: (SingleOutput & {
+            totalSizeBytes: number;
+            scheduledForDeletion: Date | null;
         })[];
     })[];
-};
+})[];

package/dist/cjs/classes/invites.d.ts

@@ -0,0 +1,82 @@
+import { BoardRole, CategoryRole, GroupRole } from '../external/vars';
+import { ResourceType } from '../external/types';
+import { BoardsManager } from '../core/manager';
+export declare class APIInvites {
+    private web;
+    constructor(web: BoardsManager);
+    getInvites({ auth }: InvitesFunctionsInput['getInvites']): Promise<import("..").WebResponse<GetInvitesOutput>>;
+    createInvite({ auth, body }: InvitesFunctionsInput['createInvite']): Promise<import("..").WebResponse<CreateInviteOutput>>;
+    useInvite({ auth, code }: InvitesFunctionsInput['useInvite']): Promise<import("..").WebResponse<UseInviteOutput>>;
+    revokeInvite({ auth, code }: InvitesFunctionsInput['revokeInvite']): Promise<import("..").WebResponse<string>>;
+}
+export type InvitesFunctionsInput = {
+    'getInvites': {
+        auth: string;
+    };
+    'createInvite': {
+        auth: string;
+        body: CreateInviteInput;
+    };
+    'useInvite': {
+        auth: string;
+        code: string;
+    };
+    'revokeInvite': {
+        auth: string;
+        code: string;
+    };
+};
+export type CreateInviteInput = {
+    groupIds?: string[];
+    categoryIds?: string[];
+    boardIds?: string[];
+    groupRole?: GroupRole;
+    categoryRole?: CategoryRole;
+    boardRole?: BoardRole;
+    expiresIn?: number;
+    maxUses?: number;
+};
+export type CreateInviteOutput = {
+    code: string;
+    expiresAt: string;
+    maxUses: number;
+};
+export type GetInvitesOutput = {
+    dbId: string;
+    code: string;
+    createdBy: string;
+    expiresAt: string | null;
+    maxUses: number | null;
+    currentUses: number;
+    groupIds: string[];
+    categoryIds: string[];
+    boardIds: string[];
+    groupRole: GroupRole | null;
+    categoryRole: CategoryRole | null;
+    boardRole: BoardRole | null;
+    createdAt: string;
+}[];
+export type GrantedRole = {
+    type: ResourceType;
+    resourceId: string;
+    role: BoardRole | CategoryRole | GroupRole;
+};
+export type UseInviteOutput = {
+    granted: GrantedRole[];
+    details: {
+        groups: {
+            groupId: string;
+            name: string;
+        }[];
+        categories: {
+            categoryId: string;
+            name: string;
+            groupId: string;
+        }[];
+        boards: {
+            boardId: string;
+            name: string;
+            categoryId: string;
+        }[];
+    };
+};

package/dist/cjs/classes/invites.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIInvites = void 0;
+// Data.
+class APIInvites {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getInvites({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/invites'),
+        });
+    }
+    async createInvite({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/invites'),
+        });
+    }
+    async useInvite({ auth, code }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/invites/${code}`),
+        });
+    }
+    async revokeInvite({ auth, code }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/invites/${code}`),
+        });
+    }
+}
+exports.APIInvites = APIInvites;

package/dist/cjs/classes/metrics.d.ts

@@ -0,0 +1,28 @@
+import { BoardsManager } from '../core/manager';
+export declare class APIMetrics {
+    private web;
+    constructor(web: BoardsManager);
+    getMetrics({ auth }: MetricsFunctionsInput['getMetrics']): Promise<import("..").WebResponse<string>>;
+    getStatus({ auth }: MetricsFunctionsInput['getStatus']): Promise<import("..").WebResponse<SystemStatus>>;
+}
+export type MetricsFunctionsInput = {
+    'getMetrics': {
+        auth: string;
+    };
+    'getStatus': {
+        auth: string;
+    };
+};
+export type SystemStatus = {
+    cpuUsage: number;
+    memoryUsage: string;
+    activeRooms: number;
+    socketConnections: number;
+    queuedFiles: number;
+    cacheSize: number;
+    totalUsers: number;
+    totalInvites: number;
+    totalBoards: number;
+    totalCategories: number;
+    totalGroups: number;
+};

package/dist/{classes/stats.js → cjs/classes/metrics.js}

@@ -1,26 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APIStats = void 0;
+exports.APIMetrics = void 0;
 // Data.
-class APIStats {
+class APIMetrics {
     web;
     constructor(web) {
         this.web = web;
     }
     // Methods.
-    async globalStats({ auth }) {
+    async getMetrics({ auth }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp('/stats'),
+            endpoint: this.web.qp('/metrics'),
         });
     }
-    async userStats({ auth, userId }) {
+    async getStatus({ auth }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp('/stats/user', {
-                userId,
-            }),
+            endpoint: this.web.qp('/metrics/status'),
         });
     }
 }
-exports.APIStats = APIStats;
+exports.APIMetrics = APIMetrics;

package/dist/cjs/classes/permissions.d.ts

@@ -0,0 +1,50 @@
+import { BoardRole, CategoryRole, GroupRole } from '../external/vars';
+import { ResourceType } from '../external/types';
+import { BoardsManager } from '../core/manager';
+export declare class APIPermissions {
+    private web;
+    constructor(web: BoardsManager);
+    viewPermissions({ auth, query }: PermissionsFunctionsInput['viewPermissions']): Promise<import("..").WebResponse<ViewPermissionsOutput>>;
+    grantPermissions({ auth, body }: PermissionsFunctionsInput['grantPermissions']): Promise<import("..").WebResponse<string>>;
+    revokePermissions({ auth, body }: PermissionsFunctionsInput['revokePermissions']): Promise<import("..").WebResponse<string>>;
+}
+export type PermissionsFunctionsInput = {
+    'viewPermissions': {
+        auth: string;
+        query: ViewPermissionsQuery;
+    };
+    'grantPermissions': {
+        auth: string;
+        body: GrantPermissionsInput;
+    };
+    'revokePermissions': {
+        auth: string;
+        body: RevokePermissionsInput;
+    };
+};
+export type ViewPermissionsQuery = {
+    type: ResourceType;
+    groupId?: string;
+    categoryId?: string;
+    boardId?: string;
+};
+export type ViewPermissionsOutput = {
+    userId: string;
+    email: string;
+    displayName: string;
+    avatarUrl: string | null;
+}[];
+export type GrantPermissionsInput = {
+    userId: string;
+    groupIds?: string[];
+    categoryIds?: string[];
+    boardIds?: string[];
+    groupRole?: GroupRole;
+    categoryRole?: CategoryRole;
+    boardRole?: BoardRole;
+};
+export type RevokePermissionsInput = {
+    userId: string;
+    resourceType: ResourceType;
+    resourceId: string;
+};

package/dist/cjs/classes/permissions.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIPermissions = void 0;
+// Data.
+class APIPermissions {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async viewPermissions({ auth, query }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/permissions/view', query),
+        });
+    }
+    async grantPermissions({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/permissions/grant'),
+        });
+    }
+    async revokePermissions({ auth, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp('/permissions/revoke'),
+        });
+    }
+}
+exports.APIPermissions = APIPermissions;

package/dist/cjs/classes/users.d.ts

@@ -0,0 +1,26 @@
+import { Platforms } from '../../prisma/generated/default';
+import { DBUserPartialType } from '../external/vars';
+import { BoardsManager } from '../core/manager';
+export declare class APIUsers {
+    private web;
+    constructor(web: BoardsManager);
+    getCurrentUser({ auth }: UsersFunctionsInput['getCurrentUser']): Promise<import("..").WebResponse<GetUsersOutput>>;
+    changeMainPlatform({ auth, newMainPlatform }: UsersFunctionsInput['changeMainPlatform']): Promise<import("..").WebResponse<string>>;
+    changeMainGroup({ auth, newMainGroupId }: UsersFunctionsInput['changeMainGroup']): Promise<import("..").WebResponse<string>>;
+}
+export type UsersFunctionsInput = {
+    'getCurrentUser': {
+        auth: string;
+    };
+    'changeMainPlatform': {
+        auth: string;
+        newMainPlatform: Platforms;
+    };
+    'changeMainGroup': {
+        auth: string;
+        newMainGroupId: string | null;
+    };
+};
+export type GetUsersOutput = DBUserPartialType & {
+    isDev: boolean;
+};

package/dist/{classes → cjs/classes}/users.js

@@ -8,18 +8,10 @@ class APIUsers {
         this.web = web;
     }
     // Methods.
-    async getUsers({ auth }) {
+    async getCurrentUser({ auth }) {
         return await this.web.request({
             method: 'GET', auth,
-            endpoint: this.web.qp('/users'),
-        });
-    }
-    async getCurrentUser({ auth, full }) {
-        return await this.web.request({
-            method: 'GET', auth,
-            endpoint: this.web.qp('/users/current', {
-                full,
-            }),
+            endpoint: this.web.qp('/users/current'),
         });
     }
     async changeMainPlatform({ auth, newMainPlatform }) {

package/dist/{core → cjs/core}/manager.d.ts

@@ -1,21 +1,23 @@
 import { PaginatedWebResponse, RequestMethod, WebResponse } from '../types';
 import { AxiosResponse, ResponseType } from 'axios';
+import { APIPermissions } from '../classes/permissions';
 import { APICategories } from '../classes/categories';
+import { APIMetrics } from '../classes/metrics';
+import { APIInvites } from '../classes/invites';
 import { APIGroups } from '../classes/groups';
 import { APIBoards } from '../classes/boards';
-import { APIUtils } from '../classes/utils';
 import { APIUsers } from '../classes/users';
-import { APIStats } from '../classes/stats';
 import { APIAdmin } from '../classes/admin';
 import { APIAuth } from '../classes/auth';
 export declare class BoardsManager {
     url: string;
+    readonly permissions: APIPermissions;
     readonly categories: APICategories;
+    readonly invites: APIInvites;
+    readonly metrics: APIMetrics;
     readonly groups: APIGroups;
     readonly boards: APIBoards;
-    readonly stats: APIStats;
     readonly admin: APIAdmin;
-    readonly utils: APIUtils;
     readonly users: APIUsers;
     readonly auth: APIAuth;
     constructor(url: string);

package/dist/{core → cjs/core}/manager.js

@@ -5,23 +5,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BoardsManager = void 0;
 const axios_1 = __importDefault(require("axios"));
+const permissions_1 = require("../classes/permissions");
 const categories_1 = require("../classes/categories");
+const metrics_1 = require("../classes/metrics");
+const invites_1 = require("../classes/invites");
 const groups_1 = require("../classes/groups");
 const boards_1 = require("../classes/boards");
-const utils_1 = require("../classes/utils");
 const users_1 = require("../classes/users");
-const stats_1 = require("../classes/stats");
 const admin_1 = require("../classes/admin");
 const auth_1 = require("../classes/auth");
-const utils_2 = require("./utils");
+const utils_1 = require("./utils");
 class BoardsManager {
     url;
+    permissions = new permissions_1.APIPermissions(this);
     categories = new categories_1.APICategories(this);
+    invites = new invites_1.APIInvites(this);
+    metrics = new metrics_1.APIMetrics(this);
     groups = new groups_1.APIGroups(this);
     boards = new boards_1.APIBoards(this);
-    stats = new stats_1.APIStats(this);
     admin = new admin_1.APIAdmin(this);
-    utils = new utils_1.APIUtils(this);
     users = new users_1.APIUsers(this);
     auth = new auth_1.APIAuth(this);
     constructor(url) {
@@ -29,7 +31,7 @@ class BoardsManager {
     }
     async request(data) {
         try {
-            axios_1.default.interceptors.response.use(utils_2.transformDates);
+            axios_1.default.interceptors.response.use(utils_1.transformDates);
             const res = await (0, axios_1.default)(this.url + data.endpoint, {
                 method: data.method,
                 data: data.body ? JSON.stringify(data.body) : undefined,

package/dist/cjs/external/types.d.ts

@@ -0,0 +1,28 @@
+import { BoardRole, CategoryRole, GroupRole } from './vars';
+import { TSPrisma } from '../../prisma/generated/default';
+export type User = TSPrisma.TSPrismaModelsFull['User'];
+export type Group = TSPrisma.TSPrismaModelsFull['Group'];
+export type Category = TSPrisma.TSPrismaModelsFull['Category'];
+export type Board = TSPrisma.TSPrismaModelsFull['Board'];
+export type File = TSPrisma.TSPrismaModelsFull['File'];
+export type LoginMethod = TSPrisma.TSPrismaModelsFull['LoginMethod'];
+export type GroupPermission = TSPrisma.TSPrismaModelsFull['GroupPermission'];
+export type CategoryPermission = TSPrisma.TSPrismaModelsFull['CategoryPermission'];
+export type BoardPermission = TSPrisma.TSPrismaModelsFull['BoardPermission'];
+export type Invite = TSPrisma.TSPrismaModelsFull['Invite'];
+export type UserRole = BoardRole | CategoryRole | GroupRole | GlobalRole;
+export declare enum GlobalRole {
+    Developer = "Developer"
+}
+export type AccessLevel = 'read' | 'write' | 'manage' | 'admin';
+export type ResourceType = 'group' | 'category' | 'board';
+export type GlobalResourceType = ResourceType | 'global';
+export type SingleOutput = {
+    id: string;
+    name: string;
+    index: number;
+    accessLevel: AccessLevel;
+};
+export type NameInput = {
+    name: string;
+};

package/dist/cjs/external/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalRole = void 0;
+var GlobalRole;
+(function (GlobalRole) {
+    GlobalRole["Developer"] = "Developer";
+})(GlobalRole || (exports.GlobalRole = GlobalRole = {}));