whio-api-sdk 1.0.0

package/src/index.ts

@@ -0,0 +1,101 @@
+import { title } from 'process';
+import { ApiSDK } from './sdk';
+import { LoginCredentials, User, SDKConfig } from './types';
+
+const keepAlive = setInterval(() => {}, 1000);
+
+class storage {
+  constructor() {
+    console.log("Storage initialized");
+  }
+
+  private items: { [key: string]: string } = {};
+
+  public getItem(key: string): string | null | Promise<string | null> {
+    return this.items[key] || null;
+  }
+
+  public setItem(key: string, value: string): void | Promise<void> {
+    this.items[key] = value;
+  }
+
+  public removeItem(key: string): void | Promise<void> {
+    delete this.items[key];
+  }
+
+}
+
+const config: SDKConfig = {
+  baseUrl: 'http://localhost:3000',
+  storage: new storage(),
+};
+
+const loginCredentials: LoginCredentials = {
+  email: "rimu.boddy@make.nz",
+  password: "cbr400rr",
+}
+
+const sdk = new ApiSDK(config);
+async function main() {
+  await sdk.login(loginCredentials);
+  const user: User | null = sdk.getCurrentUser();
+  const newUser: User = await sdk.createEditorUser(
+    "Rimu",
+    "Rimu",
+    "chiscs2snw2@bread.com",
+    "cbr400rr",
+  );
+  
+  const team = await sdk.createTeam(
+    "best team ever",
+    "this is the best team ever",
+  );
+
+  console.log(team);
+
+  const assignRes = await sdk.addUserToTeam(team.id, newUser.id, "admin");
+
+  const template = await sdk.createTemplate(
+    "Test Template",
+    "This is a test template",
+  );
+  
+  const updatedTemplate = await sdk.updateTemplate(
+      "Updated Template",
+      "This is an updated test template",
+      template.id,
+  );
+
+  const userTemplate = await sdk.createUserTemplate(
+    "User Template",
+    "This is a user template",
+    template.id,
+  );
+
+  const updatedUserTemplate = await sdk.updateUserTemplate(
+    "User templated updated",
+    "This is an updated user template",
+    userTemplate.id,
+  );
+
+  //console.log("Usertemplate", userTemplate);
+  //console.log("Updated User Template", updatedUserTemplate);
+
+  const templates = await sdk.getTemplates();
+  const userTemplates = await sdk.getUserTemplates();
+  
+  
+  
+}
+
+main().catch((error) => {
+  console.error("Error:", error);
+});
+
+//make sure no exit
+
+
+
+
+  
+

package/src/sdk.ts

@@ -0,0 +1,353 @@
+// sdk.ts
+import {
+  LoginResponse,
+  LoginCredentials,
+  SDKConfig,
+  User,
+  AssignTeamRoleDto,
+  CreateTeamDto,
+  UpdateTeamDto,
+  CreateTemplateDto,
+  UpdateTemplateDto,
+  GenerateTranscriptionSummaryDto,
+  UpdateTranscriptionSummaryDto,
+  AssignOrganizationRoleDto,
+  CreateUserTemplateDto,
+  UpdateUserTemplateDto,
+  CreateUserDto,
+  UpdateUserDto,
+  OrganizationRoleType,
+  Organization,
+  TemplateCategory,
+  Template,
+  Team,
+  UserTemplate,
+  TranscriptionSummary,
+} from './types';
+import urls from './urls';
+import jwtDecode from 'jwt-decode';
+
+export class ApiSDK {
+  private baseUrl: string;
+  private storage: SDKConfig['storage'];
+  private accessToken: string | null = null;
+  private refreshToken: string | null = null;
+  private user: User | null = null;
+
+  constructor(config: SDKConfig = {}) {
+    this.baseUrl = config.baseUrl || '/api';
+    this.storage = config.storage || {
+      getItem: (key) => localStorage.getItem(key),
+      setItem: (key, value) => localStorage.setItem(key, value),
+      removeItem: (key) => localStorage.removeItem(key),
+    };
+
+    this.initialize();
+  }
+
+  private async initialize() {
+    this.accessToken = await this.storage!.getItem('access_token');
+    const userString = await this.storage!.getItem('user');
+    this.user = userString ? JSON.parse(userString) : null;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    method: string = 'GET',
+    body?: any,
+    headers: Record<string, string> = {}
+  ): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`;
+    const defaultHeaders: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'ngrok-skip-browser-warning': 'true'
+    };
+
+    if (this.accessToken) {
+      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers: { ...defaultHeaders, ...headers },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(
+        errorData.message || `Request failed with status ${response.status}`
+      );
+    }
+
+    return response.json();
+  }
+
+  public async login(credentials: LoginCredentials): Promise<LoginResponse> {
+    try {
+      const response = await this.request<LoginResponse>(
+        '/auth/login',
+        'POST',
+        credentials
+      );
+      this.accessToken = response.access_token;
+      this.refreshToken = response.referesh_token;
+      
+      this.user = response.user;
+
+      await this.storage!.setItem('access_token', response.access_token);
+      await this.storage!.setItem('user', JSON.stringify(response.user));
+
+      return response;
+    } catch (error) {
+      await this.clearAuth();
+      throw error;
+    }
+  }
+
+  public async logout(): Promise<void> {
+    try {
+      await this.request('/auth/logout', 'POST');
+    } finally {
+      await this.clearAuth();
+    }
+  }
+
+  private async clearAuth(): Promise<void> {
+    this.accessToken = null;
+    this.user = null;
+    await this.storage!.removeItem('access_token');
+    await this.storage!.removeItem('user');
+  }
+
+  public isAuthenticated(): boolean {
+    return !!this.accessToken;
+  }
+
+  public getCurrentUser(): User | null {
+    return this.user;
+  }
+
+  public getAccessToken(): string | null {
+    return this.accessToken;
+  }
+
+  public getRefreshToken(): string | null {
+    return this.refreshToken;
+  }
+
+  private async createUser(
+    firstName: string, lastName: string,
+    email: string, password: string): Promise<User> {
+
+    const createUserDto: CreateUserDto = {
+      firstName,
+      lastName,
+      email,
+      password,
+      organizationId: this.user?.organizationId,
+    };
+
+    const user = await this.request<User>(
+      urls.users,
+      'POST',
+      createUserDto
+    );
+    return user;
+  }
+
+  private async assignRoleToUser(userId: string, roleName: OrganizationRoleType): Promise<User> {
+    const organization = await this.request<Organization>(
+      `${urls.organizations}/${this.user?.organizationId}`,
+      'GET'
+    );
+    const orgRoleEditor = organization.roles!.find(
+      r => r.name === roleName);
+    const assignRoleDto:AssignOrganizationRoleDto = {
+      userId: userId,
+      organizationRoleId: orgRoleEditor!.id,
+    };
+    this.request(urls.userOrganizationRoles, 'POST', assignRoleDto);
+    const userWithOrgRole = await this.request<User>(
+      `${urls.user}/${userId}`,
+      'GET'
+    );
+    return userWithOrgRole;
+  }
+
+  public async assignEditorToRoleToUser(userId: string): Promise<User> {
+    return this.assignRoleToUser(userId, OrganizationRoleType.EDITOR);
+  }
+
+  public async assignAdminToRoleToUser(userId: string): Promise<User> {
+    return this.assignRoleToUser(userId, OrganizationRoleType.ADMIN);
+  }
+
+  public async assignDisabledToRoleToUser(userId: string): Promise<User> {
+    return this.assignRoleToUser(userId, OrganizationRoleType.DISABLED);
+  }
+
+  public async createEditorUser(firstName: string, lastName: string,
+    email: string, password: string): Promise<User> {
+    const user = await this.createUser(firstName, lastName, email, password);
+    const userWithOrgRole = await this.assignEditorToRoleToUser(user.id);
+    return userWithOrgRole;
+  }
+
+  public async createAdminUser(firstName: string, lastName: string,
+    email: string, password: string): Promise<User> {
+    const user = await this.createUser(firstName, lastName, email, password);
+    const userWithOrgRole = await this.assignAdminToRoleToUser(user.id);
+    return userWithOrgRole;
+  }
+
+  public async createDisabledUser(firstName: string, lastName: string,
+    email: string, password: string): Promise<User> {
+    const user = await this.createUser(firstName, lastName, email, password);
+    const userWithOrgRole = await this.assignDisabledToRoleToUser(user.id);
+    return userWithOrgRole;
+  }
+
+  public async createTeam(name: string, description: string): Promise<Team> {
+    const teamDto: CreateTeamDto = {
+      name,
+      description,
+      organizationId: this.user!.organizationId,
+    };
+    return this.request(urls.teams, 'POST', teamDto);
+  }
+
+  public async updateTeam(id: string, name: string, description: string): Promise<any> {
+    const teamDto: UpdateTeamDto = {
+      name,
+      description,
+    };
+    return this.request(`${urls.teams}/${id}`, 'PUT', teamDto);
+  }
+
+  public async addUserToTeam(teamId: string, userId: string, roleName: string): Promise<any> {
+    const assignRoleDto: AssignTeamRoleDto = {
+      teamId,
+      userId,
+      name: roleName,
+    };
+    return this.request(urls.teamRoles, 'POST', assignRoleDto);
+  }
+
+  public async removeUserFromTeam(teamId: string, userId: string): Promise<any> {
+    const url = `${urls.teamRoles}/user/${userId}/team/${teamId}`;
+    return this.request(urls.teamRoles, 'DELETE');
+  }
+  //unsure how we are going to deal with template categories just yet
+  public async createTemplate(title: string, content: string): Promise<any> {
+    const templateCategories = await this.request<TemplateCategory[]>(
+      urls.templateCatedories,
+      'GET'
+    );
+    const createTemplateDto: CreateTemplateDto = {
+      title,
+      content,
+      isGlobal: false,
+      categoryId: templateCategories[0]!.id,
+      createdById: this.user!.id,
+      organizationId: this.user!.organizationId,
+    };
+    return this.request(urls.templates, 'POST', createTemplateDto);
+  }
+
+  public async createUserTemplate(
+    title: string, content: string, originalTemplateId: string | undefined): Promise<UserTemplate> {
+      const createUserTemplateDto: CreateUserTemplateDto = {
+        title,
+        content,
+        originalTemplateId,
+        userId: this.user!.id,
+      };
+      return this.request(urls.userTemplates, 'POST', createUserTemplateDto);
+  }
+
+  public async updateTemplate(
+    title: string, content: string, id: string): Promise<Template> {
+      const templateDto: UpdateTemplateDto = {
+        title,
+        content,
+        isGlobal: false,
+        organizationId: this.user!.organizationId,
+      };
+      return this.request<Template>(
+        `${urls.templates}/${id}`,
+        'PATCH',
+        templateDto,
+      );
+  }
+
+  public async updateUserTemplate(
+    title: string, content: string, id: string): Promise<UserTemplate> {
+      const userTemplateDto: UpdateUserTemplateDto = {
+        title,
+        content,
+      };
+      return this.request<UserTemplate>(
+        `${urls.userTemplates}/${id}`,
+        'PATCH',
+        userTemplateDto,
+      );
+  }
+
+  public async getTemplates(): Promise<Template[]> {
+    return this.request<Template[]>(urls.templates, 'GET');
+  }
+
+  public async getUserTemplates(): Promise<UserTemplate[]> {
+    const url = `${urls.userTemplates}/user/${this.user!.id}`;
+    return this.request<UserTemplate[]>(url, 'GET');
+  }
+
+  public async generateTranscriptionSummary(
+    transcript: string, templateId: string): Promise<TranscriptionSummary> {
+    const generateSummaryDto: GenerateTranscriptionSummaryDto = {
+      transcript,
+      templateId,
+      userId: this.user!.id,
+      fromUserTemplate: false,
+    };
+    const transcriptionSummary:TranscriptionSummary = await this.request(
+      urls.transcriptionSummary,
+      'POST',
+      generateSummaryDto
+    );
+    return transcriptionSummary;
+  }
+
+  public async generateTranscriptionSummaryFromUserTemplate(
+    transcript: string, userTemplateId: string): Promise<TranscriptionSummary> {
+    const generateSummaryDto: GenerateTranscriptionSummaryDto = {
+      transcript,
+      templateId: userTemplateId,
+      userId: this.user!.id,
+      fromUserTemplate: true,
+    };
+    const transcriptionSummary: TranscriptionSummary = await this.request(
+      urls.transcriptionSummary,
+      'POST',
+      generateSummaryDto
+    );
+    return transcriptionSummary;
+  }
+
+  public async updateTranscriptionSummary(
+    id: string, content: string): Promise<TranscriptionSummary> {
+      const updateSummaryDto: UpdateTranscriptionSummaryDto = {
+        content,
+      };
+      return this.request<TranscriptionSummary>(
+        `${urls.transcriptionSummary}/${id}`,
+        'PATCH',
+        updateSummaryDto,
+      );
+  }
+
+  
+
+
+}

package/src/types.ts

@@ -0,0 +1,278 @@
+// types.ts
+
+// Role type
+export interface Role {
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// Organization Role type
+export interface OrganizationRole {
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+  organizationId: string;
+}
+
+// User Role association
+export interface UserRole {
+  userId: string;
+  roleId: string;
+  createdAt: string;
+  role: Role;
+}
+
+// User Organization Role association
+export interface UserOrganizationRole {
+  userId: string;
+  organizationRoleId: string;
+  createdAt: string;
+  organizationRole: OrganizationRole;
+}
+
+// Organization type
+export interface Organization {
+  id: string;
+  name: string;
+  description: string;
+  createdAt: string;
+  updatedAt: string;
+
+  users?: User[];
+  roles?: OrganizationRole[];
+}
+
+// User type
+export interface User {
+  id: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  createdAt: string;
+  updatedAt: string;
+  organizationId: string;
+  organization: Organization;
+  roles: UserRole[];
+  organizationRoles: UserOrganizationRole[];
+}
+
+// Login response type
+export interface LoginResponse {
+  access_token: string;
+  referesh_token: string;
+  user: User;
+}
+
+// Login credentials type
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+// SDK configuration type
+export interface SDKConfig {
+  baseUrl?: string;
+  storage?: {
+    getItem: (key: string) => string | null | Promise<string | null>;
+    setItem: (key: string, value: string) => void | Promise<void>;
+    removeItem: (key: string) => void | Promise<void>;
+  };
+}
+
+// Team Role assignment DTO
+export interface AssignTeamRoleDto {
+  userId: string;
+  teamId: string;
+  name: string;
+}
+
+// Team creation DTO
+export interface CreateTeamDto {
+  name: string;
+  description?: string;
+  organizationId: string;
+}
+
+// Team update DTO
+export interface UpdateTeamDto {
+  name?: string;
+  description?: string;
+  organizationId?: string;
+}
+
+// Template creation DTO
+export interface CreateTemplateDto {
+  title: string;
+  content: string;
+  isGlobal?: boolean;
+  organizationId: string;
+  categoryId: string;
+  createdById: string;
+}
+
+// Template update DTO
+export interface UpdateTemplateDto {
+  title?: string;
+  content?: string;
+  isGlobal?: boolean;
+  organizationId: string;
+  categoryId?: string;
+}
+
+// Transcription summary generation DTO
+export interface GenerateTranscriptionSummaryDto {
+  transcript?: string;
+  templateId: string;
+  userId?: string;
+  fromUserTemplate?: boolean;
+}
+
+// Transcription summary update DTO
+export interface UpdateTranscriptionSummaryDto {
+  anonymisedTranscript?: string;
+  content?: string;
+  metadata?: Record<string, any>;
+  templateId?: string;
+}
+
+// Organization role assignment DTO
+export interface AssignOrganizationRoleDto {
+  userId: string;
+  organizationRoleId: string;
+}
+
+// User template creation DTO
+export interface CreateUserTemplateDto {
+  title: string;
+  content: string;
+  userId: string;
+  originalTemplateId?: string;
+}
+
+// User template update DTO
+export interface UpdateUserTemplateDto {
+  title?: string;
+  content?: string;
+}
+
+// User creation DTO
+export interface CreateUserDto {
+  email: string;
+  password: string;
+  firstName?: string;
+  lastName?: string;
+  organizationId?: string;
+}
+
+// User update DTO
+export interface UpdateUserDto {
+  email?: string;
+  password?: string;
+  firstName?: string;
+  lastName?: string;
+  organizationId?: string;
+}
+
+export enum OrganizationRoleType {
+  ADMIN = 'ADMIN',
+  EDITOR = 'EDITOR',
+  DISABLED = 'DISABLED',
+}
+
+export interface AdminUser {
+  id: string;
+  email: string;
+  password_hash: string;
+  role: string;
+  created_at: Date;
+}
+
+export interface TemplateCategory {
+  id: string;
+  name: string;
+}
+
+export interface Template {
+  id: string;
+  title: string;
+  content: string;
+  createdAt: string;
+  updatesAt: string;
+  isGlobal: boolean;
+  organizationId?: string;
+  categoryId: string;
+  createdById: string;
+
+  organization?: Organization;
+  category?: TemplateCategory;
+  createdBy?: User;
+  userTemplates?: UserTemplate[];
+  transcriptionSummaries?: TranscriptionSummary[];
+  teamTemplates?: TeamTemplate[];
+}
+
+export interface UserTemplate {
+  id: string;
+  title: string;
+  content: string;
+  createdAt: string;
+  updatesAt: string;
+  userId: string;
+  originalTemplateId?: string;
+
+  user?: User;
+  originalTemplate?: Template;
+}
+
+export interface TranscriptionSummary {
+  id: string;
+  anonymisedTranscript?: string;
+  content: string;
+  metadata?: any;
+  createdAt: string;
+  updatesAt: string;
+  templateId: string;
+  userId: string;
+
+  template?: Template;
+  user?: User;
+}
+
+export interface TeamTemplate {
+  teamId: string;
+  templateId: string;
+  createdAt: string;
+
+  team?: Team;
+  template?: Template;
+}
+
+export interface TeamRole {
+  id: string;
+  name: string;
+  createdAt: string;
+  updatesAt: string;
+  userId: string;
+  teamId: string;
+
+  user?: User;
+  team?: Team;
+}
+
+export interface Team {
+  id: string;
+  name: string;
+  description?: string;
+  createdAt: string;
+  updatesAt: string;
+  organizationId: string;
+
+  organization?: Organization;
+  teamRoles?: TeamRole[];
+  teamTemplates?: TeamTemplate[];
+}
+
+