@totoday/quinn-sdk 0.1.3 → 0.2.1

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { CompetenciesService } from './services/competencies';
 import { CoursesService } from './services/courses';
 import { EndorsementsService } from './services/endorsements';
 import { GroupsService } from './services/groups';
+import { KnowledgeService } from './services/knowledge';
 import { LevelsService } from './services/levels';
 import { MembersService } from './services/members';
 import { OrganizationsService } from './services/organizations';
@@ -15,10 +16,12 @@ export { DEFAULT_QUINN_API_URL, resolveApiUrl, resolveConfigPath, } from './conf
 export type { QuinnClientConfig } from './config';
 export type { QuinnMutationAccess } from './mutation-access';
 export { QuinnMutationAccessError } from './mutation-access';
+export { KnowledgeDocumentsService, KnowledgeFoldersService, KnowledgeService, } from './services/knowledge';
 export declare class Quinn {
     private readonly config;
     private readonly http;
     readonly organizations: OrganizationsService;
+    readonly knowledge: KnowledgeService;
     readonly members: MembersService;
     readonly roles: RolesService;
     readonly levels: LevelsService;

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Quinn = exports.QuinnMutationAccessError = exports.resolveConfigPath = exports.resolveApiUrl = exports.DEFAULT_QUINN_API_URL = exports.QuinnAuth = void 0;
+exports.Quinn = exports.KnowledgeService = exports.KnowledgeFoldersService = exports.KnowledgeDocumentsService = exports.QuinnMutationAccessError = exports.resolveConfigPath = exports.resolveApiUrl = exports.DEFAULT_QUINN_API_URL = exports.QuinnAuth = void 0;
 const config_1 = require("./config");
 const http_1 = require("./http");
 const mutation_access_1 = require("./mutation-access");
@@ -22,6 +22,7 @@ const competencies_1 = require("./services/competencies");
 const courses_1 = require("./services/courses");
 const endorsements_1 = require("./services/endorsements");
 const groups_1 = require("./services/groups");
+const knowledge_1 = require("./services/knowledge");
 const levels_1 = require("./services/levels");
 const members_1 = require("./services/members");
 const organizations_1 = require("./services/organizations");
@@ -37,10 +38,15 @@ Object.defineProperty(exports, "resolveApiUrl", { enumerable: true, get: functio
 Object.defineProperty(exports, "resolveConfigPath", { enumerable: true, get: function () { return config_2.resolveConfigPath; } });
 var mutation_access_2 = require("./mutation-access");
 Object.defineProperty(exports, "QuinnMutationAccessError", { enumerable: true, get: function () { return mutation_access_2.QuinnMutationAccessError; } });
+var knowledge_2 = require("./services/knowledge");
+Object.defineProperty(exports, "KnowledgeDocumentsService", { enumerable: true, get: function () { return knowledge_2.KnowledgeDocumentsService; } });
+Object.defineProperty(exports, "KnowledgeFoldersService", { enumerable: true, get: function () { return knowledge_2.KnowledgeFoldersService; } });
+Object.defineProperty(exports, "KnowledgeService", { enumerable: true, get: function () { return knowledge_2.KnowledgeService; } });
 class Quinn {
     config;
     http;
     organizations;
+    knowledge;
     members;
     roles;
     levels;
@@ -60,12 +66,13 @@ class Quinn {
                     orgId: this.config.orgId,
                 });
         this.organizations = new organizations_1.OrganizationsService(this.http, this.assertMutationAllowed);
+        this.knowledge = new knowledge_1.KnowledgeService(this.http);
         this.members = new members_1.MembersService(this.http, this.assertMutationAllowed);
-        this.roles = new roles_1.RolesService(this.http);
+        this.roles = new roles_1.RolesService(this.http, this.assertMutationAllowed);
         this.levels = new levels_1.LevelsService(this.http);
-        this.competencies = new competencies_1.CompetenciesService(this.http);
-        this.courses = new courses_1.CoursesService(this.http);
-        this.groups = new groups_1.GroupsService(this.http);
+        this.competencies = new competencies_1.CompetenciesService(this.http, this.assertMutationAllowed);
+        this.courses = new courses_1.CoursesService(this.http, this.assertMutationAllowed);
+        this.groups = new groups_1.GroupsService(this.http, this.assertMutationAllowed);
         this.programs = new programs_1.ProgramsService(this.http);
         this.progress = new progress_1.ProgressService(this.http);
         this.endorsements = new endorsements_1.EndorsementsService(this.http, this.assertMutationAllowed);

package/dist/services/competencies.d.ts

@@ -1,10 +1,14 @@
 import { AxiosInstance } from 'axios';
-import { CompetenciesListQuery, Competency, Course, PagedResult } from '../types';
+import { CompetenciesCreateInput, CompetenciesListQuery, CompetenciesUpdateInput, Competency, Course, PagedResult } from '../types';
 export declare class CompetenciesService {
     private readonly http;
-    constructor(http: AxiosInstance);
+    private readonly assertMutationAllowed;
+    constructor(http: AxiosInstance, assertMutationAllowed: (operation: string) => void);
     list(query: CompetenciesListQuery): Promise<PagedResult<Competency>>;
     get(id: string): Promise<Competency | null>;
     batchGet(ids: string[]): Promise<Competency[]>;
     listCourses(id: string): Promise<Course[]>;
+    create(input: CompetenciesCreateInput): Promise<Competency | null>;
+    update(input: CompetenciesUpdateInput): Promise<Competency | null>;
+    delete(competencyId: string): Promise<void>;
 }

package/dist/services/competencies.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompetenciesService = void 0;
 class CompetenciesService {
     http;
-    constructor(http) {
+    assertMutationAllowed;
+    constructor(http, assertMutationAllowed) {
         this.http = http;
+        this.assertMutationAllowed = assertMutationAllowed;
     }
     async list(query) {
         const resp = await this.http.get('/competencies', { params: query });
@@ -22,5 +24,25 @@ class CompetenciesService {
         const resp = await this.http.get(`/competencies/${id}/courses`);
         return resp.data.items;
     }
+    async create(input) {
+        this.assertMutationAllowed('competencies.create');
+        const resp = await this.http.post('/competencies', input);
+        return resp.data.item;
+    }
+    async update(input) {
+        this.assertMutationAllowed('competencies.update');
+        const resp = await this.http.patch(`/competencies/${input.competencyId}`, {
+            name: input.name,
+            description: input.description,
+            roleId: input.roleId,
+            levelIds: input.levelIds,
+            settings: input.settings,
+        });
+        return resp.data.item;
+    }
+    async delete(competencyId) {
+        this.assertMutationAllowed('competencies.delete');
+        await this.http.delete(`/competencies/${competencyId}`);
+    }
 }
 exports.CompetenciesService = CompetenciesService;

package/dist/services/courses.d.ts

@@ -1,12 +1,17 @@
 import { AxiosInstance } from 'axios';
-import { Course, PagedResult } from '../types';
+import { AssignedUser, Course, CoursesAssignToGroupsInput, CoursesAssignToUsersInput, CoursesUnassignFromGroupInput, CoursesUnassignFromUserInput, PagedResult } from '../types';
 export declare class CoursesService {
     private readonly http;
-    constructor(http: AxiosInstance);
+    private readonly assertMutationAllowed;
+    constructor(http: AxiosInstance, assertMutationAllowed: (operation: string) => void);
     list(query?: {
         limit?: number;
         token?: string;
     }): Promise<PagedResult<Course>>;
     get(id: string): Promise<Course | null>;
     batchGet(ids: string[]): Promise<Course[]>;
+    assignToUsers(input: CoursesAssignToUsersInput): Promise<AssignedUser[]>;
+    assignToGroups(input: CoursesAssignToGroupsInput): Promise<void>;
+    unassignFromUser(input: CoursesUnassignFromUserInput): Promise<void>;
+    unassignFromGroup(input: CoursesUnassignFromGroupInput): Promise<void>;
 }

package/dist/services/courses.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoursesService = void 0;
 class CoursesService {
     http;
-    constructor(http) {
+    assertMutationAllowed;
+    constructor(http, assertMutationAllowed) {
         this.http = http;
+        this.assertMutationAllowed = assertMutationAllowed;
     }
     async list(query = {}) {
         const resp = await this.http.get('/courses', { params: query });
@@ -18,5 +20,28 @@ class CoursesService {
         const resp = await this.http.post('/courses/batch', { ids });
         return resp.data.items;
     }
+    async assignToUsers(input) {
+        this.assertMutationAllowed('courses.assignToUsers');
+        const resp = await this.http.post(`/courses/${input.courseId}/assign/users`, {
+            userIds: input.userIds,
+            dueDateConfig: input.dueDateConfig,
+        });
+        return resp.data.assignedUsers;
+    }
+    async assignToGroups(input) {
+        this.assertMutationAllowed('courses.assignToGroups');
+        await this.http.post(`/courses/${input.courseId}/assign/groups`, {
+            groupIds: input.groupIds,
+            dueDateConfig: input.dueDateConfig,
+        });
+    }
+    async unassignFromUser(input) {
+        this.assertMutationAllowed('courses.unassignFromUser');
+        await this.http.delete(`/courses/${input.courseId}/users/${input.userId}`);
+    }
+    async unassignFromGroup(input) {
+        this.assertMutationAllowed('courses.unassignFromGroup');
+        await this.http.delete(`/courses/${input.courseId}/groups/${input.groupId}`);
+    }
 }
 exports.CoursesService = CoursesService;

package/dist/services/groups.d.ts

@@ -1,10 +1,16 @@
 import { AxiosInstance } from 'axios';
-import { Group, GroupMember } from '../types';
+import { AssignedUser, Group, GroupMember, GroupsAddMembersInput, GroupsCreateInput, GroupsCreateResult, GroupsRemoveMemberInput, GroupsUpdateNameInput } from '../types';
 export declare class GroupsService {
     private readonly http;
-    constructor(http: AxiosInstance);
+    private readonly assertMutationAllowed;
+    constructor(http: AxiosInstance, assertMutationAllowed: (operation: string) => void);
     list(): Promise<Group[]>;
     get(id: string): Promise<Group | null>;
     batchGet(ids: string[]): Promise<Group[]>;
     listMembers(groupId: string): Promise<GroupMember[]>;
+    create(input: GroupsCreateInput): Promise<GroupsCreateResult>;
+    updateName(input: GroupsUpdateNameInput): Promise<Group | null>;
+    delete(groupId: string): Promise<void>;
+    addMembers(input: GroupsAddMembersInput): Promise<AssignedUser[]>;
+    removeMember(input: GroupsRemoveMemberInput): Promise<void>;
 }

package/dist/services/groups.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupsService = void 0;
 class GroupsService {
     http;
-    constructor(http) {
+    assertMutationAllowed;
+    constructor(http, assertMutationAllowed) {
         this.http = http;
+        this.assertMutationAllowed = assertMutationAllowed;
     }
     async list() {
         const resp = await this.http.get('/groups');
@@ -22,5 +24,30 @@ class GroupsService {
         const resp = await this.http.get(`/groups/${groupId}/members`);
         return resp.data.items;
     }
+    async create(input) {
+        this.assertMutationAllowed('groups.create');
+        const resp = await this.http.post('/groups', input);
+        return resp.data;
+    }
+    async updateName(input) {
+        this.assertMutationAllowed('groups.updateName');
+        const resp = await this.http.put(`/groups/${input.groupId}/name`, { name: input.name });
+        return resp.data.item;
+    }
+    async delete(groupId) {
+        this.assertMutationAllowed('groups.delete');
+        await this.http.delete(`/groups/${groupId}`);
+    }
+    async addMembers(input) {
+        this.assertMutationAllowed('groups.addMembers');
+        const resp = await this.http.post(`/groups/${input.groupId}/members`, {
+            userIds: input.userIds,
+        });
+        return resp.data.assignedUsers;
+    }
+    async removeMember(input) {
+        this.assertMutationAllowed('groups.removeMember');
+        await this.http.delete(`/groups/${input.groupId}/members/${input.userId}`);
+    }
 }
 exports.GroupsService = GroupsService;

package/dist/services/knowledge.d.ts

@@ -0,0 +1,24 @@
+import { AxiosInstance } from 'axios';
+import { GetDocumentTranscriptResponse, KnowledgeDocument, KnowledgeDocumentsListQuery, KnowledgeFolder, KnowledgeFoldersListQuery, KnowledgeSearchHit, KnowledgeSearchInput, PagedResult } from '../types';
+export declare class KnowledgeDocumentsService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(query?: KnowledgeDocumentsListQuery): Promise<PagedResult<KnowledgeDocument>>;
+    get(id: string): Promise<KnowledgeDocument | null>;
+    getTranscript(id: string): Promise<GetDocumentTranscriptResponse>;
+}
+export declare class KnowledgeFoldersService {
+    private readonly http;
+    constructor(http: AxiosInstance);
+    list(query?: KnowledgeFoldersListQuery): Promise<{
+        items: KnowledgeFolder[];
+    }>;
+    get(id: string): Promise<KnowledgeFolder | null>;
+}
+export declare class KnowledgeService {
+    private readonly http;
+    readonly documents: KnowledgeDocumentsService;
+    readonly folders: KnowledgeFoldersService;
+    constructor(http: AxiosInstance);
+    search(input: KnowledgeSearchInput): Promise<KnowledgeSearchHit[]>;
+}

package/dist/services/knowledge.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeService = exports.KnowledgeFoldersService = exports.KnowledgeDocumentsService = void 0;
+class KnowledgeDocumentsService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(query = {}) {
+        const resp = await this.http.get('/knowledge/documents', { params: query });
+        return resp.data;
+    }
+    async get(id) {
+        const resp = await this.http.get(`/knowledge/documents/${id}`);
+        return resp.data.item;
+    }
+    async getTranscript(id) {
+        const resp = await this.http.get(`/knowledge/documents/${id}/transcript`);
+        return resp.data;
+    }
+}
+exports.KnowledgeDocumentsService = KnowledgeDocumentsService;
+class KnowledgeFoldersService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(query = {}) {
+        const resp = await this.http.get('/knowledge/folders', { params: query });
+        return resp.data;
+    }
+    async get(id) {
+        const resp = await this.http.get(`/knowledge/folders/${id}`);
+        return resp.data.item;
+    }
+}
+exports.KnowledgeFoldersService = KnowledgeFoldersService;
+class KnowledgeService {
+    http;
+    documents;
+    folders;
+    constructor(http) {
+        this.http = http;
+        this.documents = new KnowledgeDocumentsService(http);
+        this.folders = new KnowledgeFoldersService(http);
+    }
+    async search(input) {
+        const resp = await this.http.post('/knowledge/search', input);
+        return resp.data.items;
+    }
+}
+exports.KnowledgeService = KnowledgeService;

package/dist/services/programs.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { PagedResult, Program } from '../types';
+import { Course, PagedResult, Program } from '../types';
 export declare class ProgramsService {
     private readonly http;
     constructor(http: AxiosInstance);
@@ -9,4 +9,5 @@ export declare class ProgramsService {
     }): Promise<PagedResult<Program>>;
     get(id: string): Promise<Program | null>;
     batchGet(ids: string[]): Promise<Program[]>;
+    listCourses(id: string): Promise<Course[]>;
 }

package/dist/services/programs.js

@@ -18,5 +18,9 @@ class ProgramsService {
         const resp = await this.http.post('/programs/batch', { ids });
         return resp.data.items;
     }
+    async listCourses(id) {
+        const resp = await this.http.get(`/programs/${id}/courses`);
+        return resp.data.items;
+    }
 }
 exports.ProgramsService = ProgramsService;

package/dist/services/roles.d.ts

@@ -1,9 +1,14 @@
 import { AxiosInstance } from 'axios';
-import { Role } from '../types';
+import { Role, RolesCreateInput, RolesUpdateInput, RolesUpdateLevelsInput, Level } from '../types';
 export declare class RolesService {
     private readonly http;
-    constructor(http: AxiosInstance);
+    private readonly assertMutationAllowed;
+    constructor(http: AxiosInstance, assertMutationAllowed: (operation: string) => void);
     list(): Promise<Role[]>;
     get(id: string): Promise<Role | null>;
     batchGet(ids: string[]): Promise<Role[]>;
+    create(input: RolesCreateInput): Promise<Role | null>;
+    update(input: RolesUpdateInput): Promise<Role | null>;
+    delete(roleId: string): Promise<void>;
+    updateLevels(input: RolesUpdateLevelsInput): Promise<Level[]>;
 }

package/dist/services/roles.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RolesService = void 0;
 class RolesService {
     http;
-    constructor(http) {
+    assertMutationAllowed;
+    constructor(http, assertMutationAllowed) {
         this.http = http;
+        this.assertMutationAllowed = assertMutationAllowed;
     }
     async list() {
         const resp = await this.http.get('/roles');
@@ -18,5 +20,24 @@ class RolesService {
         const resp = await this.http.post('/roles/batch', { ids });
         return resp.data.items;
     }
+    async create(input) {
+        this.assertMutationAllowed('roles.create');
+        const resp = await this.http.post('/roles', input);
+        return resp.data.item;
+    }
+    async update(input) {
+        this.assertMutationAllowed('roles.update');
+        const resp = await this.http.patch(`/roles/${input.roleId}`, { label: input.label });
+        return resp.data.item;
+    }
+    async delete(roleId) {
+        this.assertMutationAllowed('roles.delete');
+        await this.http.delete(`/roles/${roleId}`);
+    }
+    async updateLevels(input) {
+        this.assertMutationAllowed('roles.updateLevels');
+        const resp = await this.http.put(`/roles/${input.roleId}/levels`, { levels: input.levels });
+        return resp.data.items;
+    }
 }
 exports.RolesService = RolesService;

package/dist/types.d.ts

@@ -18,13 +18,6 @@ export interface Organization {
 }
 export interface OrganizationDetails {
     organization: Organization | null;
-    stats: {
-        members: number;
-        managers: number;
-        roles: number;
-        levels: number;
-        competencies: number;
-    };
 }
 export interface OrganizationUpdateInput {
     name?: string;
@@ -40,7 +33,6 @@ export interface Member {
     managerUid: string | null;
     roleIds: string[];
     createdAt: string;
-    activatedAt: string | null;
     phoneNumber: string | null;
 }
 export interface MembersListQuery extends PaginationQuery {
@@ -86,6 +78,21 @@ export interface Role {
     createdAt: string;
     updatedAt: string;
 }
+export interface RolesCreateInput {
+    label: string;
+}
+export interface RolesUpdateInput {
+    roleId: string;
+    label?: string;
+}
+export interface RoleLevelInput {
+    id?: string;
+    name: string;
+}
+export interface RolesUpdateLevelsInput {
+    roleId: string;
+    levels: RoleLevelInput[];
+}
 export interface Level {
     id: string;
     roleId: string;
@@ -105,12 +112,32 @@ export interface LevelsListQuery extends PaginationQuery {
 export interface Competency {
     id: string;
     name: string;
+    description: string;
     creatorUid: string;
     createdAt: string;
     settings?: {
         managerOnlyEndorsement: boolean;
     };
 }
+export interface CompetenciesCreateInput {
+    name: string;
+    description?: string;
+    roleId: string;
+    levelIds: string[];
+    settings?: {
+        managerOnlyEndorsement?: boolean;
+    };
+}
+export interface CompetenciesUpdateInput {
+    competencyId: string;
+    name?: string;
+    description?: string;
+    roleId?: string;
+    levelIds?: string[];
+    settings?: {
+        managerOnlyEndorsement?: boolean;
+    };
+}
 export interface CompetenciesListQuery extends PaginationQuery {
     roleId: string;
     levelId: string;
@@ -122,6 +149,88 @@ export interface Course {
     creatorUid: string;
     createdAt: string;
 }
+export type DueDateType = 'fixed' | 'relative';
+export interface AssignmentDueConfig {
+    type: DueDateType;
+    fixedDate?: string;
+    timezone?: string;
+    relativeDays?: number;
+}
+export interface AssignedUser {
+    email: string;
+    userId: string;
+    assigned: boolean;
+}
+export interface CoursesAssignToUsersInput {
+    courseId: string;
+    userIds: string[];
+    dueDateConfig?: AssignmentDueConfig;
+}
+export interface CoursesAssignToGroupsInput {
+    courseId: string;
+    groupIds: string[];
+    dueDateConfig?: AssignmentDueConfig;
+}
+export interface CoursesUnassignFromUserInput {
+    courseId: string;
+    userId: string;
+}
+export interface CoursesUnassignFromGroupInput {
+    courseId: string;
+    groupId: string;
+}
+export interface KnowledgeSearchInput {
+    query: string;
+    folderId?: string;
+    size?: number;
+}
+export interface KnowledgeSearchHit {
+    id: string;
+    type: string;
+    text: string;
+    documentId?: string | null;
+    courseId?: string | null;
+    blockId?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface KnowledgeDocument {
+    id: string;
+    name: string;
+    uid: string;
+    orgId: string;
+    parentId: string;
+    parentType: string;
+    status: string;
+    extFileId: string | null;
+    contentType: string | null;
+    originalContentLength: number;
+    contentLength: number;
+    downloadable: boolean;
+    folderId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeDocumentsListQuery extends PaginationQuery {
+    folderId?: string;
+    name?: string;
+    includePackFiles?: boolean;
+}
+export interface GetDocumentTranscriptResponse {
+    content: string;
+}
+export interface KnowledgeFolder {
+    id: string;
+    orgId: string;
+    name: string;
+    parentId: string | null;
+    createdBy: string;
+    children?: KnowledgeFolder[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface KnowledgeFoldersListQuery {
+    parentId?: string;
+}
 export interface Group {
     id: string;
     name: string;
@@ -134,14 +243,32 @@ export interface GroupMember {
     addedByUid: string;
     addedAt: string;
 }
+export interface GroupsCreateInput {
+    name: string;
+    userIds?: string[];
+}
+export interface GroupsCreateResult {
+    group: Group;
+    assignedUsers: AssignedUser[];
+}
+export interface GroupsUpdateNameInput {
+    groupId: string;
+    name: string;
+}
+export interface GroupsAddMembersInput {
+    groupId: string;
+    userIds: string[];
+}
+export interface GroupsRemoveMemberInput {
+    groupId: string;
+    userId: string;
+}
 export interface Program {
     id: string;
     name: string;
+    description: string;
     creatorUid: string;
     createdAt: string;
-    settings?: {
-        managerOnlyEndorsement: boolean;
-    };
 }
 export interface Progress {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totoday/quinn-sdk",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [