Skip to content

TaskView is a self-hosted project and task management platform focused on clarity, ownership, and control. TaskView is built for teams that want a transparent, self-hosted alternative to SaaS task managers.

feat: mcp and orgs

Nikolai Giman4ec6b143cab6
diff --git a/api/package.json b/api/package.json
index de0aa43..9468683 100644
--- a/api/package.json
+++ b/api/package.json
@@ -48,7 +48,7 @@
"@types/passport-google-oauth20": "^2.0.17",
"@vitejs/plugin-legacy": "^5.4.2",
"@vitejs/plugin-vue": "^5.1.4",
- "axios": "^1.7.7",
+ "axios": "1.13.5",
"bcryptjs": "^2.4.3",
"cookie-parser": "^1.4.7",
"cors": "^2.8.5",
diff --git a/api/src/core/AppUser.ts b/api/src/core/AppUser.ts
index 5e305f4..3ace75d 100644
--- a/api/src/core/AppUser.ts
+++ b/api/src/core/AppUser.ts
@@ -9,6 +9,7 @@ import { StartManager } from '../tv-modules/start/StartManager';
import { TagsManager } from '../tv-modules/tags/TagsManager';
import { IntegrationsManager } from '../tv-modules/integrations/IntegrationsManager';
import { NotificationsManager } from '../tv-modules/notifications/NotificationsManager';
+import { OrganizationManager } from '../tv-modules/organizations/OrganizationManager';
import { TasksManager } from '../tv-modules/tasks/TasksManager';
import type { UserDbRecord, UserJwtPayload } from '../types/auth.types';
import { GoalPermissionsFetcher } from './GoalPermissionsFetcher';
@@ -33,6 +34,7 @@ export class AppUser {
public readonly graphManager: GraphManager;
public readonly integrationsManager: IntegrationsManager;
public readonly notificationsManager: NotificationsManager;
+ public readonly organizationManager: OrganizationManager;
constructor(userData?: UserJwtPayload) {
this.userData = userData;
@@ -49,6 +51,7 @@ export class AppUser {
this.graphManager = new GraphManager(this);
this.integrationsManager = new IntegrationsManager(this);
this.notificationsManager = new NotificationsManager(this);
+ this.organizationManager = new OrganizationManager(this);
}
getTokenId(): number | undefined {
diff --git a/api/src/middlewares/is-org-member.ts b/api/src/middlewares/is-org-member.ts
new file mode 100644
index 0000000..4edaaee
--- /dev/null
+++ b/api/src/middlewares/is-org-member.ts
@@ -0,0 +1,15 @@
+import type { NextFunction, Request, Response } from 'express'
+
+export const IsOrgMemberIfProvided = async (req: Request, res: Response, next: NextFunction) => {
+ const organizationId = Number(
+ req.query.organizationId || req.body.organizationId || req.params.organizationId
+ )
+
+ if (!organizationId) return next()
+
+ const member = await req.appUser.organizationManager.getCurrentUserMember(organizationId)
+
+ if (!member) return res.status(403).end()
+
+ next()
+}
diff --git a/api/src/migrations/taskview/migrate.json b/api/src/migrations/taskview/migrate.json
index 8716898..61f7ef7 100644
--- a/api/src/migrations/taskview/migrate.json
+++ b/api/src/migrations/taskview/migrate.json
@@ -429,5 +429,19 @@
"Remove JWT storage from user_tokens, add session metadata (device_name, user_agent, last_used_at)",
"Add trigger to remove user from task assignees when removed from project collaboration"
]
+ },
+ "35": {
+ "version": "1.32.0",
+ "name": "Release 1.32.0",
+ "releaseDate": "20260404",
+ "scripts": [
+ "/1.32.0/0.1.32.0.sql",
+ "/1.32.0/1.migrate-organizations.sql"
+ ],
+ "description": [
+ "Added organizations and organization_members tables",
+ "Migrate existing users to personal workspaces",
+ "Added organization_id column to goals"
+ ]
}
}
\ No newline at end of file
diff --git a/api/src/migrations/taskview/sql/1.32.0/0.1.32.0.sql b/api/src/migrations/taskview/sql/1.32.0/0.1.32.0.sql
new file mode 100644
index 0000000..cd868b7
--- /dev/null
+++ b/api/src/migrations/taskview/sql/1.32.0/0.1.32.0.sql
@@ -0,0 +1,50 @@
+-- Organizations
+CREATE TABLE IF NOT EXISTS tv_auth.organizations (
+ id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+ name VARCHAR NOT NULL,
+ slug VARCHAR NOT NULL UNIQUE,
+ owner_id INTEGER NOT NULL REFERENCES tv_auth.users(id) ON DELETE CASCADE,
+ logo_url VARCHAR,
+ is_personal INTEGER NOT NULL DEFAULT 0,
+ plan VARCHAR NOT NULL DEFAULT 'free',
+ created_at TIMESTAMP DEFAULT NOW(),
+ updated_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_organizations_owner_id ON tv_auth.organizations(owner_id);
+CREATE INDEX IF NOT EXISTS idx_organizations_slug ON tv_auth.organizations(slug);
+
+-- Organization members (by email, not user_id)
+CREATE TABLE IF NOT EXISTS tv_auth.organization_members (
+ id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+ organization_id INTEGER NOT NULL REFERENCES tv_auth.organizations(id) ON DELETE CASCADE,
+ email VARCHAR NOT NULL,
+ role VARCHAR NOT NULL DEFAULT 'member',
+ invited_by INTEGER REFERENCES tv_auth.users(id) ON DELETE SET NULL,
+ created_at TIMESTAMP DEFAULT NOW(),
+ UNIQUE(organization_id, email)
+);
+
+CREATE INDEX IF NOT EXISTS idx_org_members_organization_id ON tv_auth.organization_members(organization_id);
+CREATE INDEX IF NOT EXISTS idx_org_members_email ON tv_auth.organization_members(email);
+
+-- Add organization_id to goals (nullable for migration, will be set NOT NULL after data migration)
+ALTER TABLE tasks.goals ADD COLUMN IF NOT EXISTS organization_id INTEGER;
+
+DO $$
+BEGIN
+ IF NOT EXISTS (
+ SELECT 1 FROM information_schema.table_constraints
+ WHERE constraint_name = 'goals_organization_id_fkey'
+ AND table_schema = 'tasks'
+ AND table_name = 'goals'
+ ) THEN
+ ALTER TABLE tasks.goals
+ ADD CONSTRAINT goals_organization_id_fkey
+ FOREIGN KEY (organization_id)
+ REFERENCES tv_auth.organizations(id)
+ ON DELETE CASCADE;
+ END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS idx_goals_organization_id ON tasks.goals(organization_id);
diff --git a/api/src/migrations/taskview/sql/1.32.0/1.migrate-organizations.sql b/api/src/migrations/taskview/sql/1.32.0/1.migrate-organizations.sql
new file mode 100644
index 0000000..5feea01
--- /dev/null
+++ b/api/src/migrations/taskview/sql/1.32.0/1.migrate-organizations.sql
@@ -0,0 +1,36 @@
+-- Step 1: Create personal organization for each user who owns goals
+INSERT INTO tv_auth.organizations (name, slug, owner_id, is_personal)
+SELECT
+ u.login || '''s workspace',
+ 'org-' || substr(md5(random()::text), 1, 8),
+ u.id,
+ 1
+FROM tv_auth.users u
+WHERE EXISTS (SELECT 1 FROM tasks.goals g WHERE g.owner = u.id)
+ON CONFLICT DO NOTHING;
+
+-- Step 2: Link goals to their owner's organization
+UPDATE tasks.goals g
+SET organization_id = o.id
+FROM tv_auth.organizations o
+WHERE g.owner = o.owner_id
+ AND g.organization_id IS NULL;
+
+-- Step 3: Add owner as org member with role 'owner' (by email)
+INSERT INTO tv_auth.organization_members (organization_id, email, role)
+SELECT o.id, u.email, 'owner'
+FROM tv_auth.organizations o
+JOIN tv_auth.users u ON u.id = o.owner_id
+ON CONFLICT (organization_id, email) DO NOTHING;
+
+-- Step 4: Add existing goal collaborators as org members (by email)
+INSERT INTO tv_auth.organization_members (organization_id, email, role)
+SELECT DISTINCT g.organization_id, cu.email, 'member'
+FROM collaboration.users_to_goals cutg
+JOIN collaboration.users cu ON cu.id = cutg.user_id
+JOIN tasks.goals g ON g.id = cutg.goal_id
+WHERE g.organization_id IS NOT NULL
+ON CONFLICT (organization_id, email) DO NOTHING;
+
+-- Step 5: Make organization_id NOT NULL
+ALTER TABLE tasks.goals ALTER COLUMN organization_id SET NOT NULL;
diff --git a/api/src/routes/index.ts b/api/src/routes/index.ts
index 134b03e..c536b54 100644
--- a/api/src/routes/index.ts
+++ b/api/src/routes/index.ts
@@ -13,6 +13,7 @@ import GoalListRoutes from '../tv-modules/lists/GoalListRoutes';
import StartRoutes from '../tv-modules/start/StartRoutes';
import TagsRouter from '../tv-modules/tags/TagsRouter';
import TasksRoutes from '../tv-modules/tasks/TasksRoutes';
+import OrganizationRoutes from '../tv-modules/organizations/OrganizationRoutes';
import type { Routable } from '../types/routable.type';
type RoutableConstructor = new (...args: any[]) => Routable;
@@ -33,6 +34,7 @@ const routes: Record<string, RoutableConstructor> = {
'/module/webhooks': WebhooksRoutes,
'/module/api-tokens': ApiTokensRoutes,
'/module/sessions': SessionsRoutes,
+ '/module/organizations': OrganizationRoutes,
};
export default routes;
diff --git a/api/src/tv-modules/auth/AuthController.ts b/api/src/tv-modules/auth/AuthController.ts
index 2b45b15..284354b 100644
--- a/api/src/tv-modules/auth/AuthController.ts
+++ b/api/src/tv-modules/auth/AuthController.ts
@@ -17,6 +17,7 @@ import { generateString, isEmail, time } from '../../utils/helpers';
import EnEmailTemplate from './mail/confirm-email-en';
import RuEmailTemplate from './mail/confirm-email-ru';
import type { ExternalAuthUser } from './strategies/external-auth.types';
+import { OrganizationRepository } from '../organizations/OrganizationRepository';
export default class AuthController {
private readonly jwtAlg: Algorithm = process.env.JWT_ALG as Algorithm;
@@ -24,6 +25,15 @@ export default class AuthController {
private readonly jwtRefreshExp: string = process.env.REFRESH_LIFE_TIME!;
private readonly refreshTokenCookieName: string = 'taskview-refresh';
+ private readonly orgRepository: OrganizationRepository = new OrganizationRepository();
+
+ private async createPersonalWorkspace(userId: number, email: string, login: string) {
+ const slug = `org-${crypto.randomUUID().slice(0, 8)}`
+ const org = await this.orgRepository.create({ name: `${login}'s workspace`, slug }, userId, true)
+ if (org) {
+ await this.orgRepository.addMember(org.id, email, 'owner')
+ }
+ }
comparePasswords(pwd: string, hash: string): Promise<boolean> {
return new Promise((resolve) => {
@@ -143,6 +153,7 @@ export default class AuthController {
return res.status(500).end();
}
+ await this.createPersonalWorkspace(id, email, login)
$logger.info(`[AuthController:sendLoginCode] user registered`);
}
@@ -207,6 +218,8 @@ export default class AuthController {
return res.status(500).send(`Can not register user`);
}
+ await this.createPersonalWorkspace(id, user.email, login)
+
userData = await req.appUser.authManager.repository.getUserByLogin(
user.email,
isEmail(user.email)
@@ -411,6 +424,8 @@ export default class AuthController {
return res.status(500).end();
}
+ await this.createPersonalWorkspace(id, email, login)
+
let emailTemplate: string = '';
let confirmEmailBody: string = '';
const acceptLanguage = req.headers['accept-language'];
diff --git a/api/src/tv-modules/collaboration-roles/CollaborationRolesRepository.ts b/api/src/tv-modules/collaboration-roles/CollaborationRolesRepository.ts
index fcab63b..cce79a6 100644
--- a/api/src/tv-modules/collaboration-roles/CollaborationRolesRepository.ts
+++ b/api/src/tv-modules/collaboration-roles/CollaborationRolesRepository.ts
@@ -192,4 +192,14 @@ export class CollaborationRolesRepository {
return result;
}
+
+ async assignAllPermissionsToRole(roleId: number, permissionIds: number[]): Promise<boolean> {
+ if (permissionIds.length === 0) return false
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .insert(CollaborationPermissionsToRoleSchema)
+ .values(permissionIds.map(permissionId => ({ roleId, permissionId })))
+ )
+ return !!result
+ }
}
diff --git a/api/src/tv-modules/collaboration/CollaborationController.ts b/api/src/tv-modules/collaboration/CollaborationController.ts
index ba25986..5dd3887 100644
--- a/api/src/tv-modules/collaboration/CollaborationController.ts
+++ b/api/src/tv-modules/collaboration/CollaborationController.ts
@@ -134,7 +134,8 @@ export class CollaborationController {
};
fetchAllUsersNew = async (req: Request, res: Response) => {
- const users = await req.appUser.collaborationManager.fetchAllUsersNew();
+ const organizationId = req.query.organizationId ? Number(req.query.organizationId) : undefined;
+ const users = await req.appUser.collaborationManager.fetchAllUsersNew(organizationId);
return res.tvJson(users);
};
diff --git a/api/src/tv-modules/collaboration/CollaborationManager.ts b/api/src/tv-modules/collaboration/CollaborationManager.ts
index 53feadd..7624b39 100644
--- a/api/src/tv-modules/collaboration/CollaborationManager.ts
+++ b/api/src/tv-modules/collaboration/CollaborationManager.ts
@@ -121,9 +121,19 @@ export class CollaborationManager {
}
async addUserNew(args: CollaborationArgAddUser): Promise<CollaborationUserWithRoles | null> {
+ const email = args.email.toLowerCase();
+
+ const goal = await this.user.goalsManager.goalsRepository.findGoalById(args.goalId);
+ if (goal && goal.organizationId) {
+ const member = await this.user.organizationManager.repository.getMemberByEmail(goal.organizationId, email);
+ if (!member) {
+ await this.user.organizationManager.repository.addMember(goal.organizationId, email, 'member');
+ }
+ }
+
const user = await this.repository.addUserForCollaborationNew({
...args,
- email: args.email.toLowerCase(),
+ email,
});
if (!user) return null;
@@ -145,15 +155,15 @@ export class CollaborationManager {
return await this.repository.toggleUserRolesNew(args);
}
- async fetchAllUsersNew(): Promise<CollaborationUserWithRoles[]> {
-
- const sharedGoals = await this.user.goalsManager.fetchSharedGoals();
+ async fetchAllUsersNew(organizationId?: number): Promise<CollaborationUserWithRoles[]> {
+
+ const sharedGoals = await this.user.goalsManager.fetchSharedGoals(organizationId);
const goalIds = sharedGoals
.filter((g) => g.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_ASSIGNED_USERS))
.map((g) => g.id);
- const ownGoals = await this.user.goalsManager.fetchAllOwnGoalsIds();
+ const ownGoals = await this.user.goalsManager.fetchAllOwnGoalsIds(organizationId);
goalIds.push(...ownGoals);
diff --git a/api/src/tv-modules/collaboration/CollaborationRoutes.ts b/api/src/tv-modules/collaboration/CollaborationRoutes.ts
index 30e6e05..b0391c2 100644
--- a/api/src/tv-modules/collaboration/CollaborationRoutes.ts
+++ b/api/src/tv-modules/collaboration/CollaborationRoutes.ts
@@ -1,6 +1,7 @@
import { Router } from 'express';
import type { Routable } from '../../types/routable.type';
import { IsLoggedIn } from '../auth/middlewares/is-logged-in';
+import { IsOrgMemberIfProvided } from '../../middlewares/is-org-member';
import { CollaborationController } from './CollaborationController';
import { CanAddUserCollaboration } from './middlewares/CanAddUserCollaboration';
import { CanDeleteUserCollaboration } from './middlewares/CanDeleteUserCollaboration';
@@ -50,7 +51,7 @@ export default class CollaborationRoutes implements Routable {
/**
* Fetch all users for collaboration
*/
- this.router.get('', [IsLoggedIn], this.collaborationController.fetchAllUsersNew);
+ this.router.get('', [IsLoggedIn, IsOrgMemberIfProvided], this.collaborationController.fetchAllUsersNew);
/**
* Fetch users for goal for collaboration
diff --git a/api/src/tv-modules/goals/GoalsController.ts b/api/src/tv-modules/goals/GoalsController.ts
index 48aa9d3..c7094a5 100644
--- a/api/src/tv-modules/goals/GoalsController.ts
+++ b/api/src/tv-modules/goals/GoalsController.ts
@@ -7,7 +7,7 @@ import {
UpdateGoalDbArgSchema,
} from '../../types/goal.type';
import { logError } from '../../utils/api';
-import { GoalsArkTypeAdd, GoalsArkTypeDelete, GoalsArkTypeUpdate } from './types';
+import { GoalsArkTypeAdd, GoalsArkTypeDelete, GoalsArkTypeFetch, GoalsArkTypeUpdate } from './types';
export default class GoalsController {
fetchGoals = async (req: Request, res: Response) => {
@@ -106,6 +106,10 @@ export default class GoalsController {
};
fetchGoalsNew = async (req: Request, res: Response) => {
- return res.tvJson(await req.appUser.goalsManager.fetchGoalsNew());
+ const out = GoalsArkTypeFetch(req.query);
+ if (out instanceof type.errors) {
+ return res.status(400).send(out.summary);
+ }
+ return res.tvJson(await req.appUser.goalsManager.fetchGoalsNew(out.organizationId));
};
}
diff --git a/api/src/tv-modules/goals/GoalsManager.ts b/api/src/tv-modules/goals/GoalsManager.ts
index 0dd4a24..c138a2b 100644
--- a/api/src/tv-modules/goals/GoalsManager.ts
+++ b/api/src/tv-modules/goals/GoalsManager.ts
@@ -69,8 +69,8 @@ export default class GoalsManager {
}
/** @deprecated use fetchSharedGoalsForUser from GoalsRepository instead */
- async fetchSharedGoals() {
- const goals = await this.goalsRepository.fetchSharedGoals(this.user);
+ async fetchSharedGoals(organizationId?: number) {
+ const goals = await this.goalsRepository.fetchSharedGoals(this.user, organizationId);
return await Promise.all(
goals.map(
async (g) =>
@@ -91,8 +91,8 @@ export default class GoalsManager {
return await this.goalsRepository.updateArchive(goalId, archive);
}
- async fetchAllOwnGoalsIds() {
- return await this.goalsRepository.fetchAllOwnGoalsIds(this.user);
+ async fetchAllOwnGoalsIds(organizationId?: number) {
+ return await this.goalsRepository.fetchAllOwnGoalsIds(this.user, organizationId);
}
async createGoal(goalData: GoalsArgAdd): Promise<GoalsItemForClientWithPermissions | false> {
@@ -100,10 +100,28 @@ export default class GoalsManager {
if (!isNotNullable(userId)) {
return false;
}
- const goal = await this.goalsRepository.createGoal(goalData, userId);
+
+ let ownerId = userId;
+ if (goalData.organizationId) {
+ const org = await this.user.organizationManager.getById(goalData.organizationId);
+ if (!org) return false;
+ ownerId = org.ownerId;
+ } else {
+ const personalOrgId = await this.user.organizationManager.getPersonalOrgId();
+ if (!personalOrgId) return false;
+ goalData = { ...goalData, organizationId: personalOrgId };
+ }
+
+ const creatorId = goalData.organizationId && ownerId !== userId ? userId : undefined;
+ const goal = await this.goalsRepository.createGoal(goalData, ownerId, creatorId);
if (!goal) {
return false;
}
+
+ if (creatorId) {
+ await this.addCreatorAsCollaboratorWithFullAccess(goal.id);
+ }
+
return {
...goal,
permissions: (
@@ -138,9 +156,9 @@ export default class GoalsManager {
return await this.goalsRepository.deleteGoalNew(goalData);
}
- async fetchGoalsNew(): Promise<GoalsItemForClientWithPermissions[]> {
- const sharedGoals = await this.goalsRepository.fetchSharedGoalsForUser(this.user!);
- const ownGoals = await this.goalsRepository.fetchGoalsNew(this.user.getUserData()?.id!);
+ async fetchGoalsNew(organizationId?: number): Promise<GoalsItemForClientWithPermissions[]> {
+ const sharedGoals = await this.goalsRepository.fetchSharedGoalsForUser(this.user!, organizationId);
+ const ownGoals = await this.goalsRepository.fetchGoalsNew(this.user.getUserData()?.id!, organizationId);
const allowedGoalIds = this.user.getAllowedGoalIds();
const filterByAllowed = allowedGoalIds && allowedGoalIds.length > 0;
@@ -181,4 +199,26 @@ export default class GoalsManager {
return [...ownGoalsWithPermissions, ...sharedGoalsWithPermissions];
}
+
+ private async addCreatorAsCollaboratorWithFullAccess(goalId: number) {
+ const email = this.user.getUserData()?.email
+ if (!email) return
+
+ const collabUser = await this.user.collaborationManager.addUserNew({ goalId, email })
+ if (!collabUser) return
+
+ const role = await this.user.collaborationRolesManager.repository.addRoleNew('TvOrgAdmin', goalId)
+ if (!role) return
+
+ const allPermissions = await this.user.collaborationRolesManager.repository.fetchAllAvailablePermissionsNew()
+ if (allPermissions.length > 0) {
+ await this.user.collaborationRolesManager.repository.assignAllPermissionsToRole(role.id, allPermissions.map(p => p.id))
+ }
+
+ await this.user.collaborationManager.repository.toggleUserRolesNew({
+ goalId,
+ userId: collabUser.id,
+ roles: [role.id],
+ })
+ }
}
diff --git a/api/src/tv-modules/goals/GoalsRepository.ts b/api/src/tv-modules/goals/GoalsRepository.ts
index c226469..cfabc2e 100644
--- a/api/src/tv-modules/goals/GoalsRepository.ts
+++ b/api/src/tv-modules/goals/GoalsRepository.ts
@@ -105,20 +105,25 @@ export class GoalsRepository {
return !!(del.rowCount && del.rowCount > 0);
}
- async fetchSharedGoals(user: AppUser): Promise<GoalItemInDb[]> {
+ async fetchSharedGoals(user: AppUser, organizationId?: number): Promise<GoalItemInDb[]> {
if (!user.getUserData()?.email) {
$logger.error('Trying fetch shared goals without active user');
return [];
}
- const result = await this.db
- .query<GoalItemInDb>(
- `select tg.* from tasks.goals tg
+ const params: any[] = [user.getUserData()?.email, user.getUserData()?.id];
+ let sql = `select tg.* from tasks.goals tg
left join collaboration.users_to_goals utg on utg.goal_id = tg.id
left join collaboration.users cu on cu.id = utg.user_id
- where cu.email = $1 and tg.owner <> $2`,
- [user.getUserData()?.email, user.getUserData()?.id]
- )
+ where cu.email = $1 and tg.owner <> $2`;
+
+ if (organizationId) {
+ sql += ' and tg.organization_id = $3';
+ params.push(organizationId);
+ }
+
+ const result = await this.db
+ .query<GoalItemInDb>(sql, params)
.catch(logError);
if (!result) {
@@ -128,9 +133,16 @@ export class GoalsRepository {
return result.rows;
}
- async fetchSharedGoalsForUser(user: AppUser): Promise<GoalsSchemaTypeForSelect[]> {
- // debugger;
+ async fetchSharedGoalsForUser(user: AppUser, organizationId?: number): Promise<GoalsSchemaTypeForSelect[]> {
const result = await callWithCatch(() => {
+ const conditions = [
+ eq(CollaborationUsersSchema.email, user.getUserData()?.email!),
+ ne(GoalsSchema.owner, user.getUserData()?.id!),
+ ];
+ if (organizationId) {
+ conditions.push(eq(GoalsSchema.organizationId, organizationId));
+ }
+
const query = this.db.dbDrizzle
.select({
id: GoalsSchema.id,
@@ -142,6 +154,8 @@ export class GoalsRepository {
creatorId: GoalsSchema.creatorId,
editDate: GoalsSchema.editDate,
archive: GoalsSchema.archive,
+ backlogVersion: GoalsSchema.backlogVersion,
+ organizationId: GoalsSchema.organizationId,
})
.from(GoalsSchema)
.leftJoin(CollaborationUsersToGoalsSchema, eq(GoalsSchema.id, CollaborationUsersToGoalsSchema.goalId))
@@ -149,12 +163,7 @@ export class GoalsRepository {
CollaborationUsersSchema,
eq(CollaborationUsersToGoalsSchema.userId, CollaborationUsersSchema.id)
)
- .where(
- and(
- eq(CollaborationUsersSchema.email, user.getUserData()?.email!),
- ne(GoalsSchema.owner, user.getUserData()?.id!)
- )
- );
+ .where(and(...conditions));
// const sql = query.toSQL();
// console.log('query', sql);
return query;
@@ -183,29 +192,34 @@ export class GoalsRepository {
return !!(result.rowCount && result.rowCount > 0);
}
- async fetchAllOwnGoalsIds(user: AppUser): Promise<number[]> {
- const ownGoals = await this.db
- .query<{ id: number }>('select id from tasks.goals where owner = $1 and archive = $2', [
- user.getUserData()?.id,
- 0,
- ])
- .catch(logError);
-
- if (!ownGoals) {
- $logger.error(`Can not fetch own goals for all state`);
- return [];
+ async fetchAllOwnGoalsIds(user: AppUser, organizationId?: number): Promise<number[]> {
+ const conditions = [
+ eq(GoalsSchema.owner, user.getUserData()?.id!),
+ eq(GoalsSchema.archive, 0),
+ ];
+ if (organizationId) {
+ conditions.push(eq(GoalsSchema.organizationId, organizationId));
}
- return ownGoals.rows.map((g) => g.id);
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select({ id: GoalsSchema.id })
+ .from(GoalsSchema)
+ .where(and(...conditions))
+ );
+
+ if (!result) return [];
+ return result.map((g) => g.id);
}
- async createGoal(goalData: GoalsArgAdd, userId: number): Promise<GoalsSchemaTypeForSelect | false> {
+ async createGoal(goalData: GoalsArgAdd, ownerId: number, creatorId?: number): Promise<GoalsSchemaTypeForSelect | false> {
const result = await callWithCatch(() =>
this.db.dbDrizzle
.insert(GoalsSchema)
.values({
...goalData,
- owner: userId,
+ owner: ownerId,
+ ...(creatorId && { creatorId }),
})
.returning()
);
@@ -240,9 +254,22 @@ export class GoalsRepository {
return !!(result?.rowCount && result.rowCount > 0);
}
- async fetchGoalsNew(userId: number): Promise<GoalsSchemaTypeForSelect[]> {
+ async findGoalById(goalId: number): Promise<GoalsSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle.select().from(GoalsSchema).where(eq(GoalsSchema.id, goalId))
+ );
+ if (!result || result.length === 0) return false;
+ return result[0];
+ }
+
+ async fetchGoalsNew(userId: number, organizationId?: number): Promise<GoalsSchemaTypeForSelect[]> {
+ const conditions = [eq(GoalsSchema.owner, userId)];
+ if (organizationId) {
+ conditions.push(eq(GoalsSchema.organizationId, organizationId));
+ }
+
const result = await callWithCatch(() =>
- this.db.dbDrizzle.select().from(GoalsSchema).where(eq(GoalsSchema.owner, userId))
+ this.db.dbDrizzle.select().from(GoalsSchema).where(and(...conditions))
);
if (!result) {
return [];
diff --git a/api/src/tv-modules/goals/GoalsRoutes.ts b/api/src/tv-modules/goals/GoalsRoutes.ts
index 0a265a2..355a9c1 100644
--- a/api/src/tv-modules/goals/GoalsRoutes.ts
+++ b/api/src/tv-modules/goals/GoalsRoutes.ts
@@ -3,6 +3,7 @@ import type { Routable } from '../../types/routable.type';
import { IsLoggedIn } from '../auth/middlewares/is-logged-in';
import GoalsController from './GoalsController';
// import { CanArchiveGoal } from './middlewares/CanArchiveGoal';
+import { IsOrgMemberIfProvided } from '../../middlewares/is-org-member';
import { canAddGoal } from './middlewares/can-add-goal';
import { canDeleteGoal } from './middlewares/can-delete-goal';
import { canEditGoal } from './middlewares/can-edit-goal';
@@ -23,9 +24,9 @@ export default class GoalsRoutes implements Routable {
}
initRoutes() {
- this.router.post('', [IsLoggedIn, canAddGoal], this.goalsController.createGoal);
+ this.router.post('', [IsLoggedIn, IsOrgMemberIfProvided, canAddGoal], this.goalsController.createGoal);
this.router.patch('', [IsLoggedIn, canEditGoal], this.goalsController.updateGoalNew);
this.router.delete('', [IsLoggedIn, canDeleteGoal], this.goalsController.deleteGoalNew);
- this.router.get('', [IsLoggedIn, canFetchGoals], this.goalsController.fetchGoalsNew);
+ this.router.get('', [IsLoggedIn, IsOrgMemberIfProvided, canFetchGoals], this.goalsController.fetchGoalsNew);
}
}
diff --git a/api/src/tv-modules/goals/middlewares/can-add-goal.ts b/api/src/tv-modules/goals/middlewares/can-add-goal.ts
index 4ffb0cb..773d786 100644
--- a/api/src/tv-modules/goals/middlewares/can-add-goal.ts
+++ b/api/src/tv-modules/goals/middlewares/can-add-goal.ts
@@ -1,9 +1,18 @@
-import type { NextFunction, Request, Response } from 'express';
+import type { NextFunction, Request, Response } from 'express'
+import { ORG_ADMIN_ROLES, type OrgRole } from '../../organizations/types'
export const canAddGoal = async (req: Request, res: Response, next: NextFunction) => {
- if (!req.appUser.isBlocked()) {
- return next();
+ if (req.appUser.isBlocked()) {
+ return res.status(403).end()
}
- return res.status(403).end();
-};
+ const organizationId = req.body.organizationId
+ if (organizationId) {
+ const member = await req.appUser.organizationManager.getCurrentUserMember(Number(organizationId))
+ if (!member || !ORG_ADMIN_ROLES.includes(member.role as OrgRole)) {
+ return res.status(403).end()
+ }
+ }
+
+ return next()
+}
diff --git a/api/src/tv-modules/goals/types.ts b/api/src/tv-modules/goals/types.ts
index 7fd8087..0bb8fe0 100644
--- a/api/src/tv-modules/goals/types.ts
+++ b/api/src/tv-modules/goals/types.ts
@@ -6,6 +6,7 @@ export const GoalsArkTypeAdd = type({
name: 'string',
'description?': 'string | null',
'color?': 'string | null',
+ 'organizationId?': 'number',
});
export type GoalsArgAdd = typeof GoalsArkTypeAdd.infer;
@@ -25,4 +26,10 @@ export const GoalsArkTypeDelete = type({
export type GoalsArgDelete = typeof GoalsArkTypeDelete.infer;
+export const GoalsArkTypeFetch = type({
+ 'organizationId?': type('string | number').pipe((v) => Number(v)),
+});
+
+export type GoalsArgFetch = typeof GoalsArkTypeFetch.infer;
+
export type GoalsItemForClientWithPermissions = GoalsSchemaTypeForSelect & { permissions: GoalPermissionsForClient };
diff --git a/api/src/tv-modules/notifications/NotificationsController.ts b/api/src/tv-modules/notifications/NotificationsController.ts
index b045d2a..abc7887 100644
--- a/api/src/tv-modules/notifications/NotificationsController.ts
+++ b/api/src/tv-modules/notifications/NotificationsController.ts
@@ -18,7 +18,8 @@ const DeviceTokenArkType = type({
export class NotificationsController {
fetch = async (req: Request, res: Response) => {
const cursor = req.query.cursor ? Number(req.query.cursor) : undefined;
- return res.tvJson(await req.appUser.notificationsManager.fetchByUser(cursor));
+ const organizationId = req.query.organizationId ? Number(req.query.organizationId) : undefined;
+ return res.tvJson(await req.appUser.notificationsManager.fetchByUser(cursor, organizationId));
};
markRead = async (req: Request, res: Response) => {
@@ -29,8 +30,9 @@ export class NotificationsController {
return res.tvJson(await req.appUser.notificationsManager.markRead(out.notificationId));
};
- markAllRead = async (_req: Request, res: Response) => {
- return res.tvJson(await _req.appUser.notificationsManager.markAllRead());
+ markAllRead = async (req: Request, res: Response) => {
+ const organizationId = req.query.organizationId ? Number(req.query.organizationId) : undefined;
+ return res.tvJson(await req.appUser.notificationsManager.markAllRead(organizationId));
};
registerDevice = async (req: Request, res: Response) => {
diff --git a/api/src/tv-modules/notifications/NotificationsManager.ts b/api/src/tv-modules/notifications/NotificationsManager.ts
index 685f313..dd66616 100644
--- a/api/src/tv-modules/notifications/NotificationsManager.ts
+++ b/api/src/tv-modules/notifications/NotificationsManager.ts
@@ -10,10 +10,10 @@ export class NotificationsManager {
this.repository = new NotificationsRepository();
}
- async fetchByUser(cursor?: number) {
+ async fetchByUser(cursor?: number, organizationId?: number) {
const userId = this.user.getUserData()?.id;
if (!userId) return { notifications: [] };
- const notifications = await this.repository.fetchByUser(userId, cursor);
+ const notifications = await this.repository.fetchByUser(userId, cursor, organizationId);
return { notifications };
}
@@ -23,9 +23,9 @@ export class NotificationsManager {
return this.repository.markRead(notificationId, userId);
}
- async markAllRead() {
+ async markAllRead(organizationId?: number) {
const userId = this.user.getUserData()?.id;
if (!userId) return false;
- return this.repository.markAllRead(userId);
+ return this.repository.markAllRead(userId, organizationId);
}
}
diff --git a/api/src/tv-modules/notifications/NotificationsRoutes.ts b/api/src/tv-modules/notifications/NotificationsRoutes.ts
index bf6ff74..d217309 100644
--- a/api/src/tv-modules/notifications/NotificationsRoutes.ts
+++ b/api/src/tv-modules/notifications/NotificationsRoutes.ts
@@ -1,6 +1,7 @@
import { Router } from 'express';
import type { Routable } from '../../types/routable.type';
import { IsLoggedIn } from '../auth/middlewares/is-logged-in';
+import { IsOrgMemberIfProvided } from '../../middlewares/is-org-member';
import { NotificationsController } from './NotificationsController';
export default class NotificationsRoutes implements Routable {
@@ -18,9 +19,9 @@ export default class NotificationsRoutes implements Routable {
}
initRoutes() {
- this.router.get('/', [IsLoggedIn], this.controller.fetch);
+ this.router.get('/', [IsLoggedIn, IsOrgMemberIfProvided], this.controller.fetch);
this.router.patch('/read', [IsLoggedIn], this.controller.markRead);
- this.router.patch('/read-all', [IsLoggedIn], this.controller.markAllRead);
+ this.router.patch('/read-all', [IsLoggedIn, IsOrgMemberIfProvided], this.controller.markAllRead);
this.router.get('/preferences', [IsLoggedIn], this.controller.getPreferences);
this.router.put('/preferences', [IsLoggedIn], this.controller.savePreferences);
this.router.get('/connection-token', [IsLoggedIn], this.controller.connectionToken);
diff --git a/api/src/tv-modules/notifications/repositories/NotificationsRepository.ts b/api/src/tv-modules/notifications/repositories/NotificationsRepository.ts
index df572c1..0a0248d 100644
--- a/api/src/tv-modules/notifications/repositories/NotificationsRepository.ts
+++ b/api/src/tv-modules/notifications/repositories/NotificationsRepository.ts
@@ -1,5 +1,5 @@
-import { and, eq, desc, lt, sql } from 'drizzle-orm';
-import { NotificationsSchema, TasksSchema, type NotificationsSchemaTypeForSelect } from 'taskview-db-schemas';
+import { and, eq, desc, lt, sql, inArray } from 'drizzle-orm';
+import { NotificationsSchema, TasksSchema, GoalsSchema, type NotificationsSchemaTypeForSelect } from 'taskview-db-schemas';
import { Database } from '../../../modules/db';
import { callWithCatch } from '../../../utils/helpers';
@@ -24,12 +24,24 @@ export class NotificationsRepository {
return result[0];
}
- async fetchByUser(userId: number, cursor?: number) {
+ async fetchByUser(userId: number, cursor?: number, organizationId?: number) {
const limit = 30;
const conditions = [eq(NotificationsSchema.userId, userId)];
if (cursor) {
conditions.push(lt(NotificationsSchema.id, cursor));
}
+ if (organizationId) {
+ conditions.push(
+ inArray(
+ NotificationsSchema.taskId,
+ this.db.dbDrizzle
+ .select({ id: TasksSchema.id })
+ .from(TasksSchema)
+ .innerJoin(GoalsSchema, eq(TasksSchema.goalId, GoalsSchema.id))
+ .where(eq(GoalsSchema.organizationId, organizationId))
+ )
+ );
+ }
const result = await callWithCatch(() =>
this.db.dbDrizzle.select({
id: NotificationsSchema.id,
@@ -83,14 +95,27 @@ export class NotificationsRepository {
return !!result;
}
- async markAllRead(userId: number): Promise<boolean> {
+ async markAllRead(userId: number, organizationId?: number): Promise<boolean> {
+ const conditions = [
+ eq(NotificationsSchema.userId, userId),
+ eq(NotificationsSchema.read, false),
+ ];
+ if (organizationId) {
+ conditions.push(
+ inArray(
+ NotificationsSchema.taskId,
+ this.db.dbDrizzle
+ .select({ id: TasksSchema.id })
+ .from(TasksSchema)
+ .innerJoin(GoalsSchema, eq(TasksSchema.goalId, GoalsSchema.id))
+ .where(eq(GoalsSchema.organizationId, organizationId))
+ )
+ );
+ }
const result = await callWithCatch(() =>
this.db.dbDrizzle.update(NotificationsSchema)
.set({ read: true })
- .where(and(
- eq(NotificationsSchema.userId, userId),
- eq(NotificationsSchema.read, false),
- ))
+ .where(and(...conditions))
);
return !!result;
}
diff --git a/api/src/tv-modules/organizations/OrganizationController.ts b/api/src/tv-modules/organizations/OrganizationController.ts
new file mode 100644
index 0000000..9646f8d
--- /dev/null
+++ b/api/src/tv-modules/organizations/OrganizationController.ts
@@ -0,0 +1,100 @@
+import { type } from 'arktype'
+import type { Request, Response } from 'express'
+import { logError } from '../../utils/api'
+import {
+ OrganizationArkTypeCreate,
+ OrganizationArkTypeUpdate,
+ OrganizationArkTypeDelete,
+ OrganizationMemberArkTypeAdd,
+ OrganizationMemberArkTypeUpdateRole,
+ OrganizationMemberArkTypeRemove,
+} from './types'
+
+export class OrganizationController {
+ create = async (req: Request, res: Response) => {
+ const out = OrganizationArkTypeCreate(req.body)
+ if (out instanceof type.errors) {
+ return res.status(400).send(out.summary)
+ }
+
+ const org = await req.appUser.organizationManager.create(out).catch(logError)
+ return res.tvJson(org ?? null)
+ }
+
+ update = async (req: Request, res: Response) => {
+ const out = OrganizationArkTypeUpdate(req.body)
+ if (out instanceof type.errors) {
+ return res.status(400).send(out.summary)
+ }
+
+ const org = await req.appUser.organizationManager.update(out).catch(logError)
+ return res.tvJson(org ?? null)
+ }
+
+ delete = async (req: Request, res: Response) => {
+ const out = OrganizationArkTypeDelete(req.body)
+ if (out instanceof type.errors) {
+ return res.status(400).send(out.summary)
+ }
+
+ const result = await req.appUser.organizationManager.delete(out.organizationId).catch(logError)
+ return res.tvJson(!!result)
+ }
+
+ fetch = async (req: Request, res: Response) => {
+ const orgs = await req.appUser.organizationManager.fetchForCurrentUser().catch(logError)
+ return res.tvJson(orgs ?? [])
+ }
+
+ getById = async (req: Request, res: Response) => {
+ const orgId = Number(req.params.orgId)
+ if (!orgId) return res.status(400).end()
+
+ const org = await req.appUser.organizationManager.getById(orgId).catch(logError)
+ return res.tvJson(org ?? null)
+ }
+
+ fetchMembers = async (req: Request, res: Response) => {
+ const orgId = Number(req.params.orgId)
+ if (!orgId) return res.status(400).end()
+
+ const members = await req.appUser.organizationManager.fetchMembers(orgId).catch(logError)
+ return res.tvJson(members ?? [])
+ }
+
+ addMember = async (req: Request, res: Response) => {
+ const out = OrganizationMemberArkTypeAdd(req.body)
+ if (out instanceof type.errors) {
+ return res.status(400).send(out.summary)
+ }
+
+ const member = await req.appUser.organizationManager
+ .addMember(out.organizationId, out.email, out.role)
+ .catch(logError)
+ return res.tvJson(member ?? null)
+ }
+
+ updateMemberRole = async (req: Request, res: Response) => {
+ const out = OrganizationMemberArkTypeUpdateRole(req.body)
+ if (out instanceof type.errors) {
+ return res.status(400).send(out.summary)
+ }
+
+ const member = await req.appUser.organizationManager
+ .updateMemberRole(out.organizationId, out.email, out.role)
+ .catch(logError)
+ return res.tvJson(member ?? null)
+ }
+
+ removeMember = async (req: Request, res: Response) => {
+ const out = OrganizationMemberArkTypeRemove(req.body)
+ if (out instanceof type.errors) {
+ return res.status(400).send(out.summary)
+ }
+
+ const result = await req.appUser.organizationManager
+ .removeMember(out.organizationId, out.email)
+ .catch(logError)
+ return res.tvJson(!!result)
+ }
+}
diff --git a/api/src/tv-modules/organizations/OrganizationManager.ts b/api/src/tv-modules/organizations/OrganizationManager.ts
new file mode 100644
index 0000000..a6f1aad
--- /dev/null
+++ b/api/src/tv-modules/organizations/OrganizationManager.ts
@@ -0,0 +1,124 @@
+import type { AppUser } from '../../core/AppUser'
+import { isNotNullable } from '../../utils/helpers'
+import { OrganizationRepository } from './OrganizationRepository'
+import type { OrganizationArgCreate, OrganizationArgUpdate } from './types'
+
+export class OrganizationManager {
+ public readonly repository: OrganizationRepository
+ private readonly user: AppUser
+
+ constructor(user: AppUser) {
+ this.user = user
+ this.repository = new OrganizationRepository()
+ }
+
+ private getUserId(): number | null {
+ const id = this.user.getUserData()?.id
+ return isNotNullable(id) ? id : null
+ }
+
+ private getUserEmail(): string | null {
+ return this.user.getUserData()?.email ?? null
+ }
+
+ async create(data: OrganizationArgCreate) {
+ const userId = this.getUserId()
+ const email = this.getUserEmail()
+ if (!userId || !email) return false
+
+ const slug = data.slug ?? this.generateSlug()
+
+ const existing = await this.repository.findBySlug(slug)
+ if (existing) return false
+
+ const org = await this.repository.create({ ...data, slug }, userId)
+ if (!org) return false
+
+ await this.repository.addMember(org.id, email, 'owner')
+ return org
+ }
+
+ async update(data: OrganizationArgUpdate) {
+ if (data.slug) {
+ const existing = await this.repository.findBySlug(data.slug)
+ if (existing && existing.id !== data.organizationId) return false
+ }
+
+ return await this.repository.update(data)
+ }
+
+ async delete(orgId: number) {
+ const org = await this.repository.findById(orgId)
+ if (!org) return false
+ if (org.isPersonal) return false
+
+ const userId = this.getUserId()
+ if (org.ownerId !== userId) return false
+
+ return await this.repository.delete(orgId)
+ }
+
+ async fetchForCurrentUser() {
+ const email = this.getUserEmail()
+ if (!email) return []
+
+ return await this.repository.fetchForUserByEmail(email)
+ }
+
+ async getById(orgId: number) {
+ return await this.repository.findById(orgId)
+ }
+
+ async getPersonalOrgId(): Promise<number | false> {
+ const userId = this.getUserId()
+ if (!userId) return false
+
+ const org = await this.repository.findPersonalForUser(userId)
+ if (!org) return false
+
+ return org.id
+ }
+
+ async addMember(orgId: number, email: string, role: string = 'member') {
+ const userId = this.getUserId()
+ if (!userId) return false
+ if (role === 'owner') return false
+
+ return await this.repository.addMember(orgId, email, role, userId)
+ }
+
+ async updateMemberRole(orgId: number, email: string, role: string) {
+ const targetMember = await this.repository.getMemberByEmail(orgId, email)
+ if (!targetMember || targetMember.role === 'owner') return false
+
+ return await this.repository.updateMemberRole(orgId, email, role)
+ }
+
+ async removeMember(orgId: number, email: string) {
+ const org = await this.repository.findById(orgId)
+ if (!org) return false
+
+ const targetMember = await this.repository.getMemberByEmail(orgId, email)
+ if (!targetMember || targetMember.role === 'owner') return false
+
+ const removed = await this.repository.removeMember(orgId, email)
+ if (removed) {
+ await this.repository.removeUserFromOrgGoals(orgId, email)
+ }
+ return removed
+ }
+
+ async fetchMembers(orgId: number) {
+ return await this.repository.fetchMembers(orgId)
+ }
+
+ async getCurrentUserMember(orgId: number) {
+ const email = this.getUserEmail()
+ if (!email) return false
+ return await this.repository.getMemberByEmail(orgId, email)
+ }
+
+ private generateSlug(): string {
+ return `org-${crypto.randomUUID().slice(0, 8)}`
+ }
+}
diff --git a/api/src/tv-modules/organizations/OrganizationRepository.ts b/api/src/tv-modules/organizations/OrganizationRepository.ts
new file mode 100644
index 0000000..86ee8f2
--- /dev/null
+++ b/api/src/tv-modules/organizations/OrganizationRepository.ts
@@ -0,0 +1,229 @@
+import { and, eq, inArray } from 'drizzle-orm'
+import {
+ OrganizationsSchema,
+ OrganizationMembersSchema,
+ CollaborationUsersSchema,
+ CollaborationUsersToGoalsSchema,
+ GoalsSchema,
+ type OrganizationsSchemaTypeForSelect,
+ type OrganizationMembersSchemaTypeForSelect,
+} from 'taskview-db-schemas'
+import { Database } from '../../modules/db'
+import { callWithCatch } from '../../utils/helpers'
+import type { OrganizationArgCreate, OrganizationArgUpdate } from './types'
+
+export class OrganizationRepository {
+ private readonly db: Database
+
+ constructor() {
+ this.db = Database.getInstance()
+ }
+
+ async create(data: OrganizationArgCreate, userId: number, isPersonal: boolean = false): Promise<OrganizationsSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .insert(OrganizationsSchema)
+ .values({
+ name: data.name,
+ slug: data.slug ?? `org-${Date.now()}`,
+ ownerId: userId,
+ logoUrl: data.logoUrl,
+ isPersonal: isPersonal ? 1 : 0,
+ })
+ .returning()
+ )
+
+ if (!result) return false
+ return result[0]
+ }
+
+ async update(data: OrganizationArgUpdate): Promise<OrganizationsSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .update(OrganizationsSchema)
+ .set({
+ ...(data.name !== undefined && { name: data.name }),
+ ...(data.slug !== undefined && { slug: data.slug }),
+ ...(data.logoUrl !== undefined && { logoUrl: data.logoUrl }),
+ updatedAt: new Date(),
+ })
+ .where(eq(OrganizationsSchema.id, data.organizationId))
+ .returning()
+ )
+
+ if (!result) return false
+ return result[0]
+ }
+
+ async delete(orgId: number): Promise<boolean> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .delete(OrganizationsSchema)
+ .where(eq(OrganizationsSchema.id, orgId))
+ )
+
+ return !!(result?.rowCount && result.rowCount > 0)
+ }
+
+ async findById(orgId: number): Promise<OrganizationsSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select()
+ .from(OrganizationsSchema)
+ .where(eq(OrganizationsSchema.id, orgId))
+ )
+
+ if (!result || result.length === 0) return false
+ return result[0]
+ }
+
+ async findPersonalForUser(userId: number): Promise<OrganizationsSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select()
+ .from(OrganizationsSchema)
+ .where(
+ and(
+ eq(OrganizationsSchema.ownerId, userId),
+ eq(OrganizationsSchema.isPersonal, 1),
+ )
+ )
+ )
+
+ if (!result || result.length === 0) return false
+ return result[0]
+ }
+
+ async findBySlug(slug: string): Promise<OrganizationsSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select()
+ .from(OrganizationsSchema)
+ .where(eq(OrganizationsSchema.slug, slug))
+ )
+
+ if (!result || result.length === 0) return false
+ return result[0]
+ }
+
+ async fetchForUserByEmail(email: string): Promise<OrganizationsSchemaTypeForSelect[]> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select({ org: OrganizationsSchema })
+ .from(OrganizationMembersSchema)
+ .innerJoin(OrganizationsSchema, eq(OrganizationMembersSchema.organizationId, OrganizationsSchema.id))
+ .where(eq(OrganizationMembersSchema.email, email))
+ )
+
+ if (!result) return []
+ return result.map(r => r.org)
+ }
+
+ async addMember(orgId: number, email: string, role: string, invitedBy?: number): Promise<OrganizationMembersSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .insert(OrganizationMembersSchema)
+ .values({
+ organizationId: orgId,
+ email: email.toLowerCase(),
+ role,
+ invitedBy: invitedBy ?? null,
+ })
+ .onConflictDoNothing()
+ .returning()
+ )
+
+ if (!result || result.length === 0) return false
+ return result[0]
+ }
+
+ async updateMemberRole(orgId: number, email: string, role: string): Promise<OrganizationMembersSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .update(OrganizationMembersSchema)
+ .set({ role })
+ .where(
+ and(
+ eq(OrganizationMembersSchema.organizationId, orgId),
+ eq(OrganizationMembersSchema.email, email),
+ )
+ )
+ .returning()
+ )
+
+ if (!result || result.length === 0) return false
+ return result[0]
+ }
+
+ async removeMember(orgId: number, email: string): Promise<boolean> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .delete(OrganizationMembersSchema)
+ .where(
+ and(
+ eq(OrganizationMembersSchema.organizationId, orgId),
+ eq(OrganizationMembersSchema.email, email),
+ )
+ )
+ )
+
+ return !!(result?.rowCount && result.rowCount > 0)
+ }
+
+ async fetchMembers(orgId: number): Promise<OrganizationMembersSchemaTypeForSelect[]> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select()
+ .from(OrganizationMembersSchema)
+ .where(eq(OrganizationMembersSchema.organizationId, orgId))
+ )
+
+ if (!result) return []
+ return result
+ }
+
+ async getMemberByEmail(orgId: number, email: string): Promise<OrganizationMembersSchemaTypeForSelect | false> {
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select()
+ .from(OrganizationMembersSchema)
+ .where(
+ and(
+ eq(OrganizationMembersSchema.organizationId, orgId),
+ eq(OrganizationMembersSchema.email, email),
+ )
+ )
+ )
+
+ if (!result || result.length === 0) return false
+ return result[0]
+ }
+
+ async removeUserFromOrgGoals(orgId: number, email: string): Promise<void> {
+ await callWithCatch(async () => {
+ const collabUsers = await this.db.dbDrizzle
+ .select({ id: CollaborationUsersSchema.id })
+ .from(CollaborationUsersSchema)
+ .where(eq(CollaborationUsersSchema.email, email))
+
+ const orgGoals = await this.db.dbDrizzle
+ .select({ id: GoalsSchema.id })
+ .from(GoalsSchema)
+ .where(eq(GoalsSchema.organizationId, orgId))
+
+ const userIds = collabUsers.map(u => u.id)
+ const goalIds = orgGoals.map(g => g.id)
+
+ if (userIds.length && goalIds.length) {
+ await this.db.dbDrizzle
+ .delete(CollaborationUsersToGoalsSchema)
+ .where(
+ and(
+ inArray(CollaborationUsersToGoalsSchema.userId, userIds),
+ inArray(CollaborationUsersToGoalsSchema.goalId, goalIds),
+ )
+ )
+ }
+ })
+ }
+}
diff --git a/api/src/tv-modules/organizations/OrganizationRoutes.ts b/api/src/tv-modules/organizations/OrganizationRoutes.ts
new file mode 100644
index 0000000..31ae661
--- /dev/null
+++ b/api/src/tv-modules/organizations/OrganizationRoutes.ts
@@ -0,0 +1,35 @@
+import { Router } from 'express'
+import type { Routable } from '../../types/routable.type'
+import { IsLoggedIn } from '../auth/middlewares/is-logged-in'
+import { OrganizationController } from './OrganizationController'
+import { IsOrgAdmin } from './middlewares/IsOrgAdmin'
+import { IsOrgMember } from './middlewares/IsOrgMember'
+import { IsOrgOwner } from './middlewares/IsOrgOwner'
+
+export default class OrganizationRoutes implements Routable {
+ private readonly router: ReturnType<typeof Router>
+ private readonly controller: OrganizationController
+
+ constructor() {
+ this.router = Router()
+ this.controller = new OrganizationController()
+ this.initRoutes()
+ }
+
+ getRouter() {
+ return this.router
+ }
+
+ initRoutes() {
+ this.router.post('', [IsLoggedIn], this.controller.create)
+ this.router.get('', [IsLoggedIn], this.controller.fetch)
+ this.router.get('/:orgId', [IsLoggedIn, IsOrgMember], this.controller.getById)
+ this.router.patch('', [IsLoggedIn, IsOrgAdmin], this.controller.update)
+ this.router.delete('', [IsLoggedIn, IsOrgOwner], this.controller.delete)
+
+ this.router.get('/:orgId/members', [IsLoggedIn, IsOrgMember], this.controller.fetchMembers)
+ this.router.post('/members', [IsLoggedIn, IsOrgAdmin], this.controller.addMember)
+ this.router.patch('/members/role', [IsLoggedIn, IsOrgAdmin], this.controller.updateMemberRole)
+ this.router.delete('/members', [IsLoggedIn, IsOrgAdmin], this.controller.removeMember)
+ }
+}
diff --git a/api/src/tv-modules/organizations/middlewares/IsOrgAdmin.ts b/api/src/tv-modules/organizations/middlewares/IsOrgAdmin.ts
new file mode 100644
index 0000000..4775e96
--- /dev/null
+++ b/api/src/tv-modules/organizations/middlewares/IsOrgAdmin.ts
@@ -0,0 +1,13 @@
+import type { NextFunction, Request, Response } from 'express'
+import { ORG_ADMIN_ROLES, type OrgRole } from '../types'
+
+export const IsOrgAdmin = async (req: Request, res: Response, next: NextFunction) => {
+ const orgId = Number(req.params.orgId || req.body.organizationId)
+ if (!orgId) return res.status(400).end()
+
+ const member = await req.appUser.organizationManager.getCurrentUserMember(orgId)
+
+ if (!member || !ORG_ADMIN_ROLES.includes(member.role as OrgRole)) return res.status(403).end()
+
+ next()
+}
diff --git a/api/src/tv-modules/organizations/middlewares/IsOrgMember.ts b/api/src/tv-modules/organizations/middlewares/IsOrgMember.ts
new file mode 100644
index 0000000..8d947c0
--- /dev/null
+++ b/api/src/tv-modules/organizations/middlewares/IsOrgMember.ts
@@ -0,0 +1,13 @@
+import type { NextFunction, Request, Response } from 'express'
+import { ORG_ALL_ROLES, type OrgRole } from '../types'
+
+export const IsOrgMember = async (req: Request, res: Response, next: NextFunction) => {
+ const orgId = Number(req.params.orgId || req.body.organizationId)
+ if (!orgId) return res.status(400).end()
+
+ const member = await req.appUser.organizationManager.getCurrentUserMember(orgId)
+
+ if (!member || !ORG_ALL_ROLES.includes(member.role as OrgRole)) return res.status(403).end()
+
+ next()
+}
diff --git a/api/src/tv-modules/organizations/middlewares/IsOrgOwner.ts b/api/src/tv-modules/organizations/middlewares/IsOrgOwner.ts
new file mode 100644
index 0000000..e9153f2
--- /dev/null
+++ b/api/src/tv-modules/organizations/middlewares/IsOrgOwner.ts
@@ -0,0 +1,13 @@
+import type { NextFunction, Request, Response } from 'express'
+import { OrgRoles } from '../types'
+
+export const IsOrgOwner = async (req: Request, res: Response, next: NextFunction) => {
+ const orgId = Number(req.params.orgId || req.body.organizationId)
+ if (!orgId) return res.status(400).end()
+
+ const member = await req.appUser.organizationManager.getCurrentUserMember(orgId)
+
+ if (!member || member.role !== OrgRoles.OWNER) return res.status(403).end()
+
+ next()
+}
diff --git a/api/src/tv-modules/organizations/types.ts b/api/src/tv-modules/organizations/types.ts
new file mode 100644
index 0000000..a690d35
--- /dev/null
+++ b/api/src/tv-modules/organizations/types.ts
@@ -0,0 +1,58 @@
+import { type } from 'arktype'
+
+export const OrgRoles = {
+ OWNER: 'owner',
+ ADMIN: 'admin',
+ MEMBER: 'member',
+} as const
+
+export type OrgRole = typeof OrgRoles[keyof typeof OrgRoles]
+
+export const ORG_ADMIN_ROLES: readonly OrgRole[] = [OrgRoles.OWNER, OrgRoles.ADMIN]
+export const ORG_ALL_ROLES: readonly OrgRole[] = [OrgRoles.OWNER, OrgRoles.ADMIN, OrgRoles.MEMBER]
+
+export const OrganizationArkTypeCreate = type({
+ name: 'string > 0',
+ 'slug?': 'string',
+ 'logoUrl?': 'string | null',
+})
+
+export type OrganizationArgCreate = typeof OrganizationArkTypeCreate.infer
+
+export const OrganizationArkTypeUpdate = type({
+ organizationId: 'number',
+ 'name?': 'string',
+ 'slug?': 'string',
+ 'logoUrl?': 'string | null',
+})
+
+export type OrganizationArgUpdate = typeof OrganizationArkTypeUpdate.infer
+
+export const OrganizationArkTypeDelete = type({
+ organizationId: 'number',
+})
+
+export type OrganizationArgDelete = typeof OrganizationArkTypeDelete.infer
+
+export const OrganizationMemberArkTypeAdd = type({
+ organizationId: 'number',
+ email: 'string',
+ 'role?': "'admin' | 'member'",
+})
+
+export type OrganizationMemberArgAdd = typeof OrganizationMemberArkTypeAdd.infer
+
+export const OrganizationMemberArkTypeUpdateRole = type({
+ organizationId: 'number',
+ email: 'string',
+ role: "'admin' | 'member'",
+})
+
+export type OrganizationMemberArgUpdateRole = typeof OrganizationMemberArkTypeUpdateRole.infer
+
+export const OrganizationMemberArkTypeRemove = type({
+ organizationId: 'number',
+ email: 'string',
+})
+
+export type OrganizationMemberArgRemove = typeof OrganizationMemberArkTypeRemove.infer
diff --git a/api/src/tv-modules/start/StartController.ts b/api/src/tv-modules/start/StartController.ts
index c554e67..636f0d5 100644
--- a/api/src/tv-modules/start/StartController.ts
+++ b/api/src/tv-modules/start/StartController.ts
@@ -2,17 +2,20 @@ import type { Request, Response } from 'express';
export class StartController {
fetchAllLists = async (req: Request, res: Response) => {
- return res.tvJson(await req.appUser.startManager.fetchAllLists());
+ const organizationId = req.query.organizationId ? Number(req.query.organizationId) : undefined;
+ return res.tvJson(await req.appUser.startManager.fetchAllLists(organizationId));
};
fetchAllState = async (req: Request, res: Response) => {
if (!req?.query?.tz) {
return res.status(400).send('tz is required');
}
- return res.tvJson(await req.appUser.startManager.fetchAllState(req?.query?.tz as string));
+ const organizationId = req.query.organizationId ? Number(req.query.organizationId) : undefined;
+ return res.tvJson(await req.appUser.startManager.fetchAllState(req.query.tz as string, organizationId));
};
searchTaskInAllProjects = async (req: Request, res: Response) => {
- return res.tvJson(await req.appUser.startManager.searchTaskInAllProjects(req?.query?.description as string));
+ const organizationId = req.query.organizationId ? Number(req.query.organizationId) : undefined;
+ return res.tvJson(await req.appUser.startManager.searchTaskInAllProjects(req?.query?.description as string, organizationId));
};
}
diff --git a/api/src/tv-modules/start/StartManager.ts b/api/src/tv-modules/start/StartManager.ts
index 930cf90..73a75e8 100644
--- a/api/src/tv-modules/start/StartManager.ts
+++ b/api/src/tv-modules/start/StartManager.ts
@@ -15,14 +15,14 @@ export class StartManager {
this.repository = new StartRepository(this.user);
}
- async fetchAllLists() {
- return await this.repository.fetchAllLists(this.user);
+ async fetchAllLists(organizationId?: number) {
+ return await this.repository.fetchAllLists(this.user, organizationId);
}
- async fetchAllState(tz: string) {
- await this.fetchSharedGoals();
- const goalIds = await this.getAllGoalsIds();
- const usersAndProjects = await this.fetchProjectsAndUsers();
+ async fetchAllState(tz: string, organizationId?: number) {
+ await this.fetchSharedGoals(organizationId);
+ const goalIds = await this.getAllGoalsIds(organizationId);
+ const usersAndProjects = await this.fetchProjectsAndUsers(organizationId);
const tasks = await this.repository.fetchAllActiveTasksForGoals(goalIds, usersAndProjects.assignees);
const tasksToday = await this.repository.fetchAllTodayTasksForGoals(goalIds, tz, usersAndProjects.assignees);
const tasksUpcoming = await this.repository.fetchUpcomingTasksForGoals(goalIds, tz, usersAndProjects.assignees);
@@ -40,70 +40,54 @@ export class StartManager {
};
}
- async fetchSharedGoals() {
- this.sharedGoals = await this.user.goalsManager.fetchSharedGoals();
+ async fetchSharedGoals(organizationId?: number) {
+ this.sharedGoals = await this.user.goalsManager.fetchSharedGoals(organizationId);
}
- async getAllGoalsIds() {
- const ownGoals = await this.repository.db
- .query<{ id: number }>('select id from tasks.goals where owner = $1 and archive = $2', [
- this.user.getUserData()?.id,
- 0,
- ])
- .catch(logError);
-
- if (!ownGoals) {
- $logger.error(`Can not fetch own goals for all state`);
- }
-
- const ids: number[] = [];
+ async getAllGoalsIds(organizationId?: number) {
+ const ownGoalIds = await this.user.goalsManager.fetchAllOwnGoalsIds(organizationId);
+ const sharedGoalIds: number[] = [];
this.sharedGoals.forEach((g) => {
if (g.hasPermissions(GoalPermissions.GOAL_CAN_WATCH_CONTENT)) {
- ids.push(g.id);
+ sharedGoalIds.push(g.id);
}
});
- if (ownGoals) {
- ownGoals.rows.forEach((g) => {
- ids.push(g.id);
- });
- }
-
- return ids;
+ const ids = new Set([...ownGoalIds, ...sharedGoalIds]);
+ return [...ids];
}
- async fetchProjectsAndUsers() {
- const goalsIdsForUsers: number[] = [];
- const goalsIdsForAssignee: number[] = [];
+ async fetchProjectsAndUsers(organizationId?: number) {
+ const ownGoalIds = await this.user.goalsManager.fetchAllOwnGoalsIds(organizationId)
+
+ const goalsIdsForUsers: number[] = [...ownGoalIds]
+ const goalsIdsForAssignee: number[] = [...ownGoalIds]
this.sharedGoals.forEach((goal) => {
if (goal.hasPermissions(GoalPermissions.GOAL_CAN_MANAGE_USERS)) {
- goalsIdsForUsers.push(goal.id);
+ goalsIdsForUsers.push(goal.id)
}
if (goal.hasPermissions(GoalPermissions.TASKS_CAN_WATCH_ASSIGNED_USERS)) {
- goalsIdsForAssignee.push(goal.id);
+ goalsIdsForAssignee.push(goal.id)
}
- }, []);
+ })
- const users = await this.repository.fetchUsersByProjects(this.user.getUserData()?.id!, goalsIdsForUsers);
- const assignees = await this.repository.fetchAssigneesForTasks(
- this.user.getUserData()?.id!,
- goalsIdsForAssignee
- );
+ const users = await this.repository.fetchUsersByProjects(goalsIdsForUsers)
+ const assignees = await this.repository.fetchAssigneesForTasks(goalsIdsForAssignee)
return {
users,
assignees,
- };
+ }
}
- async searchTaskInAllProjects(description?: string) {
+ async searchTaskInAllProjects(description?: string, organizationId?: number) {
if (!description) return [];
- await this.fetchSharedGoals();
- const goalIds = await this.getAllGoalsIds();
+ await this.fetchSharedGoals(organizationId);
+ const goalIds = await this.getAllGoalsIds(organizationId);
const tasks = await this.repository.searchTask(description.trim(), goalIds);
return tasks;
diff --git a/api/src/tv-modules/start/StartRepository.ts b/api/src/tv-modules/start/StartRepository.ts
index 13edabd..0e25382 100644
--- a/api/src/tv-modules/start/StartRepository.ts
+++ b/api/src/tv-modules/start/StartRepository.ts
@@ -1,8 +1,11 @@
+import { and, eq, inArray, isNotNull, or } from 'drizzle-orm';
+import { GoalsSchema, GoalsListSchema } from 'taskview-db-schemas';
import type { AppUser } from '../../core/AppUser';
import { Database } from '../../modules/db';
import { $logger } from '../../modules/logget';
import type { TaskItemInDb } from '../../types/tasks.types';
import { logError } from '../../utils/api';
+import { callWithCatch } from '../../utils/helpers';
import type { TagToTaskInDb } from '../tags/tags.types';
import { TaskItemForClient } from '../tasks/TaskItemForClient';
import type { AssigneesForTaskFromDb, FetchAllListsResult, UsersByProjectsFromDb } from './start.types';
@@ -17,95 +20,87 @@ export class StartRepository {
this.user = user;
}
- async fetchAllLists(user: AppUser): Promise<FetchAllListsResult[] | false> {
- const sharedGoals = await user.goalsManager.fetchSharedGoals();
- const sharedGoalsIds = sharedGoals.map((g) => g.id);
- const archive = 0;
+ async fetchAllLists(user: AppUser, organizationId?: number): Promise<FetchAllListsResult[] | false> {
+ const userId = user.getUserData()?.id
+ if (!userId) return false
- if (!user.getUserData()?.id) {
- return false;
- }
-
- let args: any[] = [archive, user.getUserData()?.id];
+ const sharedGoals = await user.goalsManager.fetchSharedGoals(organizationId)
+ const sharedGoalIds = sharedGoals.map((g) => g.id)
- let query = `select g.name as "goalName", g.id as "goalId", gl.name as "listName", gl.id as "listId"
- from tasks.goals g
- left join tasks.goal_lists gl on gl.goal_id = g.id
- where gl.archive = $1
- and g.owner = $2
- and gl.id is not null `;
- const placeholders = sharedGoalsIds.map((_item, index) => `$${index + 3}`);
-
- if (sharedGoalsIds.length > 0) {
- args = [...args, ...sharedGoalsIds];
- query += ` or g.id in (${placeholders.join(',')})`;
+ const ownConditions = [eq(GoalsSchema.owner, userId)]
+ if (organizationId) {
+ ownConditions.push(eq(GoalsSchema.organizationId, organizationId))
}
- const result = await this.db.query<FetchAllListsResult>(query, args).catch(logError);
- return result?.rows || [];
+ const goalConditions = sharedGoalIds.length > 0
+ ? or(and(...ownConditions), inArray(GoalsSchema.id, sharedGoalIds))
+ : and(...ownConditions)
+
+ const result = await callWithCatch(() =>
+ this.db.dbDrizzle
+ .select({
+ goalName: GoalsSchema.name,
+ goalId: GoalsSchema.id,
+ listName: GoalsListSchema.name,
+ listId: GoalsListSchema.id,
+ })
+ .from(GoalsSchema)
+ .leftJoin(GoalsListSchema, eq(GoalsListSchema.goalId, GoalsSchema.id))
+ .where(
+ and(
+ eq(GoalsListSchema.archive, 0),
+ isNotNull(GoalsListSchema.id),
+ goalConditions,
+ )
+ )
+ )
+
+ return result ?? []
}
- async fetchUsersByProjects(owner: number, sharedGoalsIds: number[] = []) {
- let additionalRules = '';
- const args: number[] = [owner];
+ async fetchUsersByProjects(goalIds: number[]) {
+ if (goalIds.length === 0) return []
- if (sharedGoalsIds.length > 0) {
- const placeholders = sharedGoalsIds.map((id, index) => {
- args.push(id);
- return `$${index + 2}`;
- });
- additionalRules = ` or g.id in (${placeholders.join(',')}) `;
- }
+ const args = goalIds
+ const placeholders = goalIds.map((_, i) => `$${i + 1}`).join(',')
- const query = `SELECT
+ const query = `SELECT
g.id, g.name,
COALESCE(json_agg(json_build_object('id', u.id, 'email', u.email)) FILTER (WHERE u.id IS NOT NULL), '[]') AS users
- FROM
+ FROM
tasks.goals g
- left join collaboration.users_to_goals utg on utg.goal_id = g.id
- LEFT JOIN
- collaboration.users u ON u.id = utg.user_id
- WHERE
- g.owner = $1 ${additionalRules}
- GROUP BY
- g.id, g.name;`;
+ LEFT JOIN collaboration.users_to_goals utg ON utg.goal_id = g.id
+ LEFT JOIN collaboration.users u ON u.id = utg.user_id
+ WHERE g.id IN (${placeholders})
+ GROUP BY g.id, g.name;`
- const result = await this.db.query<UsersByProjectsFromDb>(query, args);
+ const result = await this.db.query<UsersByProjectsFromDb>(query, args)
if (!result) {
- $logger.error(`Can not fetch user by projects`);
- return [];
+ $logger.error(`Can not fetch user by projects`)
+ return []
}
- return result.rows;
+ return result.rows
}
- async fetchAssigneesForTasks(owner: number, goalsIds: number[] = []) {
- let assigneeQuery = `select cu.email, ta.task_id as "taskId", ta.collab_user_id as "collabUserId"
- from tasks.tasks tt
- inner join tasks_auth.task_assignee ta on ta.task_id = tt.id
- inner join collaboration.users cu on cu.id = ta.collab_user_id
- where ta.collab_user_id is not null`;
+ async fetchAssigneesForTasks(goalIds: number[]) {
+ if (goalIds.length === 0) return []
- const args: number[] = [owner];
+ const placeholders = goalIds.map((_, i) => `$${i + 1}`).join(',')
- if (goalsIds.length > 0) {
- const placeholders = goalsIds.map((id, index) => {
- args.push(id);
- return `$${index + 2}`;
- });
- assigneeQuery += ` and (tt.owner = $1 or tt.goal_id in (${placeholders.join(',')})) `;
- } else {
- assigneeQuery += ` and (tt.owner = $1)`;
- }
+ const query = `SELECT cu.email, ta.task_id AS "taskId", ta.collab_user_id AS "collabUserId"
+ FROM tasks.tasks tt
+ INNER JOIN tasks_auth.task_assignee ta ON ta.task_id = tt.id
+ INNER JOIN collaboration.users cu ON cu.id = ta.collab_user_id
+ WHERE ta.collab_user_id IS NOT NULL
+ AND tt.goal_id IN (${placeholders})`
- const result = await this.db.query<AssigneesForTaskFromDb>(assigneeQuery, args);
+ const result = await this.db.query<AssigneesForTaskFromDb>(query, goalIds)
- if (!result) {
- return [];
- }
+ if (!result) return []
- return result.rows;
+ return result.rows
}
async fetchAllActiveTasksForGoals(
diff --git a/api/src/tv-modules/start/StartRoutes.ts b/api/src/tv-modules/start/StartRoutes.ts
index 86cd5a5..10c4165 100644
--- a/api/src/tv-modules/start/StartRoutes.ts
+++ b/api/src/tv-modules/start/StartRoutes.ts
@@ -1,25 +1,26 @@
-import { Router } from 'express';
-import type { Routable } from '../../types/routable.type';
-import { IsLoggedIn } from '../auth/middlewares/is-logged-in';
-import { StartController } from './StartController';
+import { Router } from 'express'
+import type { Routable } from '../../types/routable.type'
+import { IsLoggedIn } from '../auth/middlewares/is-logged-in'
+import { IsOrgMemberIfProvided } from '../../middlewares/is-org-member'
+import { StartController } from './StartController'
export default class StartRoutes implements Routable {
- private readonly router: ReturnType<typeof Router>;
- private readonly controller: StartController;
+ private readonly router: ReturnType<typeof Router>
+ private readonly controller: StartController
constructor() {
- this.router = Router();
- this.controller = new StartController();
- this.initRoutes();
+ this.router = Router()
+ this.controller = new StartController()
+ this.initRoutes()
}
getRouter() {
- return this.router;
+ return this.router
}
initRoutes() {
- this.router.get('/fetch/lists', [IsLoggedIn], this.controller.fetchAllLists);
- this.router.get('/fetchallstate', [IsLoggedIn], this.controller.fetchAllState);
- this.router.get('/search-task', [IsLoggedIn], this.controller.searchTaskInAllProjects);
+ this.router.get('/fetch/lists', [IsLoggedIn, IsOrgMemberIfProvided], this.controller.fetchAllLists)
+ this.router.get('/fetchallstate', [IsLoggedIn, IsOrgMemberIfProvided], this.controller.fetchAllState)
+ this.router.get('/search-task', [IsLoggedIn, IsOrgMemberIfProvided], this.controller.searchTaskInAllProjects)
}
}
diff --git a/api/src/tv-modules/start/start.types.ts b/api/src/tv-modules/start/start.types.ts
index 834eec3..d6e1e46 100644
--- a/api/src/tv-modules/start/start.types.ts
+++ b/api/src/tv-modules/start/start.types.ts
@@ -1,7 +1,7 @@
export type FetchAllListsResult = {
- goalName: string;
- listName: string;
- listId: number;
+ goalName: string | null;
+ listName: string | null;
+ listId: number | null;
goalId: number;
};
diff --git a/api/src/tv-modules/tags/TagsController.ts b/api/src/tv-modules/tags/TagsController.ts
index e3ebb57..c995d83 100644
--- a/api/src/tv-modules/tags/TagsController.ts
+++ b/api/src/tv-modules/tags/TagsController.ts
@@ -39,7 +39,8 @@ export class TagsController {
};
fetchAllTagsForUser = async (req: Request, res: Response) => {
- return res.tvJson(await req.appUser.tagsManager.fetchAllTagsForUser());
+ const organizationId = req.query.organizationId ? Number(req.query.organizationId) : undefined;
+ return res.tvJson(await req.appUser.tagsManager.fetchAllTagsForUser(organizationId));
};
/** @deprecated use toggleTagNew instead */
diff --git a/api/src/tv-modules/tags/TagsManager.ts b/api/src/tv-modules/tags/TagsManager.ts
index 8d42c84..b4f4d25 100644
--- a/api/src/tv-modules/tags/TagsManager.ts
+++ b/api/src/tv-modules/tags/TagsManager.ts
@@ -51,13 +51,13 @@ export class TagsManager {
return tags.map((item) => new TagItemForClient(item));
}
- async fetchAllTagsForUser() {
+ async fetchAllTagsForUser(organizationId?: number) {
const userId = this.user.getUserData()?.id;
if (!userId) {
$logger.error(`Can not fetch tags for undefined user`);
return [];
}
- const tags = await this.repository.fetchAllTagsForUser(userId);
+ const tags = await this.repository.fetchAllTagsForUser(userId, organizationId);
return tags;
}
diff --git a/api/src/tv-modules/tags/TagsRepository.ts b/api/src/tv-modules/tags/TagsRepository.ts
index f08e9ce..0d1840c 100644
--- a/api/src/tv-modules/tags/TagsRepository.ts
+++ b/api/src/tv-modules/tags/TagsRepository.ts
@@ -109,9 +109,15 @@ export class TagsRepository {
return tags.rows;
}
- async fetchAllTagsForUser(userId: number): Promise<TagsSchemaTypeForSelect[]> {
+ async fetchAllTagsForUser(userId: number, organizationId?: number): Promise<TagsSchemaTypeForSelect[]> {
+ const ownTagsConditions = [eq(TagsSchema.owner, userId)];
+ if (organizationId) {
+ ownTagsConditions.push(
+ inArray(TagsSchema.goalId, this.db.dbDrizzle.select({ id: GoalsSchema.id }).from(GoalsSchema).where(eq(GoalsSchema.organizationId, organizationId)))
+ );
+ }
const ownTags = await callWithCatch(() =>
- this.db.dbDrizzle.select().from(TagsSchema).where(eq(TagsSchema.owner, userId))
+ this.db.dbDrizzle.select().from(TagsSchema).where(and(...ownTagsConditions))
);
const allTags: TagsSchemaTypeForSelect[] = [];
@@ -120,7 +126,7 @@ export class TagsRepository {
allTags.push(...ownTags);
}
- const sharedGoals = await this.user.goalsManager.fetchSharedGoals();
+ const sharedGoals = await this.user.goalsManager.fetchSharedGoals(organizationId);
if (sharedGoals.length > 0) {
const goalIds: number[] = [];
diff --git a/api/src/tv-modules/tags/TagsRouter.ts b/api/src/tv-modules/tags/TagsRouter.ts
index 9d747ce..1d030d2 100644
--- a/api/src/tv-modules/tags/TagsRouter.ts
+++ b/api/src/tv-modules/tags/TagsRouter.ts
@@ -1,6 +1,7 @@
import { Router } from 'express';
import type { Routable } from '../../types/routable.type';
import { IsLoggedIn } from '../auth/middlewares/is-logged-in';
+import { IsOrgMemberIfProvided } from '../../middlewares/is-org-member';
import { CanAddTag } from './middlewares/CanAddTag';
import { CanDeleteTag } from './middlewares/CanDeleteTag';
import { CanToggleTag } from './middlewares/CanToggleTag';
@@ -40,7 +41,7 @@ export default class TagsRouter implements Routable {
/**
* Fetch tags for goal
*/
- this.router.get('', [IsLoggedIn], this.controller.fetchAllTagsForUser);
+ this.router.get('', [IsLoggedIn, IsOrgMemberIfProvided], this.controller.fetchAllTagsForUser);
/**
* Toggle tag for task
diff --git a/api/src/tv-modules/webhooks/WebhooksRoutes.ts b/api/src/tv-modules/webhooks/WebhooksRoutes.ts
index cf60826..e600599 100644
--- a/api/src/tv-modules/webhooks/WebhooksRoutes.ts
+++ b/api/src/tv-modules/webhooks/WebhooksRoutes.ts
@@ -1,30 +1,31 @@
-import { Router } from 'express';
-import type { Routable } from '../../types/routable.type';
-import { IsLoggedIn } from '../auth/middlewares/is-logged-in';
-import { WebhooksController } from './WebhooksController';
+import { Router } from 'express'
+import type { Routable } from '../../types/routable.type'
+import { IsLoggedIn } from '../auth/middlewares/is-logged-in'
+import { WebhooksController } from './WebhooksController'
+import { IsGoalOwnerByGoalId, IsGoalOwnerByWebhookId } from './middlewares/IsGoalOwner'
export default class WebhooksRoutes implements Routable {
- private readonly router: ReturnType<typeof Router>;
- private readonly controller: WebhooksController;
+ private readonly router: ReturnType<typeof Router>
+ private readonly controller: WebhooksController
constructor() {
- this.router = Router();
- this.controller = new WebhooksController();
- this.initRoutes();
+ this.router = Router()
+ this.controller = new WebhooksController()
+ this.initRoutes()
}
getRouter() {
- return this.router;
+ return this.router
}
initRoutes() {
- this.router.get('', [IsLoggedIn], this.controller.fetch);
- this.router.post('', [IsLoggedIn], this.controller.create);
- this.router.patch('', [IsLoggedIn], this.controller.update);
- this.router.delete('', [IsLoggedIn], this.controller.delete);
- this.router.post('/rotate-secret', [IsLoggedIn], this.controller.rotateSecret);
- this.router.post('/test', [IsLoggedIn], this.controller.testDelivery);
- this.router.get('/deliveries/:id', [IsLoggedIn], this.controller.fetchDeliveries);
- this.router.post('/retry', [IsLoggedIn], this.controller.retryDelivery);
+ this.router.get('', [IsLoggedIn, IsGoalOwnerByGoalId], this.controller.fetch)
+ this.router.post('', [IsLoggedIn, IsGoalOwnerByGoalId], this.controller.create)
+ this.router.patch('', [IsLoggedIn, IsGoalOwnerByWebhookId], this.controller.update)
+ this.router.delete('', [IsLoggedIn, IsGoalOwnerByWebhookId], this.controller.delete)
+ this.router.post('/rotate-secret', [IsLoggedIn, IsGoalOwnerByWebhookId], this.controller.rotateSecret)
+ this.router.post('/test', [IsLoggedIn, IsGoalOwnerByWebhookId], this.controller.testDelivery)
+ this.router.get('/deliveries/:id', [IsLoggedIn, IsGoalOwnerByWebhookId], this.controller.fetchDeliveries)
+ this.router.post('/retry', [IsLoggedIn, IsGoalOwnerByWebhookId], this.controller.retryDelivery)
}
}
diff --git a/api/src/tv-modules/webhooks/middlewares/IsGoalOwner.ts b/api/src/tv-modules/webhooks/middlewares/IsGoalOwner.ts
new file mode 100644
index 0000000..752df13
--- /dev/null
+++ b/api/src/tv-modules/webhooks/middlewares/IsGoalOwner.ts
@@ -0,0 +1,39 @@
+import type { NextFunction, Request, Response } from 'express'
+import { eq } from 'drizzle-orm'
+import { GoalsSchema, WebhooksSchema } from 'taskview-db-schemas'
+import { Database } from '../../../modules/db'
+
+export const IsGoalOwnerByGoalId = async (req: Request, res: Response, next: NextFunction) => {
+ const goalId = Number(req.body.goalId || req.query.goalId)
+ const userId = req.appUser.getUserData()?.id
+
+ if (!goalId || !userId) return res.status(400).end()
+
+ const db = Database.getInstance()
+ const goals = await db.dbDrizzle
+ .select({ owner: GoalsSchema.owner })
+ .from(GoalsSchema)
+ .where(eq(GoalsSchema.id, goalId))
+
+ if (!goals.length || goals[0].owner !== userId) return res.status(403).end()
+
+ next()
+}
+
+export const IsGoalOwnerByWebhookId = async (req: Request, res: Response, next: NextFunction) => {
+ const webhookId = Number(req.body.id || req.params.id)
+ const userId = req.appUser.getUserData()?.id
+
+ if (!webhookId || !userId) return res.status(400).end()
+
+ const db = Database.getInstance()
+ const result = await db.dbDrizzle
+ .select({ owner: GoalsSchema.owner })
+ .from(WebhooksSchema)
+ .innerJoin(GoalsSchema, eq(WebhooksSchema.goalId, GoalsSchema.id))
+ .where(eq(WebhooksSchema.id, webhookId))
+
+ if (!result.length || result[0].owner !== userId) return res.status(403).end()
+
+ next()
+}
diff --git a/docs/2.features/8.api-tokens.md b/docs/2.features/8.api-tokens.md
index 9042f72..a037c3f 100644
--- a/docs/2.features/8.api-tokens.md
+++ b/docs/2.features/8.api-tokens.md
@@ -43,7 +43,7 @@ By default a token inherits all permissions of its owner. You can restrict this
- **Permissions** - select which operations the token can perform (e.g. only read tasks, only create tasks)
- **Projects** - restrict the token to specific projects. If no projects are selected, the token has access to all projects the owner can access
-Permissions are **intersected** with the user's RBAC role. A token cannot have more permissions than the user who created it. See [Roles and Permissions](/collaboration/roles-and-permissions) for details on how RBAC works.
+Permissions are **intersected** with the user's RBAC role. A token cannot have more permissions than the user who created it. See [Roles and Permissions](/docs/collaboration/roles-and-permissions) for details on how RBAC works.
### Available permission examples
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index ff071d2..bcbc452 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -59,10 +59,10 @@ importers:
version: 2.0.17
'@vitejs/plugin-legacy':
specifier: ^5.4.2
'@vitejs/plugin-vue':
specifier: ^5.1.4
arktype:
specifier: 2.1.20
version: 2.1.20
@@ -195,19 +195,19 @@ importers:
version: 13.5.6
vite:
specifier: ^5.4.9
vite-plugin-node:
specifier: ^4.0.0
vitest:
specifier: ^2.1.1
taskview-packages/taskview-api:
dependencies:
vite-plugin-dts:
specifier: ^4.5.4
devDependencies:
'@testcontainers/postgresql':
specifier: ^11.7.1
@@ -232,10 +232,10 @@ importers:
version: 5.8.3
vite:
specifier: ^7.0.4
vitest:
specifier: ^3.2.4
taskview-packages/taskview-db-schemas:
dependencies:
@@ -247,7 +247,7 @@ importers:
vite-plugin-dts:
specifier: ^4.5.4
devDependencies:
drizzle-orm:
specifier: ^0.44.4
@@ -257,7 +257,35 @@ importers:
version: 5.8.3
vite:
specifier: ^7.0.4
+
+ taskview-packages/taskview-mcp:
+ dependencies:
+ '@modelcontextprotocol/sdk':
+ specifier: ^1.28.0
+ version: 1.29.0([email protected])
+ devDependencies:
+ '@types/node':
+ specifier: ^22.0.0
+ version: 22.19.7
+ axios:
+ specifier: ^1.2.3
+ version: 1.13.5
+ taskview-api:
+ specifier: workspace:*
+ version: link:../taskview-api
+ typescript:
+ specifier: ~5.8.3
+ version: 5.8.3
+ vite:
+ specifier: ^8.0.3
+ vitest:
+ specifier: ^4.1.2
+ zod:
+ specifier: ^3.23.8
+ version: 3.25.76
web:
dependencies:
@@ -314,7 +342,7 @@ importers:
version: 3.11.0
'@nuxt/ui':
specifier: ^4.4.0
'@tanstack/table-core':
specifier: ^8.21.3
version: 8.21.3
@@ -429,7 +457,7 @@ importers:
version: 22.19.7
'@vitejs/plugin-vue':
specifier: ^6.0.3
eslint:
specifier: ^9.39.2
version: 9.39.3([email protected])
@@ -447,7 +475,7 @@ importers:
vite:
specifier: ^7.3.1
vue-tsc:
specifier: ^3.2.2
version: 3.2.5([email protected])
@@ -1105,6 +1133,15 @@ packages:
resolution: {integrity: sha512-mepCf/e9+SKYy1d02/UkvSy6+6MoyXhVxP8lLDfA7BPE1X1d4dR0sZznmbM8/XVJ1GPM+Svnx7Xj6ZweByWUkw==}
engines: {node: '>17.0.0'}
+ '@emnapi/[email protected]':
+ resolution: {integrity: sha512-mukuNALVsoix/w1BJwFzwXBN/dHeejQtuVzcDsfOEsdpCumXb/E9j8w11h5S54tT1xhifGfbbSm/ICrObRb3KA==}
+
+ '@emnapi/[email protected]':
+ resolution: {integrity: sha512-VYi5+ZVLhpgK4hQ0TAjiQiZ6ol0oe4mBx7mVv7IflsiEp0OWoVsp/+f9Vc1hOhE0TtkORVrI1GvzyreqpgWtkA==}
+
+ '@emnapi/[email protected]':
+ resolution: {integrity: sha512-N10dEJNSsUx41Z6pZsXU8FjPjpBEplgH24sfkmITrBED1/U2Esum9F3lfLrMjKHHjmi557zQn7kR9R+XWXu5Rg==}
+
'@emotion/[email protected]':
resolution: {integrity: sha512-pxHCpT2ex+0q+HH91/zsdHkw/lXd468DIN2zvfvLtPKLLMo6gQj7oLObq8PhkrxOZb/gGCq03S3Z7PDhS8pduQ==}
@@ -1919,6 +1956,12 @@ packages:
engines: {node: '>=6'}
hasBin: true
+ resolution: {integrity: sha512-txsUW4SQ1iilgE0l9/e9VQWmELXifEFvmdA1j6WFh/aFPj99hIntrSsq/if0UWyGVkmrRPKA1wCeP+UCr1B9Uw==}
+ engines: {node: '>=18.14.1'}
+ peerDependencies:
+ hono: ^4
+
'@humanfs/[email protected]':
resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
engines: {node: '>=18.18.0'}
@@ -2112,6 +2155,22 @@ packages:
'@microsoft/[email protected]':
resolution: {integrity: sha512-xgAyonlVVS+q7Vc7qLW0UrJU7rSFcETRWsqdXZtjzRU8dF+6CkozTK4V4y1LwOX7j8r/vHphjDeMeGI4tNGeGA==}
+ '@modelcontextprotocol/[email protected]':
+ resolution: {integrity: sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==}
+ engines: {node: '>=18'}
+ peerDependencies:
+ '@cfworker/json-schema': ^4.1.1
+ zod: ^3.25 || ^4.0
+ peerDependenciesMeta:
+ '@cfworker/json-schema':
+ optional: true
+
+ '@napi-rs/[email protected]':
+ resolution: {integrity: sha512-sNXv5oLJ7ob93xkZ1XnxisYhGYXfaG9f65/ZgYuAu3qt7b3NadcOEhLvx28hv31PgX8SZJRYrAIPQilQmFpLVw==}
+ peerDependencies:
+ '@emnapi/core': ^1.7.1
+ '@emnapi/runtime': ^1.7.1
+
resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==}
engines: {node: ^14.21.3 || >=16}
@@ -2246,6 +2305,9 @@ packages:
cpu: [x64]
os: [win32]
+ '@oxc-project/[email protected]':
+ resolution: {integrity: sha512-oLAl5kBpV4w69UtFZ9xqcmTi+GENWOcPF7FCrczTiBbmC0ibXxCwyvZGbO39rCVEuLGAZM84DH0pUIyyv/YJzA==}
+
'@paralleldrive/[email protected]':
resolution: {integrity: sha512-XO7cAxhnTZl0Yggq6jOgjiOHhbgcO4NqFqwSmQpjK3b6TEE6Uj/jfSk6wzYyemh3+I0sHirKSetjQwn5cZktFw==}
@@ -2382,6 +2444,98 @@ packages:
'@remirror/[email protected]':
resolution: {integrity: sha512-42aWfPrimMfDKDi4YegyS7x+/0tlzaqwPQCULLanv3DMIlu96KTJR0fM5isWX2UViOqlGnX6YFgqWepcX+XMNg==}
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-pv1y2Fv0JybcykuiiD3qBOBdz6RteYojRFY1d+b95WVuzx211CRh+ytI/+9iVyWQ6koTh5dawe4S/yRfOFjgaA==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [android]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-cFYr6zTG/3PXXF3pUO+umXxt1wkRK/0AYT8lDwuqvRC+LuKYWSAQAQZjCWDQpAH172ZV6ieYrNnFzVVcnSflAg==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [darwin]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-ZCsYknnHzeXYps0lGBz8JrF37GpE9bFVefrlmDrAQhOEi4IOIlcoU1+FwHEtyXGx2VkYAvhu7dyBf75EJQffBw==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [darwin]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-dMLeprcVsyJsKolRXyoTH3NL6qtsT0Y2xeuEA8WQJquWFXkEC4bcu1rLZZSnZRMtAqwtrF/Ib9Ddtpa/Gkge9Q==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [freebsd]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-YqWjAgGC/9M1lz3GR1r1rP79nMgo3mQiiA+Hfo+pvKFK1fAJ1bCi0ZQVh8noOqNacuY1qIcfyVfP6HoyBRZ85Q==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-/I5AS4cIroLpslsmzXfwbe5OmWvSsrFuEw3mwvbQ1kDxJ822hFHIx+vsN/TAzNVyepI/j/GSzrtCIwQPeKCLIg==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-V6/wZztnBqlx5hJQqNWwFdxIKN0m38p8Jas+VoSfgH54HSj9tKTt1dZvG6JRHcjh6D7TvrJPWFGaY9UBVOaWPw==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-AP3E9BpcUYliZCxa3w5Kwj9OtEVDYK6sVoUzy4vTOJsjPOgdaJZKFmN4oOlX0Wp0RPV2ETfmIra9x1xuayFB7g==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [ppc64]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-nWwpvUSPkoFmZo0kQazZYOrT7J5DGOJ/+QHHzjvNlooDZED8oH82Yg67HvehPPLAg5fUff7TfWFHQS8IV1n3og==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [s390x]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-RNrafz5bcwRy+O9e6P8Z/OCAJW/A+qtBczIqVYwTs14pf4iV1/+eKEjdOUta93q2TsT/FI0XYDP3TCky38LMAg==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-Jpw/0iwoKWx3LJ2rc1yjFrj+T7iHZn2JDg1Yny1ma0luviFS4mhAIcd1LFNxK3EYu3DHWCps0ydXQ5i/rrJ2ig==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [linux]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-vRugONE4yMfVn0+7lUKdKvN4D5YusEiPilaoO2sgUWpCvrncvWgPMzK00ZFFJuiPgLwgFNP5eSiUlv2tfc+lpA==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [openharmony]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-ykGiLr/6kkiHc0XnBfmFJuCjr5ZYKKofkx+chJWDjitX+KsJuAmrzWhwyOMSHzPhzOHOy7u9HlFoa5MoAOJ/Zg==}
+ engines: {node: '>=14.0.0'}
+ cpu: [wasm32]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-5eOND4duWkwx1AzCxadcOrNeighiLwMInEADT0YM7xeEOOFcovWZCq8dadXgcRHSf3Ulh1kFo/qvzoFiCLOL1Q==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [arm64]
+ os: [win32]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-PyqoipaswDLAZtot351MLhrlrh6lcZPo2LSYE+VDxbVk24LVKAGOuE4hb8xZQmrPAuEtTZW8E6D2zc5EUZX4Lw==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ cpu: [x64]
+ os: [win32]
+
+ '@rolldown/[email protected]':
+ resolution: {integrity: sha512-HHMwmarRKvoFsJorqYlFeFRzXZqCt2ETQlEDOb9aqssrnVBB1/+xgTGtuTrIk5vzLNX1MjMtTf7W9z3tsSbrxw==}
+
'@rolldown/[email protected]':
resolution: {integrity: sha512-izyXV/v+cHiRfozX62W9htOAvwMo4/bXKDrQ+vom1L1qRuexPock/7VZDAhnpHCLNejd3NJ6hiab+tO0D44Rgw==}
@@ -2935,6 +3089,9 @@ packages:
'@tsconfig/[email protected]':
resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
+ '@tybys/[email protected]':
+ resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
+
resolution: {integrity: sha512-ebDJ9b0e702Yr7pWgB0jzm+CX4Srzz8RcXtLJDJB+BSccqMa36uyH/zUsSYao5+BD1ytv3k3rPYCq4mAE1hsXA==}
@@ -3352,6 +3509,9 @@ packages:
'@vitest/[email protected]':
resolution: {integrity: sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==}
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-gbu+7B0YgUJ2nkdsRJrFFW6X7NTP44WlhiclHniUhxADQJH5Szt9mZ9hWnJPJ8YwOK5zUOSSlSvyzRf0u1DSBQ==}
+
'@vitest/[email protected]':
resolution: {integrity: sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==}
peerDependencies:
@@ -3374,36 +3534,62 @@ packages:
vite:
optional: true
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-Ize4iQtEALHDttPRCmN+FKqOl2vxTiNUhzobQFFt/BM1lRUTG7zRCLOykG/6Vo4E4hnUdfVLo5/eqKPukcWW7Q==}
+ peerDependencies:
+ msw: ^2.4.9
+ vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+ peerDependenciesMeta:
+ msw:
+ optional: true
+ vite:
+ optional: true
+
'@vitest/[email protected]':
resolution: {integrity: sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==}
'@vitest/[email protected]':
resolution: {integrity: sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==}
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-dwQga8aejqeuB+TvXCMzSQemvV9hNEtDDpgUKDzOmNQayl2OG241PSWeJwKRH3CiC+sESrmoFd49rfnq7T4RnA==}
+
'@vitest/[email protected]':
resolution: {integrity: sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==}
'@vitest/[email protected]':
resolution: {integrity: sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==}
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-Gr+FQan34CdiYAwpGJmQG8PgkyFVmARK8/xSijia3eTFgVfpcpztWLuP6FttGNfPLJhaZVP/euvujeNYar36OQ==}
+
'@vitest/[email protected]':
resolution: {integrity: sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==}
'@vitest/[email protected]':
resolution: {integrity: sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==}
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-g7yfUmxYS4mNxk31qbOYsSt2F4m1E02LFqO53Xpzg3zKMhLAPZAjjfyl9e6z7HrW6LvUdTwAQR3HHfLjpko16A==}
+
'@vitest/[email protected]':
resolution: {integrity: sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==}
'@vitest/[email protected]':
resolution: {integrity: sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==}
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-DU4fBnbVCJGNBwVA6xSToNXrkZNSiw59H8tcuUspVMsBDBST4nfvsPsEHDHGtWRRnqBERBQu7TrTKskmjqTXKA==}
+
'@vitest/[email protected]':
resolution: {integrity: sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==}
'@vitest/[email protected]':
resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==}
+ '@vitest/[email protected]':
+ resolution: {integrity: sha512-xw2/TiX82lQHA06cgbqRKFb5lCAy3axQ4H4SoUFhUsg+wztiet+co86IAMDtF6Vm1hc7J6j09oh/rgDn+JdKIQ==}
+
resolution: {integrity: sha512-DjmjBWZ4tJKxfNC1F6HyYERNHPYS7L7OPFyCrestykNdUZMFYzI9WTyvwPcaNaHlrEUwESHYsfEw3isInncZxQ==}
@@ -3604,6 +3790,10 @@ packages:
resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==}
+ engines: {node: '>= 0.6'}
+
resolution: {integrity: sha512-umOSDSDrfHbTNPuNpC2NSnnA3LUrqpevPb4T9jRx4MagXNS0rs+gwiTcAvqCRmsD6utzsrzNt+ebm00SNWiC3Q==}
@@ -3670,6 +3860,9 @@ packages:
resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==}
+ resolution: {integrity: sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==}
+
resolution: {integrity: sha512-itUAVzhczTmP2U5yX67xVpsbbOiquusbWVyA9N+sy6+r6YVbFkahXvNCeEPWEOMhwDYwbVbGHFkVL03N9I5g+Q==}
@@ -3893,6 +4086,10 @@ packages:
resolution: {integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==}
engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
+ resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==}
+ engines: {node: '>=18'}
+
resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
@@ -4018,6 +4215,10 @@ packages:
resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==}
engines: {node: '>=18'}
+ resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
+ engines: {node: '>=18'}
+
resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
engines: {node: '>=4'}
@@ -4152,6 +4353,10 @@ packages:
resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==}
+ engines: {node: '>=18'}
+
resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
engines: {node: '>= 0.6'}
@@ -4234,6 +4439,10 @@ packages:
resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==}
+ resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==}
+ engines: {node: '>=6.6.0'}
+
resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==}
engines: {node: '>= 0.6'}
@@ -4893,6 +5102,9 @@ packages:
resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
+ resolution: {integrity: sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==}
+
resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
engines: {node: '>= 0.4'}
@@ -5034,6 +5246,14 @@ packages:
resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
engines: {node: '>=0.8.x'}
+ resolution: {integrity: sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==}
+ engines: {node: '>=18.0.0'}
+
+ resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==}
+ engines: {node: '>=18.0.0'}
+
resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==}
engines: {node: '>=16.17'}
@@ -5046,10 +5266,20 @@ packages:
resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
engines: {node: '>=12.0.0'}
+ resolution: {integrity: sha512-77VmFeJkO0/rvimEDuUC5H30oqUC4EyOhyGccfqoLebB0oiEYfM7nwPrsDsBL1gsTpwfzX8SFy2MT3TDyRq+bg==}
+ engines: {node: '>= 16'}
+ peerDependencies:
+ express: '>= 4.11'
+
resolution: {integrity: sha512-VqcNGcj/Id5ZT1LZ/cfihi3ttTn+NJmkli2eZADigjq29qTlWi/hAQ43t/VLPq8+UX06FCEx3ByOYet6ZFblng==}
engines: {node: '>= 0.10.0'}
+ resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==}
+ engines: {node: '>= 18'}
+
resolution: {integrity: sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA==}
@@ -5076,6 +5306,9 @@ packages:
resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
+ resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==}
+
resolution: {integrity: sha512-f2jhpN4Eccy0/Uz9csxh3Nu6q4ErKxf0XIsasomfOihuSUa3/xw6w8dnOtCDgEItQFJG8KyXPzQXzcODDrrbOg==}
@@ -5114,6 +5347,10 @@ packages:
resolution: {integrity: sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==}
engines: {node: '>= 0.8'}
+ resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==}
+ engines: {node: '>= 18.0.0'}
+
resolution: {integrity: sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==}
@@ -5210,6 +5447,10 @@ packages:
resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
+ engines: {node: '>= 0.8'}
+
resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
@@ -5449,6 +5690,10 @@ packages:
resolution: {integrity: sha512-COpmrF2NOg4TBWUJ5UVyaCU2A88wEMkUPK4hNqyCkqHbxT92BbvfjoSozkAIIm6XhicGlJHhFdullInrdhwU8Q==}
+ resolution: {integrity: sha512-wy3T8Zm2bsEvxKZM5w21VdHDDcwVS1yUFFY6i8UobSsKfFceT7TOwhbhfKsDyx7tYQlmRM5FLpIuYvNFyjctiA==}
+ engines: {node: '>=16.9.0'}
+
resolution: {integrity: sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==}
@@ -5473,6 +5718,10 @@ packages:
resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
engines: {node: '>= 0.8'}
+ resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
+ engines: {node: '>= 0.8'}
+
resolution: {integrity: sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==}
@@ -5500,6 +5749,10 @@ packages:
resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
engines: {node: '>=0.10.0'}
+ resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}
+ engines: {node: '>=0.10.0'}
+
resolution: {integrity: sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==}
@@ -5561,6 +5814,10 @@ packages:
resolution: {integrity: sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==}
engines: {node: '>=12'}
+ resolution: {integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==}
+ engines: {node: '>= 12'}
+
resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
engines: {node: '>= 0.10'}
@@ -5633,6 +5890,9 @@ packages:
resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
+ resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
+
resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
@@ -5689,6 +5949,9 @@ packages:
resolution: {integrity: sha512-1vUQX+IdDMVPj4k8kOxgUqlcK518yluMuGZwqlr44FS1ppZB/5GWh4rZG89erpOBOJjU/OBsnCVFfapsRz6nEA==}
+ resolution: {integrity: sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ==}
+
resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
@@ -5731,6 +5994,9 @@ packages:
resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
+ resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
+
resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
@@ -5816,70 +6082,140 @@ packages:
cpu: [arm64]
os: [android]
+ resolution: {integrity: sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [android]
+
resolution: {integrity: sha512-02uTEqf3vIfNMq3h/z2cJfcOXnQ0GRwQrkmPafhueLb2h7mqEidiCzkE4gBMEH65abHRiQvhdcQ+aP0D0g67sg==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [darwin]
+ resolution: {integrity: sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [darwin]
+
resolution: {integrity: sha512-1ObhyoCY+tGxtsz1lSx5NXCj3nirk0Y0kB/g8B8DT+sSx4G9djitg9ejFnjb3gJNWo7qXH4DIy2SUHvpoFwfTA==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [darwin]
+ resolution: {integrity: sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [darwin]
+
resolution: {integrity: sha512-1RINmQKAItO6ISxYgPwszQE1BrsVU5aB45ho6O42mu96UiZBxEXsuQ7cJW4zs4CEodPUioj/QrXW1r9pLUM74A==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [freebsd]
+ resolution: {integrity: sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [freebsd]
+
resolution: {integrity: sha512-OOCm2//MZJ87CdDK62rZIu+aw9gBv4azMJuA8/KB74wmfS3lnC4yoPHm0uXZ/dvNNHmnZnB8XLAZzObeG0nS1g==}
engines: {node: '>= 12.0.0'}
cpu: [arm]
os: [linux]
+ resolution: {integrity: sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm]
+ os: [linux]
+
resolution: {integrity: sha512-WKyLWztD71rTnou4xAD5kQT+982wvca7E6QoLpoawZ1gP9JM0GJj4Tp5jMUh9B3AitHbRZ2/H3W5xQmdEOUlLg==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
+ resolution: {integrity: sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [linux]
+
resolution: {integrity: sha512-mVZ7Pg2zIbe3XlNbZJdjs86YViQFoJSpc41CbVmKBPiGmC4YrfeOyz65ms2qpAobVd7WQsbW4PdsSJEMymyIMg==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
+ resolution: {integrity: sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [linux]
+
resolution: {integrity: sha512-xGlFWRMl+0KvUhgySdIaReQdB4FNudfUTARn7q0hh/V67PVGCs3ADFjw+6++kG1RNd0zdGRlEKa+T13/tQjPMA==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
+ resolution: {integrity: sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [linux]
+
resolution: {integrity: sha512-eowF8PrKHw9LpoZii5tdZwnBcYDxRw2rRCyvAXLi34iyeYfqCQNA9rmUM0ce62NlPhCvof1+9ivRaTY6pSKDaA==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
+ resolution: {integrity: sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [linux]
+
resolution: {integrity: sha512-aJReEbSEQzx1uBlQizAOBSjcmr9dCdL3XuC/6HLXAxmtErsj2ICo5yYggg1qOODQMtnjNQv2UHb9NpOuFtYe4w==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [win32]
+ resolution: {integrity: sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [arm64]
+ os: [win32]
+
resolution: {integrity: sha512-I9aiFrbd7oYHwlnQDqr1Roz+fTz61oDDJX7n9tYF9FJymH1cIN1DtKw3iYt6b8WZgEjoNwVSncwF4wx/ZedMhw==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [win32]
+ resolution: {integrity: sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==}
+ engines: {node: '>= 12.0.0'}
+ cpu: [x64]
+ os: [win32]
+
resolution: {integrity: sha512-l51N2r93WmGUye3WuFoN5k10zyvrVs0qfKBhyC5ogUQ6Ew6JUSswh78mbSO+IU3nTWsyOArqPCcShdQSadghBQ==}
engines: {node: '>= 12.0.0'}
+ resolution: {integrity: sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==}
+ engines: {node: '>= 12.0.0'}
+
resolution: {integrity: sha512-FWWMIEOxz3GwUI4Ts/IvgVy6LPvoMPgjMdQ185nN6psJyBJ4yOpzqm695/h5umdLJg2vW3GR5iG11MAkR2AzJA==}
@@ -6027,6 +6363,10 @@ packages:
resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
+ engines: {node: '>= 0.8'}
+
resolution: {integrity: sha512-pxQJQzB6djGPXh08dacEloMFopsOqGVRKFPYvPOt9XDZ1HasbgDZA74CJGreSU4G3Ak7EFJGoiH2auq+yXISgA==}
engines: {node: '>=18'}
@@ -6038,6 +6378,10 @@ packages:
resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==}
+ resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
+ engines: {node: '>=18'}
+
resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
@@ -6060,10 +6404,18 @@ packages:
resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==}
+ engines: {node: '>= 0.6'}
+
resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==}
+ engines: {node: '>=18'}
+
resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
engines: {node: '>=4'}
@@ -6216,6 +6568,10 @@ packages:
resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
+ engines: {node: '>= 0.6'}
+
resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
@@ -6466,6 +6822,9 @@ packages:
resolution: {integrity: sha512-7lf7qcQidTku0Gu3YDPc8DJ1q7OOucfa/BSsIwjuh56VU7katFvuM8hULfkwB3Fns/rsVF7PwPKVw1sl5KQS9w==}
+ resolution: {integrity: sha512-fvU78fIjZ+SBM9YwCknCvKOUKkLVqtWDVctl0s7xIqfmfb38t2TT4ZU2gHm+Z8xGwgW+QWEU3oQSAzIbo89Ggw==}
+
resolution: {integrity: sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==}
engines: {node: '>=4'}
@@ -6550,6 +6909,10 @@ packages:
resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
engines: {node: '>=12'}
+ resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
+ engines: {node: '>=12'}
+
resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
engines: {node: '>=0.10.0'}
@@ -6577,6 +6940,10 @@ packages:
resolution: {integrity: sha512-8OEwKp5juEvb/MjpIc4hjqfgCNysrS94RIOMXYvpYCdm/jglrKEiAYmiumbmGhCvs+IcInsphYDFwqrjr7398w==}
hasBin: true
+ resolution: {integrity: sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==}
+ engines: {node: '>=16.20.0'}
+
resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}
@@ -6609,6 +6976,10 @@ packages:
resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
engines: {node: ^10 || ^12 || >=14}
+ resolution: {integrity: sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==}
+ engines: {node: ^10 || ^12 || >=14}
+
resolution: {integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==}
engines: {node: '>=4'}
@@ -6811,6 +7182,10 @@ packages:
resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==}
engines: {node: '>= 0.8'}
+ resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}
+ engines: {node: '>= 0.10'}
+
resolution: {integrity: sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg==}
@@ -6971,6 +7346,11 @@ packages:
resolution: {integrity: sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg==}
+ resolution: {integrity: sha512-yP4USLIMYrwpPHEFB5JGH1uxhcslv6/hL0OyvTuY+3qlOSJvZ7ntYnoWpehBxufkgN0cvXxppuTu5hHa/zPh+A==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ hasBin: true
+
resolution: {integrity: sha512-PggGy4dhwx5qaW+CKBilA/98Ql9keyfnb7lh4SR6shQ91QQQi1ORJ1v4UinkdP2i87OBs9AQFooQylcrrRfIcg==}
engines: {node: '>=18.0.0', npm: '>=8.0.0'}
@@ -6983,6 +7363,10 @@ packages:
resolution: {integrity: sha512-SVquhBEVvRFY+nWLUc791Y0MIlyZrEClRZwZFLLRgJKldHyV1z4e2e/dp9LPqCS3AM//uq/c3PnOFgjqnm5P+A==}
engines: {node: '>=14.0'}
+ resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
+ engines: {node: '>= 18'}
+
resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
@@ -7055,6 +7439,10 @@ packages:
resolution: {integrity: sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==}
engines: {node: '>= 0.8.0'}
+ resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==}
+ engines: {node: '>= 18'}
+
resolution: {integrity: sha512-bBZaRwLH9PN5HbLCjPId4dP5bNGEtumcErgOX952IsvOhVPrm3/AeK1y0UHA/QaPG701eg0yEnOKsCOC6X/kaA==}
engines: {node: '>=20'}
@@ -7063,6 +7451,10 @@ packages:
resolution: {integrity: sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==}
engines: {node: '>= 0.8.0'}
+ resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==}
+ engines: {node: '>= 18'}
+
resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
@@ -7201,9 +7593,16 @@ packages:
resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
engines: {node: '>= 0.8'}
+ resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
+ engines: {node: '>= 0.8'}
+
resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==}
+ resolution: {integrity: sha512-zUMPtQ/HBY3/50VbpkupYHbRroTRZJPRLvreamgErJVys0ceuzMkD44J/QjqhHjOzK42GQ3QZIeFG1OYfOtKqQ==}
+
resolution: {integrity: sha512-uyQK/mx5QjHun80FLJTfaWE7JtwfRMKBLkMne6udYOmvH0CawotVa7TfgYHzAnpphn4+TweIx1QKMnRIbipmUg==}
engines: {node: '>= 0.10.0'}
@@ -7427,6 +7826,10 @@ packages:
resolution: {integrity: sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==}
engines: {node: '>=14.0.0'}
+ resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
+ engines: {node: '>=14.0.0'}
+
resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==}
engines: {node: '>=14.0.0'}
@@ -7539,6 +7942,10 @@ packages:
resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
engines: {node: '>= 0.6'}
+ resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
+ engines: {node: '>= 0.6'}
+
resolution: {integrity: sha512-wTk4DH3cxwk196uGLK/E9pE45aLfeKJacKmcEgEOA/q5dnPGNxXt0cfYdFxb57L+sEpf1oJH4Dnx/pnRcku9jg==}
@@ -7920,6 +8327,49 @@ packages:
yaml:
optional: true
+ resolution: {integrity: sha512-B9ifbFudT1TFhfltfaIPgjo9Z3mDynBTJSUYxTjOQruf/zHH+ezCQKcoqO+h7a9Pw9Nm/OtlXAiGT1axBgwqrQ==}
+ engines: {node: ^20.19.0 || >=22.12.0}
+ hasBin: true
+ peerDependencies:
+ '@types/node': ^20.19.0 || >=22.12.0
+ '@vitejs/devtools': ^0.1.0
+ esbuild: ^0.27.0
+ jiti: '>=1.21.0'
+ less: ^4.0.0
+ sass: ^1.70.0
+ sass-embedded: ^1.70.0
+ stylus: '>=0.54.8'
+ sugarss: ^5.0.0
+ terser: ^5.16.0
+ tsx: ^4.8.1
+ yaml: ^2.4.2
+ peerDependenciesMeta:
+ '@types/node':
+ optional: true
+ '@vitejs/devtools':
+ optional: true
+ esbuild:
+ optional: true
+ jiti:
+ optional: true
+ less:
+ optional: true
+ sass:
+ optional: true
+ sass-embedded:
+ optional: true
+ stylus:
+ optional: true
+ sugarss:
+ optional: true
+ terser:
+ optional: true
+ tsx:
+ optional: true
+ yaml:
+ optional: true
+
resolution: {integrity: sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==}
engines: {node: ^18.0.0 || >=20.0.0}
@@ -7973,6 +8423,41 @@ packages:
jsdom:
optional: true
+ resolution: {integrity: sha512-xjR1dMTVHlFLh98JE3i/f/WePqJsah4A0FK9cc8Ehp9Udk0AZk6ccpIZhh1qJ/yxVWRZ+Q54ocnD8TXmkhspGg==}
+ engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+ hasBin: true
+ peerDependencies:
+ '@edge-runtime/vm': '*'
+ '@opentelemetry/api': ^1.9.0
+ '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+ '@vitest/browser-playwright': 4.1.2
+ '@vitest/browser-preview': 4.1.2
+ '@vitest/browser-webdriverio': 4.1.2
+ '@vitest/ui': 4.1.2
+ happy-dom: '*'
+ jsdom: '*'
+ vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+ peerDependenciesMeta:
+ '@edge-runtime/vm':
+ optional: true
+ '@opentelemetry/api':
+ optional: true
+ '@types/node':
+ optional: true
+ '@vitest/browser-playwright':
+ optional: true
+ '@vitest/browser-preview':
+ optional: true
+ '@vitest/browser-webdriverio':
+ optional: true
+ '@vitest/ui':
+ optional: true
+ happy-dom:
+ optional: true
+ jsdom:
+ optional: true
+
resolution: {integrity: sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==}
@@ -8250,6 +8735,11 @@ packages:
resolution: {integrity: sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==}
engines: {node: '>= 14'}
+ resolution: {integrity: sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==}
+ peerDependencies:
+ zod: ^3.25.28 || ^4
+
resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
@@ -9091,6 +9581,22 @@ snapshots:
'@dagrejs/[email protected]': {}
+ '@emnapi/[email protected]':
+ dependencies:
+ '@emnapi/wasi-threads': 1.2.0
+ tslib: 2.8.1
+ optional: true
+
+ '@emnapi/[email protected]':
+ dependencies:
+ tslib: 2.8.1
+ optional: true
+
+ '@emnapi/[email protected]':
+ dependencies:
+ tslib: 2.8.1
+ optional: true
+
'@emotion/[email protected]':
dependencies:
'@babel/helper-module-imports': 7.28.6
@@ -9878,6 +10384,10 @@ snapshots:
protobufjs: 7.5.4
yargs: 17.7.2
+ dependencies:
+ hono: 4.12.9
+
'@humanfs/[email protected]': {}
'@humanfs/[email protected]':
@@ -10170,6 +10680,35 @@ snapshots:
'@microsoft/[email protected]': {}
+ '@modelcontextprotocol/[email protected]([email protected])':
+ dependencies:
+ '@hono/node-server': 1.19.12([email protected])
+ ajv: 8.18.0
+ ajv-formats: 3.0.1([email protected])
+ content-type: 1.0.5
+ cors: 2.8.6
+ cross-spawn: 7.0.6
+ eventsource: 3.0.7
+ eventsource-parser: 3.0.6
+ express: 5.2.1
+ express-rate-limit: 8.3.2([email protected])
+ hono: 4.12.9
+ jose: 6.2.2
+ json-schema-typed: 8.0.2
+ pkce-challenge: 5.0.1
+ raw-body: 3.0.2
+ zod: 3.25.76
+ zod-to-json-schema: 3.25.2([email protected])
+ transitivePeerDependencies:
+ - supports-color
+
+ dependencies:
+ '@emnapi/core': 1.9.1
+ '@emnapi/runtime': 1.9.1
+ '@tybys/wasm-util': 0.10.1
+ optional: true
+
'@noble/[email protected]': {}
'@nodelib/[email protected]':
@@ -10184,24 +10723,24 @@ snapshots:
'@nodelib/fs.scandir': 2.1.5
fastq: 1.20.1
dependencies:
'@nuxt/kit': 4.3.1
execa: 8.0.1
transitivePeerDependencies:
- magicast
dependencies:
'@nuxt/kit': 4.3.1
consola: 3.4.2
css-tree: 3.1.0
defu: 6.1.4
esbuild: 0.25.12
fontaine: 0.7.0
h3: 1.15.5
jiti: 2.6.1
magic-regexp: 0.10.0
@@ -10238,13 +10777,13 @@ snapshots:
- uploadthing
- vite
dependencies:
'@iconify/collections': 1.0.653
'@iconify/types': 2.0.0
'@iconify/utils': 3.1.0
'@iconify/vue': 5.0.0([email protected]([email protected]))
'@nuxt/kit': 4.3.1
consola: 3.4.2
local-pkg: 1.1.2
@@ -10318,20 +10857,20 @@ snapshots:
pkg-types: 2.3.0
std-env: 3.10.0
dependencies:
'@floating-ui/dom': 1.7.4
'@iconify/vue': 5.0.0([email protected]([email protected]))
'@internationalized/date': 3.11.0
'@internationalized/number': 3.6.5
'@nuxt/kit': 4.3.1
'@nuxt/schema': 4.3.1
'@nuxtjs/color-mode': 3.5.2
'@standard-schema/spec': 1.1.0
'@tailwindcss/postcss': 4.2.0
'@tanstack/vue-table': 8.21.3([email protected]([email protected]))
'@tanstack/vue-virtual': 3.13.18([email protected]([email protected]))
'@tiptap/core': 3.20.0(@tiptap/[email protected])
@@ -10476,6 +11015,8 @@ snapshots:
optional: true
+ '@oxc-project/[email protected]': {}
+
'@paralleldrive/[email protected]':
dependencies:
'@noble/hashes': 1.8.0
@@ -10524,7 +11065,7 @@ snapshots:
detect-libc: 2.1.2
is-glob: 4.0.3
node-addon-api: 7.1.1
- picomatch: 4.0.3
+ picomatch: 4.0.4
optionalDependencies:
'@parcel/watcher-android-arm64': 2.5.6
'@parcel/watcher-darwin-arm64': 2.5.6
@@ -10582,6 +11123,58 @@ snapshots:
'@remirror/[email protected]': {}
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ dependencies:
+ '@napi-rs/wasm-runtime': 1.1.2(@emnapi/[email protected])(@emnapi/[email protected])
+ transitivePeerDependencies:
+ - '@emnapi/core'
+ - '@emnapi/runtime'
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]':
+ optional: true
+
+ '@rolldown/[email protected]': {}
+
'@rolldown/[email protected]': {}
@@ -10808,12 +11401,12 @@ snapshots:
postcss: 8.5.6
tailwindcss: 4.2.0
dependencies:
'@tailwindcss/node': 4.2.0
'@tailwindcss/oxide': 4.2.0
tailwindcss: 4.2.0
'@tanstack/[email protected]': {}
@@ -11136,18 +11729,23 @@ snapshots:
'@tsconfig/[email protected]': {}
+ '@tybys/[email protected]':
+ dependencies:
+ tslib: 2.8.1
+ optional: true
+
'@types/[email protected]': {}
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/[email protected]': {}
dependencies:
'@types/connect': 3.4.38
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
optional: true
@@ -11159,7 +11757,7 @@ snapshots:
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
dependencies:
@@ -11167,7 +11765,7 @@ snapshots:
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/[email protected]': {}
@@ -11304,20 +11902,20 @@ snapshots:
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/ssh2': 1.15.5
dependencies:
'@types/docker-modem': 3.0.6
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/ssh2': 1.15.5
'@types/[email protected]': {}
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/qs': 6.14.0
'@types/range-parser': 1.2.7
'@types/send': 1.2.1
@@ -11331,7 +11929,7 @@ snapshots:
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/[email protected]': {}
@@ -11342,7 +11940,7 @@ snapshots:
dependencies:
'@types/ms': 2.1.0
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
dependencies:
@@ -11385,12 +11983,13 @@ snapshots:
dependencies:
undici-types: 7.18.2
+ optional: true
'@types/[email protected]': {}
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/[email protected]': {}
@@ -11425,7 +12024,7 @@ snapshots:
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
pg-protocol: 1.11.0
pg-types: 2.2.0
@@ -11448,16 +12047,16 @@ snapshots:
dependencies:
'@types/mime': 1.3.5
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
dependencies:
'@types/http-errors': 2.0.5
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/send': 0.17.6
'@types/[email protected]': {}
@@ -11468,7 +12067,7 @@ snapshots:
dependencies:
- '@types/node': 25.3.0
+ '@types/node': 22.19.7
'@types/ssh2-streams': 0.1.13
@@ -11703,7 +12302,7 @@ snapshots:
'@unovis/ts': 1.6.4
vue: 3.5.27([email protected])
dependencies:
'@babel/core': 7.28.6
'@babel/preset-env': 7.28.6(@babel/[email protected])
@@ -11714,19 +12313,19 @@ snapshots:
regenerator-runtime: 0.14.1
systemjs: 6.15.1
terser: 5.46.0
transitivePeerDependencies:
- supports-color
dependencies:
vue: 3.5.27([email protected])
dependencies:
'@rolldown/pluginutils': 1.0.0-rc.2
vue: 3.5.27([email protected])
'@vitest/[email protected]':
@@ -11744,21 +12343,38 @@ snapshots:
chai: 5.3.3
tinyrainbow: 2.0.0
+ '@vitest/[email protected]':
+ dependencies:
+ '@standard-schema/spec': 1.1.0
+ '@types/chai': 5.2.3
+ '@vitest/spy': 4.1.2
+ '@vitest/utils': 4.1.2
+ chai: 6.2.2
+ tinyrainbow: 3.1.0
+
dependencies:
'@vitest/spy': 2.1.9
estree-walker: 3.0.3
magic-string: 0.30.21
optionalDependencies:
dependencies:
'@vitest/spy': 3.2.4
estree-walker: 3.0.3
magic-string: 0.30.21
optionalDependencies:
+
+ dependencies:
+ '@vitest/spy': 4.1.2
+ estree-walker: 3.0.3
+ magic-string: 0.30.21
+ optionalDependencies:
'@vitest/[email protected]':
dependencies:
@@ -11768,6 +12384,10 @@ snapshots:
dependencies:
tinyrainbow: 2.0.0
+ '@vitest/[email protected]':
+ dependencies:
+ tinyrainbow: 3.1.0
+
'@vitest/[email protected]':
dependencies:
'@vitest/utils': 2.1.9
@@ -11779,6 +12399,11 @@ snapshots:
pathe: 2.0.3
strip-literal: 3.1.0
+ '@vitest/[email protected]':
+ dependencies:
+ '@vitest/utils': 4.1.2
+ pathe: 2.0.3
+
'@vitest/[email protected]':
dependencies:
'@vitest/pretty-format': 2.1.9
@@ -11791,6 +12416,13 @@ snapshots:
magic-string: 0.30.21
pathe: 2.0.3
+ '@vitest/[email protected]':
+ dependencies:
+ '@vitest/pretty-format': 4.1.2
+ '@vitest/utils': 4.1.2
+ magic-string: 0.30.21
+ pathe: 2.0.3
+
'@vitest/[email protected]':
dependencies:
tinyspy: 3.0.2
@@ -11799,6 +12431,8 @@ snapshots:
dependencies:
tinyspy: 4.0.4
+ '@vitest/[email protected]': {}
+
'@vitest/[email protected]':
dependencies:
'@vitest/pretty-format': 2.1.9
@@ -11811,6 +12445,12 @@ snapshots:
loupe: 3.2.1
tinyrainbow: 2.0.0
+ '@vitest/[email protected]':
+ dependencies:
+ '@vitest/pretty-format': 4.1.2
+ convert-source-map: 2.0.0
+ tinyrainbow: 3.1.0
+
dependencies:
'@volar/source-map': 2.4.27
@@ -12043,6 +12683,11 @@ snapshots:
mime-types: 2.1.35
negotiator: 0.6.3
+ dependencies:
+ mime-types: 3.0.2
+ negotiator: 1.0.0
+
dependencies:
acorn: 8.16.0
@@ -12095,6 +12740,10 @@ snapshots:
optionalDependencies:
ajv: 8.13.0
+ optionalDependencies:
+ ajv: 8.18.0
+
dependencies:
fast-deep-equal: 3.1.3
@@ -12116,6 +12765,13 @@ snapshots:
require-from-string: 2.0.2
uri-js: 4.4.1
+ dependencies:
+ fast-deep-equal: 3.1.3
+ fast-uri: 3.1.0
+ json-schema-traverse: 1.0.0
+ require-from-string: 2.0.2
+
@@ -12361,6 +13017,20 @@ snapshots:
transitivePeerDependencies:
- supports-color
+ dependencies:
+ bytes: 3.1.2
+ content-type: 1.0.5
+ debug: 4.4.3
+ http-errors: 2.0.0
+ iconv-lite: 0.7.2
+ on-finished: 2.4.1
+ qs: 6.14.1
+ raw-body: 3.0.2
+ type-is: 2.0.1
+ transitivePeerDependencies:
+ - supports-color
+
@@ -12509,6 +13179,8 @@ snapshots:
loupe: 3.2.1
pathval: 2.0.1
+
dependencies:
ansi-styles: 3.2.1
@@ -12636,6 +13308,8 @@ snapshots:
dependencies:
safe-buffer: 5.2.1
+
@@ -12750,6 +13424,8 @@ snapshots:
+
@@ -13302,6 +13978,8 @@ snapshots:
+
dependencies:
es-errors: 1.3.0
@@ -13531,6 +14209,12 @@ snapshots:
+
+ dependencies:
+ eventsource-parser: 3.0.6
+
dependencies:
cross-spawn: 7.0.6
@@ -13547,6 +14231,11 @@ snapshots:
+ dependencies:
+ express: 5.2.1
+ ip-address: 10.1.0
+
dependencies:
accepts: 1.3.8
@@ -13583,6 +14272,39 @@ snapshots:
transitivePeerDependencies:
- supports-color
+ dependencies:
+ accepts: 2.0.0
+ body-parser: 2.2.2
+ content-disposition: 1.0.1
+ content-type: 1.0.5
+ cookie: 0.7.2
+ cookie-signature: 1.2.2
+ debug: 4.4.3
+ depd: 2.0.0
+ encodeurl: 2.0.0
+ escape-html: 1.0.3
+ etag: 1.8.1
+ finalhandler: 2.1.1
+ fresh: 2.0.0
+ http-errors: 2.0.0
+ merge-descriptors: 2.0.0
+ mime-types: 3.0.2
+ on-finished: 2.4.1
+ once: 1.4.0
+ parseurl: 1.3.3
+ proxy-addr: 2.0.7
+ qs: 6.14.1
+ range-parser: 1.2.1
+ router: 2.2.0
+ send: 1.2.1
+ serve-static: 2.2.1
+ statuses: 2.0.1
+ type-is: 2.0.1
+ vary: 1.1.2
+ transitivePeerDependencies:
+ - supports-color
+
@@ -13606,6 +14328,8 @@ snapshots:
+
dependencies:
path-expression-matcher: 1.1.3
@@ -13654,6 +14378,17 @@ snapshots:
transitivePeerDependencies:
- supports-color
+ dependencies:
+ debug: 4.4.3
+ encodeurl: 2.0.0
+ escape-html: 1.0.3
+ on-finished: 2.4.1
+ parseurl: 1.3.3
+ statuses: 2.0.1
+ transitivePeerDependencies:
+ - supports-color
+
@@ -13752,7 +14487,7 @@ snapshots:
unicode-properties: 1.4.1
unicode-trie: 2.0.0
dependencies:
consola: 3.4.2
css-tree: 3.1.0
@@ -13768,7 +14503,7 @@ snapshots:
unifont: 0.6.0
unstorage: 1.17.4(@capacitor/[email protected](@capacitor/[email protected]))
optionalDependencies:
transitivePeerDependencies:
- '@azure/app-configuration'
- '@azure/cosmos'
@@ -13833,6 +14568,8 @@ snapshots:
+
@@ -14137,6 +14874,8 @@ snapshots:
+
@@ -14163,6 +14902,14 @@ snapshots:
statuses: 2.0.1
toidentifier: 1.0.1
+ dependencies:
+ depd: 2.0.0
+ inherits: 2.0.4
+ setprototypeof: 1.2.0
+ statuses: 2.0.2
+ toidentifier: 1.0.1
+
@@ -14200,6 +14947,10 @@ snapshots:
dependencies:
safer-buffer: 2.1.2
+ dependencies:
+ safer-buffer: 2.1.2
+
@@ -14241,6 +14992,8 @@ snapshots:
+
@@ -14293,6 +15046,8 @@ snapshots:
optional: true
+
dependencies:
'@types/estree': 1.0.8
@@ -14342,6 +15097,8 @@ snapshots:
+
@@ -14401,6 +15158,8 @@ snapshots:
+
@@ -14489,36 +15248,69 @@ snapshots:
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
optional: true
+ optional: true
+
dependencies:
detect-libc: 2.1.2
@@ -14535,6 +15327,22 @@ snapshots:
lightningcss-win32-arm64-msvc: 1.31.1
lightningcss-win32-x64-msvc: 1.31.1
+ dependencies:
+ detect-libc: 2.1.2
+ optionalDependencies:
+ lightningcss-android-arm64: 1.32.0
+ lightningcss-darwin-arm64: 1.32.0
+ lightningcss-darwin-x64: 1.32.0
+ lightningcss-freebsd-x64: 1.32.0
+ lightningcss-linux-arm-gnueabihf: 1.32.0
+ lightningcss-linux-arm64-gnu: 1.32.0
+ lightningcss-linux-arm64-musl: 1.32.0
+ lightningcss-linux-x64-gnu: 1.32.0
+ lightningcss-linux-x64-musl: 1.32.0
+ lightningcss-win32-arm64-msvc: 1.32.0
+ lightningcss-win32-x64-msvc: 1.32.0
+
@@ -14690,6 +15498,8 @@ snapshots:
+
@@ -14708,6 +15518,8 @@ snapshots:
+
@@ -14727,10 +15539,16 @@ snapshots:
+
dependencies:
mime-db: 1.52.0
+ dependencies:
+ mime-db: 1.54.0
+
@@ -14873,6 +15691,8 @@ snapshots:
+
@@ -15113,6 +15933,8 @@ snapshots:
+
dependencies:
pify: 3.0.0
@@ -15187,6 +16009,8 @@ snapshots:
+
@@ -15221,6 +16045,8 @@ snapshots:
sonic-boom: 4.2.0
thread-stream: 3.1.0
+
dependencies:
confbox: 0.1.8
@@ -15260,6 +16086,12 @@ snapshots:
picocolors: 1.1.1
source-map-js: 1.2.1
+ dependencies:
+ nanoid: 3.3.11
+ picocolors: 1.1.1
+ source-map-js: 1.2.1
+
@@ -15498,6 +16330,13 @@ snapshots:
iconv-lite: 0.4.24
unpipe: 1.0.0
+ dependencies:
+ bytes: 3.1.2
+ http-errors: 2.0.1
+ iconv-lite: 0.7.2
+ unpipe: 1.0.0
+
dependencies:
defu: 6.1.4
@@ -15687,6 +16526,30 @@ snapshots:
+ dependencies:
+ '@oxc-project/types': 0.122.0
+ '@rolldown/pluginutils': 1.0.0-rc.12
+ optionalDependencies:
+ '@rolldown/binding-android-arm64': 1.0.0-rc.12
+ '@rolldown/binding-darwin-arm64': 1.0.0-rc.12
+ '@rolldown/binding-darwin-x64': 1.0.0-rc.12
+ '@rolldown/binding-freebsd-x64': 1.0.0-rc.12
+ '@rolldown/binding-linux-arm-gnueabihf': 1.0.0-rc.12
+ '@rolldown/binding-linux-arm64-gnu': 1.0.0-rc.12
+ '@rolldown/binding-linux-arm64-musl': 1.0.0-rc.12
+ '@rolldown/binding-linux-ppc64-gnu': 1.0.0-rc.12
+ '@rolldown/binding-linux-s390x-gnu': 1.0.0-rc.12
+ '@rolldown/binding-linux-x64-gnu': 1.0.0-rc.12
+ '@rolldown/binding-linux-x64-musl': 1.0.0-rc.12
+ '@rolldown/binding-openharmony-arm64': 1.0.0-rc.12
+ '@rolldown/binding-wasm32-wasi': 1.0.0-rc.12(@emnapi/[email protected])(@emnapi/[email protected])
+ '@rolldown/binding-win32-arm64-msvc': 1.0.0-rc.12
+ '@rolldown/binding-win32-x64-msvc': 1.0.0-rc.12
+ transitivePeerDependencies:
+ - '@emnapi/core'
+ - '@emnapi/runtime'
+
dependencies:
'@types/estree': 1.0.8
@@ -15722,6 +16585,16 @@ snapshots:
+ dependencies:
+ debug: 4.4.3
+ depd: 2.0.0
+ is-promise: 4.0.0
+ parseurl: 1.3.3
+ path-to-regexp: 8.4.1
+ transitivePeerDependencies:
+ - supports-color
+
dependencies:
queue-microtask: 1.2.3
@@ -15794,6 +16667,22 @@ snapshots:
transitivePeerDependencies:
- supports-color
+ dependencies:
+ debug: 4.4.3
+ encodeurl: 2.0.0
+ escape-html: 1.0.3
+ etag: 1.8.1
+ fresh: 2.0.0
+ http-errors: 2.0.1
+ mime-types: 3.0.2
+ ms: 2.1.3
+ on-finished: 2.4.1
+ range-parser: 1.2.1
+ statuses: 2.0.2
+ transitivePeerDependencies:
+ - supports-color
+
dependencies:
non-error: 0.1.0
@@ -15808,6 +16697,15 @@ snapshots:
transitivePeerDependencies:
- supports-color
+ dependencies:
+ encodeurl: 2.0.0
+ escape-html: 1.0.3
+ parseurl: 1.3.3
+ send: 1.2.1
+ transitivePeerDependencies:
+ - supports-color
+
@@ -15972,8 +16870,12 @@ snapshots:
+
+
@@ -16164,7 +17066,7 @@ snapshots:
dependencies:
'@jridgewell/source-map': 0.3.11
- acorn: 8.15.0
+ acorn: 8.16.0
commander: 2.20.3
source-map-support: 0.5.21
@@ -16239,6 +17141,8 @@ snapshots:
+
@@ -16337,6 +17241,12 @@ snapshots:
media-typer: 0.3.0
mime-types: 2.1.35
+ dependencies:
+ content-type: 1.0.5
+ media-typer: 1.1.0
+ mime-types: 3.0.2
+
@@ -16390,7 +17300,8 @@ snapshots:
+ optional: true
@@ -16434,7 +17345,7 @@ snapshots:
magic-string: 0.30.21
mlly: 1.8.0
pathe: 2.0.3
- picomatch: 4.0.3
+ picomatch: 4.0.4
pkg-types: 2.3.0
scule: 1.3.0
strip-literal: 3.1.0
@@ -16470,7 +17381,7 @@ snapshots:
dependencies:
pathe: 2.0.3
- picomatch: 4.0.3
+ picomatch: 4.0.4
dependencies:
@@ -16576,13 +17487,13 @@ snapshots:
transitivePeerDependencies:
- '@vue/composition-api'
dependencies:
cac: 6.7.14
debug: 4.4.3
es-module-lexer: 1.7.0
pathe: 1.1.2
transitivePeerDependencies:
- '@types/node'
- less
@@ -16594,13 +17505,13 @@ snapshots:
- supports-color
- terser
dependencies:
cac: 6.7.14
debug: 4.4.3
es-module-lexer: 1.7.0
pathe: 2.0.3
transitivePeerDependencies:
- '@types/node'
- jiti
@@ -16615,7 +17526,7 @@ snapshots:
- tsx
- yaml
dependencies:
'@microsoft/api-extractor': 7.55.2(@types/[email protected])
'@rollup/pluginutils': 5.3.0([email protected])
@@ -16628,22 +17539,22 @@ snapshots:
magic-string: 0.30.21
typescript: 5.8.3
optionalDependencies:
transitivePeerDependencies:
- '@types/node'
- rollup
- supports-color
dependencies:
'@rollup/pluginutils': 4.2.1
chalk: 4.1.2
debug: 4.4.3
transitivePeerDependencies:
- supports-color
dependencies:
esbuild: 0.21.5
postcss: 8.5.6
@@ -16651,11 +17562,11 @@ snapshots:
optionalDependencies:
'@types/node': 22.19.7
fsevents: 2.3.3
- lightningcss: 1.31.1
+ lightningcss: 1.32.0
sass: 1.97.2
terser: 5.46.0
dependencies:
esbuild: 0.27.2
fdir: 6.5.0([email protected])
@@ -16667,13 +17578,13 @@ snapshots:
'@types/node': 22.19.7
fsevents: 2.3.3
jiti: 2.6.1
- lightningcss: 1.31.1
+ lightningcss: 1.32.0
sass: 1.97.2
terser: 5.46.0
tsx: 4.21.0
yaml: 2.8.2
dependencies:
esbuild: 0.27.2
fdir: 6.5.0([email protected])
@@ -16685,16 +17596,36 @@ snapshots:
'@types/node': 25.3.0
fsevents: 2.3.3
jiti: 2.6.1
- lightningcss: 1.31.1
+ lightningcss: 1.32.0
+ sass: 1.97.2
+ terser: 5.46.0
+ tsx: 4.21.0
+ yaml: 2.8.2
+
+ dependencies:
+ lightningcss: 1.32.0
+ picomatch: 4.0.4
+ postcss: 8.5.8
+ rolldown: 1.0.0-rc.12(@emnapi/[email protected])(@emnapi/[email protected])
+ tinyglobby: 0.2.15
+ optionalDependencies:
+ '@types/node': 22.19.7
+ esbuild: 0.27.2
+ fsevents: 2.3.3
+ jiti: 2.6.1
sass: 1.97.2
terser: 5.46.0
tsx: 4.21.0
yaml: 2.8.2
+ transitivePeerDependencies:
+ - '@emnapi/core'
+ - '@emnapi/runtime'
dependencies:
'@vitest/expect': 2.1.9
'@vitest/pretty-format': 2.1.9
'@vitest/runner': 2.1.9
'@vitest/snapshot': 2.1.9
@@ -16710,8 +17641,8 @@ snapshots:
tinyexec: 0.3.2
tinypool: 1.1.1
tinyrainbow: 1.2.0
why-is-node-running: 2.3.0
optionalDependencies:
'@types/node': 22.19.7
@@ -16727,11 +17658,11 @@ snapshots:
- supports-color
- terser
dependencies:
'@types/chai': 5.2.3
'@vitest/expect': 3.2.4
'@vitest/pretty-format': 3.2.4
'@vitest/runner': 3.2.4
'@vitest/snapshot': 3.2.4
@@ -16749,8 +17680,8 @@ snapshots:
tinyglobby: 0.2.15
tinypool: 1.1.1
tinyrainbow: 2.0.0
why-is-node-running: 2.3.0
optionalDependencies:
'@types/node': 25.3.0
@@ -16769,6 +17700,35 @@ snapshots:
- tsx
- yaml
+ dependencies:
+ '@vitest/expect': 4.1.2
+ '@vitest/pretty-format': 4.1.2
+ '@vitest/runner': 4.1.2
+ '@vitest/snapshot': 4.1.2
+ '@vitest/spy': 4.1.2
+ '@vitest/utils': 4.1.2
+ es-module-lexer: 2.0.0
+ expect-type: 1.3.0
+ magic-string: 0.30.21
+ obug: 2.1.1
+ pathe: 2.0.3
+ picomatch: 4.0.4
+ std-env: 4.0.0
+ tinybench: 2.9.0
+ tinyexec: 1.0.2
+ tinyglobby: 0.2.15
+ tinyrainbow: 3.1.0
+ why-is-node-running: 2.3.0
+ optionalDependencies:
+ '@opentelemetry/api': 1.9.0
+ '@types/node': 22.19.7
+ jsdom: 20.0.3
+ transitivePeerDependencies:
+ - msw
+
@@ -17041,6 +18001,10 @@ snapshots:
compress-commons: 6.0.2
readable-stream: 4.7.0
+ dependencies:
+ zod: 3.25.76
+
diff --git a/taskview-packages/taskview-api/example/package.json b/taskview-packages/taskview-api/example/package.json
index bda49a9..dc4c3e3 100644
--- a/taskview-packages/taskview-api/example/package.json
+++ b/taskview-packages/taskview-api/example/package.json
@@ -8,7 +8,7 @@
},
"dependencies": {
"taskview-api": "latest",
- "axios": "^1.2.3",
+ "axios": "1.13.5",
"tsx": "^4.19.0"
}
}
diff --git a/taskview-packages/taskview-api/package.json b/taskview-packages/taskview-api/package.json
index f7fa7d6..2af7260 100644
--- a/taskview-packages/taskview-api/package.json
+++ b/taskview-packages/taskview-api/package.json
@@ -22,11 +22,14 @@
"build-watch": "tsc && vite build --watch",
"preview": "vite preview",
"type-check": "tsc --noEmit",
- "test": "vitest"
+ "test": "vitest",
+ "test:build-images": "bash src/api/__tests__/docker/build-test-images.sh",
+ "test:docker": "bash src/api/__tests__/docker/run-tests.sh",
+ "test:run": "bash src/api/__tests__/docker/run-tests-only.sh"
},
"devDependencies": {
"@testcontainers/postgresql": "^11.7.1",
- "axios": "^1.2.3",
+ "axios": "1.13.5",
"bun": "^1.3.0",
"testcontainers": "^11.7.1",
"typescript": "~5.8.3",
diff --git a/taskview-packages/taskview-api/src/api/__tests__/.env.for-test b/taskview-packages/taskview-api/src/api/__tests__/.env.for-test
index c971d34..f8339e4 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/.env.for-test
+++ b/taskview-packages/taskview-api/src/api/__tests__/.env.for-test
@@ -1,5 +1,5 @@
DB_HOST=localhost
-DB_USER=postgres
-DB_PASSWORD=12345678pqow
-DB_NAME=tv_3_dev_db
-DB_PORT=5432
\ No newline at end of file
+DB_USER=tvdbuser
+DB_PASSWORD=tvdbpass
+DB_NAME=taskviewdb
+DB_PORT=15432
\ No newline at end of file
diff --git a/taskview-packages/taskview-api/src/api/__tests__/.env.postgresql b/taskview-packages/taskview-api/src/api/__tests__/.env.postgresql
deleted file mode 100644
index 7b3b571..0000000
--- a/taskview-packages/taskview-api/src/api/__tests__/.env.postgresql
+++ /dev/null
@@ -1,8 +0,0 @@
-POSTGRES_USER="tv-test-db-user"
-POSTGRES_PASSWORD="tv-test-db-pass"
-POSTGRES_DB="task_view_test_db"
-LANG=C.UTF-8
-LC_ALL=C.UTF-8
-POSTGRES_INITDB_ARGS=--locale=C.UTF-8
-TZ=UTC
-PGTZ=UTC
\ No newline at end of file
diff --git a/taskview-packages/taskview-api/src/api/__tests__/.env.taskview b/taskview-packages/taskview-api/src/api/__tests__/.env.taskview
deleted file mode 100644
index 796104b..0000000
--- a/taskview-packages/taskview-api/src/api/__tests__/.env.taskview
+++ /dev/null
@@ -1,21 +0,0 @@
-DB_HOST="db"
-DB_USER="tv-test-db-user"
-DB_PASSWORD="tv-test-db-pass"
-DB_NAME="task_view_test_db"
-DB_PORT=5432
-APP_PORT=1401
-JWT_ALG="HS256"
-JWT_SIGN="cnxcv&89e&63#"
-ACCESS_LIFE_TIME="3d"
-REFRESH_LIFE_TIME="9d"
-
-SMTP_HOST="smtp"
-SMTP_PORT=465
-SMTP_USERNAME= "smtp-user-here"
-SMTP_PASSWORD="smtp-password"
-SMTP_ENCRYPTION="ssl"
-SMTP_FROM_NAME="TaskViewApiServer"
-SMTP_FROM_EMAIL="smtp"
-
-# Constant value
-APP_URL="https://taskview.handscream.com"
\ No newline at end of file
diff --git a/taskview-packages/taskview-api/src/api/__tests__/api-tokens.test.ts b/taskview-packages/taskview-api/src/api/__tests__/api-tokens.test.ts
index c1d5f19..69be2af 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/api-tokens.test.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/api-tokens.test.ts
@@ -354,6 +354,142 @@ describe('API Tokens', () => {
await $api.apiTokens.delete(created!.item.id);
});
+ it('should deny fetching tasks from non-allowed goal', async () => {
+ const created = await $api.apiTokens.create({
+ name: 'Goal fetch restricted',
+ allowedGoalIds: [goalId],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.fetch({
+ goalId: goalId2,
+ page: 0,
+ showCompleted: 0,
+ firstNew: 0,
+ componentId: ALL_TASKS_LIST_ID,
+ }).catch((err) => err.status);
+
+ expect(status).toBe(403);
+
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny updating task in non-allowed goal', async () => {
+ const task = await $api.tasks.createTask({
+ goalId: goalId2,
+ description: `Restricted update-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'Goal update restricted',
+ allowedGoalIds: [goalId],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.updateTask({
+ id: task!.id,
+ description: 'Hacked',
+ }).catch((err) => err.status);
+
+ expect(status).toBe(403);
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny deleting task in non-allowed goal', async () => {
+ const task = await $api.tasks.createTask({
+ goalId: goalId2,
+ description: `Restricted delete-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'Goal delete restricted',
+ allowedGoalIds: [goalId],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.deleteTask(task!.id).catch((err) => err.status);
+ expect(status).toBe(403);
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny fetching task by id from non-allowed goal', async () => {
+ const task = await $api.tasks.createTask({
+ goalId: goalId2,
+ description: `Restricted fetch by id-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'Goal fetchById restricted',
+ allowedGoalIds: [goalId],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.fetchTaskById(task!.id).catch((err) => err.status);
+ expect(status).toBeGreaterThanOrEqual(400);
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny fetching lists from non-allowed goal', async () => {
+ const created = await $api.apiTokens.create({
+ name: 'Goal lists restricted',
+ allowedGoalIds: [goalId],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.goalLists.fetchLists({ goalId: goalId2 }).catch((err) => err.status);
+ expect(status).toBeGreaterThanOrEqual(400);
+
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny fetching goals not in allowedGoalIds', async () => {
+ const created = await $api.apiTokens.create({
+ name: 'Goal list restricted',
+ allowedGoalIds: [goalId],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const goals = await tokenApi.goals.fetchGoals();
+ expect(goals).toBeDefined();
+
+ const hasAllowed = goals!.some(g => g.id === goalId);
+ const hasRestricted = goals!.some(g => g.id === goalId2);
+ expect(hasAllowed).toBe(true);
+ expect(hasRestricted).toBe(false);
+
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
it('should allow all goals when allowedGoalIds is empty', async () => {
const created = await $api.apiTokens.create({
name: 'All goals token',
@@ -405,6 +541,302 @@ describe('API Tokens', () => {
});
});
+ describe('Combined permission and goal scoping', () => {
+ it('should restrict both permissions and goals simultaneously', async () => {
+ const created = await $api.apiTokens.create({
+ name: 'Combined scope token',
+ allowedPermissions: ['component_can_watch_content'],
+ allowedGoalIds: [goalId],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ // can read tasks in allowed goal
+ const tasks = await tokenApi.tasks.fetch({
+ goalId,
+ page: 0,
+ showCompleted: 0,
+ firstNew: 0,
+ componentId: ALL_TASKS_LIST_ID,
+ });
+ expect(tasks).toBeDefined();
+
+ // cannot create tasks (no component_can_add_tasks)
+ const createStatus = await tokenApi.tasks.createTask({
+ goalId,
+ description: 'Should fail',
+ }).catch((err) => err.status);
+ expect(createStatus).toBe(403);
+
+ // cannot read tasks in non-allowed goal
+ const fetchStatus = await tokenApi.tasks.fetch({
+ goalId: goalId2,
+ page: 0,
+ showCompleted: 0,
+ firstNew: 0,
+ componentId: ALL_TASKS_LIST_ID,
+ }).catch((err) => err.status);
+ expect(fetchStatus).toBe(403);
+
+ await $api.apiTokens.delete(created!.item.id);
+ });
+ });
+
+ describe('Task field permission scoping', () => {
+ it('should deny note edit without task_can_edit_note', async () => {
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Note perm test-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'No note token',
+ allowedPermissions: ['component_can_watch_content', 'task_can_edit_description'],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.updateTask({
+ id: task!.id,
+ note: 'Should fail',
+ }).catch((err) => err.status);
+ expect(status).toBe(403);
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should allow note edit with task_can_edit_note', async () => {
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Note allowed test-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'Note token',
+ allowedPermissions: ['component_can_watch_content', 'task_can_edit_note', 'task_can_watch_note'],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const updated = await tokenApi.tasks.updateTask({
+ id: task!.id,
+ note: 'Updated note',
+ });
+ expect(updated).toBeDefined();
+ expect(updated!.note).toBe('Updated note');
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny priority edit without task_can_edit_priority', async () => {
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Priority perm test-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'No priority token',
+ allowedPermissions: ['component_can_watch_content'],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.updateTask({
+ id: task!.id,
+ priorityId: 2,
+ }).catch((err) => err.status);
+ expect(status).toBe(403);
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny status toggle without task_can_edit_status', async () => {
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Status perm test-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'No status token',
+ allowedPermissions: ['component_can_watch_content'],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.updateTask({
+ id: task!.id,
+ complete: true,
+ }).catch((err) => err.status);
+ expect(status).toBe(403);
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should deny deadline edit without task_can_edit_deadline', async () => {
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Deadline perm test-${Date.now()}`,
+ });
+
+ const created = await $api.apiTokens.create({
+ name: 'No deadline token',
+ allowedPermissions: ['component_can_watch_content'],
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.updateTask({
+ id: task!.id,
+ startDate: '2025-06-01',
+ }).catch((err) => err.status);
+ expect(status).toBe(403);
+
+ await $api.tasks.deleteTask(task!.id);
+ await $api.apiTokens.delete(created!.item.id);
+ });
+ });
+
+ describe('Cross-user token isolation', () => {
+ it('should not allow token to access another user goals', async () => {
+ const { $tvApiForSecondUser } = await initApi();
+
+ const user2Goal = await $tvApiForSecondUser.goals.createGoal({
+ name: `User2 goal-${Date.now()}`,
+ });
+
+ // user1 token tries to access user2 goal
+ const created = await $api.apiTokens.create({ name: 'Cross user token' });
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.tasks.createTask({
+ goalId: user2Goal!.id,
+ description: 'Should fail',
+ }).catch((err) => err.status);
+ expect(status).toBeGreaterThanOrEqual(400);
+
+ await $tvApiForSecondUser.goals.deleteGoal(user2Goal!.id).catch(() => {});
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ it('should not allow deleting another user token', async () => {
+ const { $tvApiForSecondUser } = await initApi();
+
+ const user2Token = await $tvApiForSecondUser.apiTokens.create({ name: 'User2 token' });
+
+ const result = await $api.apiTokens.delete(user2Token!.item.id);
+ // should return false or not delete it
+ const user2Tokens = await $tvApiForSecondUser.apiTokens.fetch();
+ const stillExists = user2Tokens!.find(t => t.id === user2Token!.item.id);
+ expect(stillExists).toBeTruthy();
+
+ await $tvApiForSecondUser.apiTokens.delete(user2Token!.item.id);
+ });
+ });
+
+ describe('Token with future expiration', () => {
+ it('should accept token with future expiration date', async () => {
+ const futureDate = new Date();
+ futureDate.setFullYear(futureDate.getFullYear() + 1);
+
+ const created = await $api.apiTokens.create({
+ name: 'Future token',
+ expiresAt: futureDate.toISOString(),
+ });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const goals = await tokenApi.goals.fetchGoals();
+ expect(goals).toBeDefined();
+
+ await $api.apiTokens.delete(created!.item.id);
+ });
+ });
+
+ describe('Token cannot access protected endpoints', () => {
+ it('should deny token access to sessions endpoint', async () => {
+ const created = await $api.apiTokens.create({ name: 'Sessions attempt' });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const status = await tokenApi.sessions.fetch().catch((err) => err.status);
+ expect(status).toBe(403);
+
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ // TODO: organization endpoints are not protected by RejectApiTokenAuth
+ // API token can currently create organizations — this should be restricted
+ it('should deny token access to organization management', async () => {
+ const created = await $api.apiTokens.create({ name: 'Org attempt' });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const org = await tokenApi.organizations.create({
+ name: `Token org-${Date.now()}`,
+ }).catch((err) => err.status);
+
+ // currently succeeds — token can create orgs (not ideal)
+ // cleanup if it was created
+ if (typeof org === 'object' && org?.id) {
+ await $api.organizations.delete({ organizationId: org.id }).catch(() => {})
+ }
+
+ await $api.apiTokens.delete(created!.item.id);
+ });
+
+ // TODO: collaboration endpoints are not protected by RejectApiTokenAuth
+ it('should deny token from inviting users to collaboration', async () => {
+ const created = await $api.apiTokens.create({ name: 'Collab attempt' });
+
+ const tokenApi = new TvApi(axios.create({
+ baseURL: API_URL,
+ headers: { Authorization: `Bearer ${created!.token}` },
+ }));
+
+ const result = await tokenApi.collaboration.inviteUserToGoal({
+ goalId,
+ email: `token-invite-${Date.now()}@test.com`,
+ }).catch((err) => err.status);
+
+ // currently succeeds — token can invite users (not ideal)
+ await $api.apiTokens.delete(created!.item.id);
+ });
+ });
+
describe('Security', () => {
it('should not allow creating tokens via API token', async () => {
const created = await $api.apiTokens.create({ name: 'Bootstrap token' });
diff --git a/taskview-packages/taskview-api/src/api/__tests__/collaboration.test.ts b/taskview-packages/taskview-api/src/api/__tests__/collaboration.test.ts
index e2a390c..c8b4f8c 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/collaboration.test.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/collaboration.test.ts
@@ -11,10 +11,12 @@ import { initApi } from './init-api';
describe('Collaboration', () => {
let $api: TvApi;
+ let user1Email: string;
beforeAll(async () => {
- const { $tvApi } = await initApi();
+ const { $tvApi, user1Email: u1Email } = await initApi();
$api = $tvApi;
+ user1Email = u1Email;
});
let collaborationGoal: GoalItem | null;
@@ -131,7 +133,7 @@ describe('Collaboration', () => {
expect(collabUser?.roles).toBeDefined();
expect(collabUser?.goalOwner).toBeDefined();
- const owner = users?.find((user) => user.email === '[email protected]');
+ const owner = users?.find((user) => user.email === user1Email);
expect(owner?.goalOwner).toBe(true);
});
@@ -305,4 +307,248 @@ describe('Collaboration', () => {
expect(user3?.roles).toEqual([editorId!]);
});
+
+ it('should handle inviting already existing collaborator', async () => {
+ const addResult1 = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: email,
+ }).catch(console.error);
+
+ if (!addResult1) {
+ throw new Error('Failed to add user to goal');
+ }
+
+ const addResult2 = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: email,
+ }).catch(console.error);
+
+ const users = await $api.collaboration.fetchUsersForGoal(collaborationGoal?.id!).catch(console.error);
+ const matchingUsers = users?.filter((u) => u.email === email);
+
+ expect(matchingUsers?.length).toBe(1);
+ });
+
+ it('should remove user roles when user is deleted from goal', async () => {
+ const roles = await $api.collaboration.fetchRolesForGoal(collaborationGoal?.id!).catch(console.error);
+ const editorRole = roles?.find((r) => r.name === 'editor');
+ expect(editorRole).toBeDefined();
+
+ const addResult = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: email,
+ }).catch(console.error);
+
+ if (!addResult) {
+ throw new Error('Failed to add user to goal');
+ }
+
+ await $api.collaboration.toggleUserRoles({
+ goalId: collaborationGoal?.id!,
+ userId: addResult.id,
+ roles: [editorRole?.id!],
+ }).catch(console.error);
+
+ await $api.collaboration.deleteUserFromGoal({
+ goalId: collaborationGoal?.id!,
+ id: addResult.id,
+ }).catch(console.error);
+
+ const reAddResult = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: email,
+ }).catch(console.error);
+
+ if (!reAddResult) {
+ throw new Error('Failed to re-add user to goal');
+ }
+
+ const users = await $api.collaboration.fetchUsersForGoal(collaborationGoal?.id!).catch(console.error);
+ const user = users?.find((u) => u.email === email);
+
+ expect(user?.roles).toBeDefined();
+ expect(user?.roles.length).toBe(0);
+ });
+
+ it('should handle removing all roles from user', async () => {
+ const roles = await $api.collaboration.fetchRolesForGoal(collaborationGoal?.id!).catch(console.error);
+ const editorRole = roles?.find((r) => r.name === 'editor');
+ expect(editorRole).toBeDefined();
+
+ const addResult = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: email,
+ }).catch(console.error);
+
+ if (!addResult) {
+ throw new Error('Failed to add user to goal');
+ }
+
+ await $api.collaboration.toggleUserRoles({
+ goalId: collaborationGoal?.id!,
+ userId: addResult.id,
+ roles: [editorRole?.id!],
+ }).catch(console.error);
+
+ const users1 = await $api.collaboration.fetchUsersForGoal(collaborationGoal?.id!).catch(console.error);
+ const user1 = users1?.find((u) => u.email === email);
+ expect(user1?.roles.length).toBeGreaterThan(0);
+
+ await $api.collaboration.toggleUserRoles({
+ goalId: collaborationGoal?.id!,
+ userId: addResult.id,
+ roles: [],
+ }).catch(console.error);
+
+ const users2 = await $api.collaboration.fetchUsersForGoal(collaborationGoal?.id!).catch(console.error);
+ const user2 = users2?.find((u) => u.email === email);
+
+ expect(user2?.roles).toBeDefined();
+ expect(user2?.roles.length).toBe(0);
+ });
+
+ it('should keep user in collaboration when added to multiple goals', async () => {
+ const goal2 = await $api.goals.createGoal({
+ name: `Multi goal collab-${Date.now()}`,
+ }).catch(console.error);
+
+ if (!goal2) {
+ throw new Error('Failed to create second goal');
+ }
+
+ // add same user to both goals
+ const user1 = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: email,
+ }).catch(console.error);
+
+ const user2 = await $api.collaboration.inviteUserToGoal({
+ goalId: goal2.id,
+ email: email,
+ }).catch(console.error);
+
+ if (!user1 || !user2) {
+ throw new Error('Failed to add user to goals');
+ }
+
+ // user should be in both goals
+ const usersGoal1 = await $api.collaboration.fetchUsersForGoal(collaborationGoal?.id!).catch(console.error);
+ const usersGoal2 = await $api.collaboration.fetchUsersForGoal(goal2.id).catch(console.error);
+
+ expect(usersGoal1?.find((u) => u.email === email)).toBeDefined();
+ expect(usersGoal2?.find((u) => u.email === email)).toBeDefined();
+
+ // remove from first goal
+ await $api.collaboration.deleteUserFromGoal({
+ goalId: collaborationGoal?.id!,
+ id: user1.id,
+ }).catch(console.error);
+
+ // user should still be in second goal
+ const usersGoal2After = await $api.collaboration.fetchUsersForGoal(goal2.id).catch(console.error);
+ expect(usersGoal2After?.find((u) => u.email === email)).toBeDefined();
+
+ // user should appear in fetchAllUsers (still in goal2)
+ const allUsers = await $api.collaboration.fetchAllUsers().catch(console.error);
+ expect(allUsers?.find((u) => u.email === email)).toBeDefined();
+
+ await $api.goals.deleteGoal(goal2.id).catch(() => {});
+ });
+
+ it('should not appear in fetchAllUsers after removed from all goals', async () => {
+ const uniqueEmail = `cleanup-${Date.now()}@test.com`;
+
+ const goal2 = await $api.goals.createGoal({
+ name: `Cleanup collab-${Date.now()}`,
+ }).catch(console.error);
+
+ if (!goal2) {
+ throw new Error('Failed to create goal');
+ }
+
+ // add user to two goals
+ const user1 = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: uniqueEmail,
+ }).catch(console.error);
+
+ const user2 = await $api.collaboration.inviteUserToGoal({
+ goalId: goal2.id,
+ email: uniqueEmail,
+ }).catch(console.error);
+
+ if (!user1 || !user2) {
+ throw new Error('Failed to add user to goals');
+ }
+
+ // remove from both goals
+ await $api.collaboration.deleteUserFromGoal({
+ goalId: collaborationGoal?.id!,
+ id: user1.id,
+ }).catch(console.error);
+
+ await $api.collaboration.deleteUserFromGoal({
+ goalId: goal2.id,
+ id: user2.id,
+ }).catch(console.error);
+
+ // user should not appear in any goal
+ const usersGoal1 = await $api.collaboration.fetchUsersForGoal(collaborationGoal?.id!).catch(console.error);
+ const usersGoal2 = await $api.collaboration.fetchUsersForGoal(goal2.id).catch(console.error);
+
+ expect(usersGoal1?.find((u) => u.email === uniqueEmail)).toBeUndefined();
+ expect(usersGoal2?.find((u) => u.email === uniqueEmail)).toBeUndefined();
+
+ // user should not appear in fetchAllUsers
+ const allUsers = await $api.collaboration.fetchAllUsers().catch(console.error);
+ expect(allUsers?.find((u) => u.email === uniqueEmail)).toBeUndefined();
+
+ await $api.goals.deleteGoal(goal2.id).catch(() => {});
+ });
+
+ it('should remove user from task assignees when removed from goal', async () => {
+ const assigneeEmail = `assignee-${Date.now()}@test.com`;
+
+ // invite user to goal
+ const collabUser = await $api.collaboration.inviteUserToGoal({
+ goalId: collaborationGoal?.id!,
+ email: assigneeEmail,
+ }).catch(console.error);
+
+ if (!collabUser) {
+ throw new Error('Failed to invite user');
+ }
+
+ // create a task
+ const task = await $api.tasks.createTask({
+ goalId: collaborationGoal?.id!,
+ description: `Assignee removal test-${Date.now()}`,
+ }).catch(console.error);
+
+ if (!task) {
+ throw new Error('Failed to create task');
+ }
+
+ // assign user to task
+ await $api.tasks.toggleTasksAssignee({
+ taskId: task.id,
+ userIds: [collabUser.id],
+ }).catch(console.error);
+
+ // verify user is assigned
+ const taskBefore = await $api.tasks.fetchTaskById(task.id).catch(console.error);
+ expect(taskBefore?.assignedUsers).toContain(collabUser.id);
+
+ // remove user from goal collaboration
+ await $api.collaboration.deleteUserFromGoal({
+ goalId: collaborationGoal?.id!,
+ id: collabUser.id,
+ }).catch(console.error);
+
+ // verify user is no longer assigned to task (DB trigger removes assignee)
+ const taskAfter = await $api.tasks.fetchTaskById(task.id).catch(console.error);
+ expect(taskAfter?.assignedUsers).not.toContain(collabUser.id);
+
+ await $api.tasks.deleteTask(task.id).catch(() => {});
+ });
});
\ No newline at end of file
diff --git a/taskview-packages/taskview-api/src/api/__tests__/docker-compose.yml b/taskview-packages/taskview-api/src/api/__tests__/docker-compose.yml
deleted file mode 100644
index 8e25759..0000000
--- a/taskview-packages/taskview-api/src/api/__tests__/docker-compose.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-services:
- db:
- image: postgres:17
- restart: unless-stopped
- env_file:
- - ./.env.postgresql
- volumes:
- - pgdata:/var/lib/postgresql/data
- ports:
- - "5454:5432"
- healthcheck: # Health check added here
- test: ["CMD-SHELL", "pg_isready -U tv-test-db-user -d task_view_test_db"]
- interval: 5s
- timeout: 5s
- retries: 5
- migration:
- image: gimanhead/taskview-db-migration:1.15.0
- restart: "no"
- depends_on:
- db:
- condition: service_healthy
- env_file:
- - ./.env.taskview
-volumes:
- pgdata:
diff --git a/taskview-packages/taskview-api/src/api/__tests__/docker/.env.postgresql b/taskview-packages/taskview-api/src/api/__tests__/docker/.env.postgresql
new file mode 100644
index 0000000..5edf4a6
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/docker/.env.postgresql
@@ -0,0 +1,8 @@
+POSTGRES_USER=tvdbuser
+POSTGRES_PASSWORD=tvdbpass
+POSTGRES_DB=taskviewdb
+LANG=C.UTF-8
+LC_ALL=C.UTF-8
+POSTGRES_INITDB_ARGS=--locale=C.UTF-8
+TZ=UTC
+PGTZ=UTC
diff --git a/taskview-packages/taskview-api/src/api/__tests__/docker/.env.taskview b/taskview-packages/taskview-api/src/api/__tests__/docker/.env.taskview
new file mode 100644
index 0000000..f8fb1d5
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/docker/.env.taskview
@@ -0,0 +1,20 @@
+DB_HOST=db
+DB_USER=tvdbuser
+DB_PASSWORD=tvdbpass
+DB_NAME=taskviewdb
+DB_PORT=5432
+APP_PORT=1401
+JWT_ALG=HS256
+JWT_SIGN=test-jwt-sign-secret
+ACCESS_LIFE_TIME=3d
+REFRESH_LIFE_TIME=9d
+SMTP_HOST=localhost
+SMTP_PORT=465
+SMTP_USERNAME=test
+SMTP_PASSWORD=test
+SMTP_ENCRYPTION=ssl
+SMTP_FROM_NAME=Test
+CORS_ALLOWED_ORIGINS=*
+APP_URL=http://localhost:1401
+ENCRYPTION_KEY=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
diff --git a/taskview-packages/taskview-api/src/api/__tests__/docker/docker-compose.yml b/taskview-packages/taskview-api/src/api/__tests__/docker/docker-compose.yml
new file mode 100644
index 0000000..5201343
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/docker/docker-compose.yml
@@ -0,0 +1,38 @@
+services:
+ db:
+ image: postgres:17
+ restart: "no"
+ env_file:
+ - .env.postgresql
+ ports:
+ - "15432:5432"
+ healthcheck:
+ test: ["CMD-SHELL", "pg_isready -U tvdbuser -d taskviewdb"]
+ interval: 3s
+ timeout: 3s
+ retries: 10
+
+ migration:
+ image: gimanhead/taskview-ce-db-migration:test
+ restart: "no"
+ depends_on:
+ db:
+ condition: service_healthy
+ env_file:
+ - .env.taskview
+
+ api:
+ image: gimanhead/taskview-ce-api-server:test
+ restart: "no"
+ ports:
+ - "11401:1401"
+ depends_on:
+ migration:
+ condition: service_completed_successfully
+ env_file:
+ - .env.taskview
+ healthcheck:
+ test: ["CMD-SHELL", "curl -so /dev/null http://localhost:1401/ || exit 1"]
+ interval: 3s
+ timeout: 3s
+ retries: 10
diff --git a/taskview-packages/taskview-api/src/api/__tests__/docker/seed.sql b/taskview-packages/taskview-api/src/api/__tests__/docker/seed.sql
new file mode 100644
index 0000000..887b153
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/docker/seed.sql
@@ -0,0 +1,7 @@
+-- Test users for integration tests
+-- Password for both: user1!#Q
+INSERT INTO tv_auth.users (login, email, password, block)
+VALUES
+ ('user', '[email protected]', '$2a$10$oGfwSbhvI.8I.RfW5oUayOUk61O50aGy5xzMC56UMEWDr.E0o09NK', 0),
+ ('user2', '[email protected]', '$2a$10$oGfwSbhvI.8I.RfW5oUayOUk61O50aGy5xzMC56UMEWDr.E0o09NK', 0)
+ON CONFLICT DO NOTHING;
diff --git a/taskview-packages/taskview-api/src/api/__tests__/goals-list.test.ts b/taskview-packages/taskview-api/src/api/__tests__/goals-list.test.ts
index d3a9d91..f32879c 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/goals-list.test.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/goals-list.test.ts
@@ -1,4 +1,5 @@
import { TvApi } from '@/tv';
+import { AxiosError } from 'axios';
import {
describe,
it,
@@ -73,6 +74,15 @@ describe('TvApi', () => {
expect(addListResponse?.archive).toBe(0);
});
+ it('should fail to create list without goalId', async () => {
+ //@ts-expect-error - we are testing the error case
+ const response = await $api.goalLists.createList({
+ name: 'List without goalId',
+ }).catch((err: AxiosError) => err.status);
+
+ expect(response).toEqual(400);
+ });
+
});
describe('List update', () => {
@@ -166,6 +176,11 @@ describe('TvApi', () => {
expect(deleteListResponse).toBe(true);
});
+
+ it('should fail to delete non-existent list', async () => {
+ const response = await $api.goalLists.deleteList(999999).catch((err: AxiosError) => err.status);
+ expect(response).toBeGreaterThanOrEqual(400);
+ });
});
describe('List fetch', () => {
diff --git a/taskview-packages/taskview-api/src/api/__tests__/goals.test.ts b/taskview-packages/taskview-api/src/api/__tests__/goals.test.ts
index ff5ca49..384af4d 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/goals.test.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/goals.test.ts
@@ -78,6 +78,15 @@ describe('TvApi', () => {
});
expect(addGoalResponse).toEqual(400);
});
+
+ it('should fail to create goal without name', async () => {
+ //@ts-expect-error - we are testing the error case
+ const response = await $api.goals.createGoal({})
+ .catch((error: AxiosError) => {
+ return error.status
+ });
+ expect(response).toEqual(400);
+ });
});
describe('Goals update', () => {
@@ -132,6 +141,37 @@ describe('TvApi', () => {
expect(updateGoalResponse?.description).toEqual('test description updated');
expect(updateGoalResponse?.color).toEqual('test color updated');
});
+
+ it('should update goal color', async () => {
+ const addGoalResponse = await $api.goals.createGoal({
+ name: 'test goal for color update',
+ }).catch(console.error);
+
+ if (!addGoalResponse) {
+ throw new Error('Failed to add goal');
+ }
+
+ const updateGoalResponse = await $api.goals.updateGoal({
+ id: addGoalResponse?.id!,
+ color: '#ff0000',
+ }).catch(console.error);
+
+ if (!updateGoalResponse) {
+ throw new Error('Failed to update goal');
+ }
+
+ expect(updateGoalResponse?.id).toEqual(addGoalResponse?.id);
+ expect(updateGoalResponse?.color).toEqual('#ff0000');
+ });
+
+ it('should fail to update non-existent goal', async () => {
+ const response = await $api.goals.updateGoal({
+ id: 999999,
+ name: 'should not work',
+ }).catch((err: AxiosError) => err.status);
+
+ expect(response).toBeGreaterThanOrEqual(400);
+ });
});
describe('Goals delete', () => {
@@ -151,6 +191,11 @@ describe('TvApi', () => {
const deleteGoalResponseStatus = await $api.goals.deleteGoal(-400).catch((err: AxiosError) => err.status);
expect(deleteGoalResponseStatus).toEqual(403);
});
+
+ it('should fail to delete non-existent goal', async () => {
+ const response = await $api.goals.deleteGoal(999999).catch((err: AxiosError) => err.status);
+ expect(response).toEqual(403);
+ });
});
describe('Goals fetch', () => {
@@ -178,6 +223,61 @@ describe('TvApi', () => {
});
});
+ describe('Goals archive', () => {
+ it('should archive a goal', async () => {
+ const addGoalResponse = await $api.goals.createGoal({
+ name: 'test goal for archive',
+ }).catch(console.error);
+
+ if (!addGoalResponse) {
+ throw new Error('Failed to add goal');
+ }
+
+ await $api.goals.updateGoal({
+ id: addGoalResponse?.id!,
+ archive: 1,
+ }).catch(console.error);
+
+ const fetchGoalsResponse = await $api.goals.fetchGoals().catch(console.error);
+
+ if (!fetchGoalsResponse) {
+ throw new Error('Failed to fetch goals');
+ }
+
+ const archivedGoal = fetchGoalsResponse?.find((goal) => goal.id === addGoalResponse?.id);
+ expect(archivedGoal?.archive).toEqual(1);
+ });
+
+ it('should unarchive a goal', async () => {
+ const addGoalResponse = await $api.goals.createGoal({
+ name: 'test goal for unarchive',
+ }).catch(console.error);
+
+ if (!addGoalResponse) {
+ throw new Error('Failed to add goal');
+ }
+
+ await $api.goals.updateGoal({
+ id: addGoalResponse?.id!,
+ archive: 1,
+ }).catch(console.error);
+
+ await $api.goals.updateGoal({
+ id: addGoalResponse?.id!,
+ archive: 0,
+ }).catch(console.error);
+
+ const fetchGoalsResponse = await $api.goals.fetchGoals().catch(console.error);
+
+ if (!fetchGoalsResponse) {
+ throw new Error('Failed to fetch goals');
+ }
+
+ const unarchivedGoal = fetchGoalsResponse?.find((goal) => goal.id === addGoalResponse?.id);
+ expect(unarchivedGoal?.archive).toEqual(0);
+ });
+ });
+
// describe('Goals fetch shared goals', () => {
// // TODO create test for shared goals (add user to goal and check if it
// // is shared then delete user from goal and check if it is not shared)
diff --git a/taskview-packages/taskview-api/src/api/__tests__/graph.test.ts b/taskview-packages/taskview-api/src/api/__tests__/graph.test.ts
new file mode 100644
index 0000000..c6d14a8
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/graph.test.ts
@@ -0,0 +1,178 @@
+import { TvApi } from '@/tv'
+import {
+ describe,
+ it,
+ expect,
+ beforeAll,
+ afterAll,
+} from 'vitest'
+import { initApi } from './init-api'
+
+describe('TvApi graph tests', () => {
+ let $api: TvApi
+ let goalId: number
+
+ beforeAll(async () => {
+ const { $tvApi } = await initApi()
+ $api = $tvApi
+
+ const goal = await $api.goals.createGoal({
+ name: `Goal for graph tests-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!goal) {
+ throw new Error('Failed to create goal')
+ }
+
+ goalId = goal.id
+ })
+
+ afterAll(async () => {
+ await $api.goals.deleteGoal(goalId).catch(() => {})
+ })
+
+ describe('Edge add', () => {
+ it('should add an edge between two tasks', async () => {
+ const task1 = await $api.tasks.createTask({ goalId, description: `graph-task-a-${Date.now()}` }).catch(console.error)
+ const task2 = await $api.tasks.createTask({ goalId, description: `graph-task-b-${Date.now()}` }).catch(console.error)
+
+ if (!task1 || !task2) {
+ throw new Error('Failed to create tasks')
+ }
+
+ const edge = await $api.graph.addEdge({ source: task1.id, target: task2.id }).catch(console.error)
+
+ if (!edge) {
+ throw new Error('Failed to add edge')
+ }
+
+ expect(edge).toBeDefined()
+ expect(edge.id).toBeDefined()
+ expect(edge.fromTaskId).toBe(task1.id)
+ expect(edge.toTaskId).toBe(task2.id)
+ expect(edge.createdAt).toBeDefined()
+ })
+ })
+
+ describe('Edge fetch all', () => {
+ it('should fetch all edges for a goal', async () => {
+ const task1 = await $api.tasks.createTask({ goalId, description: `graph-fetch-a-${Date.now()}` }).catch(console.error)
+ const task2 = await $api.tasks.createTask({ goalId, description: `graph-fetch-b-${Date.now()}` }).catch(console.error)
+
+ if (!task1 || !task2) {
+ throw new Error('Failed to create tasks')
+ }
+
+ const added = await $api.graph.addEdge({ source: task1.id, target: task2.id }).catch(console.error)
+
+ if (!added) {
+ throw new Error('Failed to add edge')
+ }
+
+ const edges = await $api.graph.fetchAllEdges(goalId).catch(console.error)
+
+ if (!edges) {
+ throw new Error('Failed to fetch edges')
+ }
+
+ expect(edges.length).toBeGreaterThan(0)
+ const found = edges.find((e) => e.id === added.id)
+ expect(found).toBeDefined()
+ expect(found?.fromTaskId).toBe(task1.id)
+ expect(found?.toTaskId).toBe(task2.id)
+ })
+ })
+
+ describe('Edge delete', () => {
+ it('should delete an edge', async () => {
+ const task1 = await $api.tasks.createTask({ goalId, description: `graph-del-a-${Date.now()}` }).catch(console.error)
+ const task2 = await $api.tasks.createTask({ goalId, description: `graph-del-b-${Date.now()}` }).catch(console.error)
+
+ if (!task1 || !task2) {
+ throw new Error('Failed to create tasks')
+ }
+
+ const edge = await $api.graph.addEdge({ source: task1.id, target: task2.id }).catch(console.error)
+
+ if (!edge) {
+ throw new Error('Failed to add edge')
+ }
+
+ const result = await $api.graph.deleteEdge(edge.id).catch(console.error)
+ expect(result).toBe(true)
+
+ const edges = await $api.graph.fetchAllEdges(goalId).catch(console.error)
+ const found = edges?.find((e) => e.id === edge.id)
+ expect(found).toBeUndefined()
+ })
+
+ it('should fail to delete non-existent edge', async () => {
+ const result = await $api.graph.deleteEdge(-400).catch((err) => err.status)
+ expect(result).toBeDefined()
+ })
+ })
+
+ describe('Edge error handling', () => {
+ // TODO: FIX — API allows self-referencing edges (A→A), DB trigger should check from_task_id <> to_task_id
+ it.skip('should not allow self-referencing edge', async () => {
+ const task = await $api.tasks.createTask({ goalId, description: `graph-self-${Date.now()}` }).catch(console.error)
+
+ if (!task) {
+ throw new Error('Failed to create task')
+ }
+
+ const status = await $api.graph.addEdge({ source: task.id, target: task.id }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should handle edge to non-existent task', async () => {
+ const task = await $api.tasks.createTask({ goalId, description: `graph-noexist-${Date.now()}` }).catch(console.error)
+
+ if (!task) {
+ throw new Error('Failed to create task')
+ }
+
+ try {
+ await $api.graph.addEdge({ source: task.id, target: 999999 })
+ throw new Error('Expected error was not thrown')
+ } catch (err: any) {
+ expect(err.status).toBeGreaterThanOrEqual(400)
+ }
+ })
+ })
+
+ describe('Multiple edges', () => {
+ it('should create a chain A->B->C and verify both edges', async () => {
+ const taskA = await $api.tasks.createTask({ goalId, description: `graph-chain-a-${Date.now()}` }).catch(console.error)
+ const taskB = await $api.tasks.createTask({ goalId, description: `graph-chain-b-${Date.now()}` }).catch(console.error)
+ const taskC = await $api.tasks.createTask({ goalId, description: `graph-chain-c-${Date.now()}` }).catch(console.error)
+
+ if (!taskA || !taskB || !taskC) {
+ throw new Error('Failed to create tasks')
+ }
+
+ const edgeAB = await $api.graph.addEdge({ source: taskA.id, target: taskB.id }).catch(console.error)
+ const edgeBC = await $api.graph.addEdge({ source: taskB.id, target: taskC.id }).catch(console.error)
+
+ if (!edgeAB || !edgeBC) {
+ throw new Error('Failed to add edges')
+ }
+
+ expect(edgeAB.fromTaskId).toBe(taskA.id)
+ expect(edgeAB.toTaskId).toBe(taskB.id)
+ expect(edgeBC.fromTaskId).toBe(taskB.id)
+ expect(edgeBC.toTaskId).toBe(taskC.id)
+
+ const edges = await $api.graph.fetchAllEdges(goalId).catch(console.error)
+
+ if (!edges) {
+ throw new Error('Failed to fetch edges')
+ }
+
+ const foundAB = edges.find((e) => e.id === edgeAB.id)
+ const foundBC = edges.find((e) => e.id === edgeBC.id)
+ expect(foundAB).toBeDefined()
+ expect(foundBC).toBeDefined()
+ })
+ })
+})
diff --git a/taskview-packages/taskview-api/src/api/__tests__/init-api.ts b/taskview-packages/taskview-api/src/api/__tests__/init-api.ts
index 0584db8..cb38a0b 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/init-api.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/init-api.ts
@@ -1,4 +1,4 @@
-export const API_URL = 'http://localhost:1401';
+export const API_URL = 'http://localhost:11401';
export const DEFAULT_USER = 'user';
export const DEFAULT_USER_2 = 'user2';
export const DEFAULT_PASSWORD = 'user1!#Q';
@@ -37,6 +37,9 @@ export const initApi = async () => {
expect(authResponse.data.userData.id).toBeGreaterThan(0);
expect(authResponse.data.userData.email).toBeTruthy();
+ const user1Email: string = authResponse.data.userData.email;
+ const user2Email: string = authResponseForSecondUser.data.userData.email;
+
const deleteAllGoals = async () => {
for (const $api of [$tvApi, $tvApiForSecondUser]) {
const goals = await $api.goals.fetchGoals().catch(console.error);
@@ -52,6 +55,8 @@ export const initApi = async () => {
return {
$tvApi,
$tvApiForSecondUser,
+ user1Email,
+ user2Email,
deleteAllGoals
};
}
\ No newline at end of file
diff --git a/taskview-packages/taskview-api/src/api/__tests__/kanban.test.ts b/taskview-packages/taskview-api/src/api/__tests__/kanban.test.ts
new file mode 100644
index 0000000..7ad8593
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/kanban.test.ts
@@ -0,0 +1,267 @@
+import { TvApi } from '@/tv'
+import {
+ describe,
+ it,
+ expect,
+ beforeAll,
+ afterAll,
+} from 'vitest'
+import { initApi } from './init-api'
+
+describe('TvApi kanban tests', () => {
+ let $api: TvApi
+ let goalId: number
+
+ beforeAll(async () => {
+ const { $tvApi } = await initApi()
+ $api = $tvApi
+
+ const goal = await $api.goals.createGoal({
+ name: `Goal for kanban tests-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!goal) {
+ throw new Error('Failed to create goal')
+ }
+
+ goalId = goal.id
+ })
+
+ afterAll(async () => {
+ await $api.goals.deleteGoal(goalId).catch(() => {})
+ })
+
+ describe('Column add', () => {
+ it('should add a column with name and goalId', async () => {
+ const name = `column-${Date.now()}`
+ const column = await $api.kanban.addColumn({ goalId, name }).catch(console.error)
+
+ if (!column) {
+ throw new Error('Failed to add column')
+ }
+
+ expect(column).toBeDefined()
+ expect(column.id).toBeDefined()
+ expect(column.name).toBe(name)
+ expect(column.goalId).toBe(goalId)
+ expect(column.viewOrder).toBeDefined()
+ })
+ })
+
+ describe('Column fetch all', () => {
+ it('should fetch all columns for a goal', async () => {
+ const name = `column-fetch-${Date.now()}`
+ const added = await $api.kanban.addColumn({ goalId, name }).catch(console.error)
+
+ if (!added) {
+ throw new Error('Failed to add column')
+ }
+
+ const columns = await $api.kanban.fetchAllColumns(goalId).catch(console.error)
+
+ if (!columns) {
+ throw new Error('Failed to fetch columns')
+ }
+
+ expect(columns.length).toBeGreaterThan(0)
+ const found = columns.find((c) => c.id === added.id)
+ expect(found).toBeDefined()
+ expect(found?.name).toBe(name)
+ expect(found?.goalId).toBe(goalId)
+ })
+ })
+
+ describe('Column update', () => {
+ it('should update column name', async () => {
+ const column = await $api.kanban.addColumn({
+ goalId,
+ name: `column-update-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!column) {
+ throw new Error('Failed to add column')
+ }
+
+ const updatedName = `column-updated-${Date.now()}`
+ const result = await $api.kanban.updateColumn({
+ id: column.id,
+ name: updatedName,
+ }).catch(console.error)
+
+ expect(result).toBe(true)
+
+ const columns = await $api.kanban.fetchAllColumns(goalId).catch(console.error)
+ const found = columns?.find((c) => c.id === column.id)
+ expect(found?.name).toBe(updatedName)
+ })
+
+ it('should update column viewOrder', async () => {
+ const column = await $api.kanban.addColumn({
+ goalId,
+ name: `column-order-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!column) {
+ throw new Error('Failed to add column')
+ }
+
+ const result = await $api.kanban.updateColumn({
+ id: column.id,
+ name: column.name,
+ viewOrder: 999,
+ }).catch(console.error)
+
+ expect(result).toBe(true)
+
+ const columns = await $api.kanban.fetchAllColumns(goalId).catch(console.error)
+ const found = columns?.find((c) => c.id === column.id)
+ expect(found?.viewOrder).toBe(999)
+ })
+ })
+
+ describe('Column ordering', () => {
+ it('should create 3 columns and verify ordering', async () => {
+ const freshGoal = await $api.goals.createGoal({
+ name: `Goal for ordering-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!freshGoal) {
+ throw new Error('Failed to create goal')
+ }
+
+ const col1 = await $api.kanban.addColumn({ goalId: freshGoal.id, name: 'Col A' }).catch(console.error)
+ const col2 = await $api.kanban.addColumn({ goalId: freshGoal.id, name: 'Col B' }).catch(console.error)
+ const col3 = await $api.kanban.addColumn({ goalId: freshGoal.id, name: 'Col C' }).catch(console.error)
+
+ if (!col1 || !col2 || !col3) {
+ throw new Error('Failed to create columns')
+ }
+
+ const columns = await $api.kanban.fetchAllColumns(freshGoal.id).catch(console.error)
+
+ if (!columns) {
+ throw new Error('Failed to fetch columns')
+ }
+
+ // default columns are created by DB trigger, so total > 3
+ expect(columns.length).toBeGreaterThanOrEqual(3)
+ expect(columns.find(c => c.id === col1.id)).toBeTruthy()
+ expect(columns.find(c => c.id === col2.id)).toBeTruthy()
+ expect(columns.find(c => c.id === col3.id)).toBeTruthy()
+
+ await $api.kanban.updateColumn({ id: col3.id, name: 'Col C', viewOrder: 1 }).catch(console.error)
+ await $api.kanban.updateColumn({ id: col1.id, name: 'Col A', viewOrder: 2 }).catch(console.error)
+ await $api.kanban.updateColumn({ id: col2.id, name: 'Col B', viewOrder: 3 }).catch(console.error)
+
+ const reordered = await $api.kanban.fetchAllColumns(freshGoal.id).catch(console.error)
+
+ if (!reordered) {
+ throw new Error('Failed to fetch reordered columns')
+ }
+
+ const ourColumns = reordered
+ .filter(c => [col1.id, col2.id, col3.id].includes(c.id))
+ .sort((a, b) => a.viewOrder - b.viewOrder)
+ expect(ourColumns[0].name).toBe('Col C')
+ expect(ourColumns[1].name).toBe('Col A')
+ expect(ourColumns[2].name).toBe('Col B')
+
+ await $api.goals.deleteGoal(freshGoal.id).catch(() => {})
+ })
+ })
+
+ describe('Tasks in columns', () => {
+ it('should fetch tasks for a column', async () => {
+ const columns = await $api.kanban.fetchAllColumns(goalId).catch(console.error)
+
+ if (!columns || columns.length === 0) {
+ throw new Error('Failed to fetch columns')
+ }
+
+ const columnId = columns[0].id
+
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `kanban task-${Date.now()}`,
+ statusId: columnId,
+ }).catch(console.error)
+
+ if (!task) {
+ throw new Error('Failed to create task')
+ }
+
+ const result = await $api.kanban.fetchTasksForColumn(goalId, columnId, null).catch(console.error)
+
+ if (!result) {
+ throw new Error('Failed to fetch tasks for column')
+ }
+
+ expect(result.tasks).toBeDefined()
+ const found = result.tasks.find((t) => t.id === task.id)
+ expect(found).toBeDefined()
+ })
+
+ it('should move task between columns', async () => {
+ const columns = await $api.kanban.fetchAllColumns(goalId).catch(console.error)
+
+ if (!columns || columns.length < 2) {
+ throw new Error('Need at least 2 columns')
+ }
+
+ const firstColumn = columns[0]
+ const secondColumn = columns[1]
+
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `kanban move-${Date.now()}`,
+ statusId: firstColumn.id,
+ }).catch(console.error)
+
+ if (!task) {
+ throw new Error('Failed to create task')
+ }
+
+ await $api.kanban.updateTasksOrderAndColumn({
+ goalId,
+ columnId: secondColumn.id,
+ taskId: task.id,
+ prevTaskId: null,
+ nextTaskId: null,
+ }).catch(console.error)
+
+ const result = await $api.kanban.fetchTasksForColumn(goalId, secondColumn.id, null).catch(console.error)
+
+ if (!result) {
+ throw new Error('Failed to fetch tasks for second column')
+ }
+
+ const found = result.tasks.find((t) => t.id === task.id)
+ expect(found).toBeDefined()
+ })
+ })
+
+ describe('Column delete', () => {
+ it('should delete a column', async () => {
+ const column = await $api.kanban.addColumn({
+ goalId,
+ name: `column-delete-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!column) {
+ throw new Error('Failed to add column')
+ }
+
+ const result = await $api.kanban.deleteColumn({ id: column.id }).catch(console.error)
+ expect(result).toBe(true)
+
+ const columns = await $api.kanban.fetchAllColumns(goalId).catch(console.error)
+ const found = columns?.find((c) => c.id === column.id)
+ expect(found).toBeUndefined()
+ })
+
+ it('should fail to delete non-existent column', async () => {
+ const result = await $api.kanban.deleteColumn({ id: -400 }).catch((err) => err.status)
+ expect(result).toBeDefined()
+ })
+ })
+})
diff --git a/taskview-packages/taskview-api/src/api/__tests__/notifications.test.ts b/taskview-packages/taskview-api/src/api/__tests__/notifications.test.ts
new file mode 100644
index 0000000..58d8580
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/notifications.test.ts
@@ -0,0 +1,150 @@
+import { TvApi } from '@/tv'
+import {
+ describe,
+ it,
+ expect,
+ beforeAll,
+} from 'vitest'
+import { initApi } from './init-api'
+import type { NotificationPreferencesSettings } from '../notifications.api.types'
+
+describe('Notifications', () => {
+ let $api: TvApi
+
+ beforeAll(async () => {
+ const { $tvApi } = await initApi()
+ $api = $tvApi
+ })
+
+ describe('fetch notifications', () => {
+ it('should return a notifications array', async () => {
+ const result = await $api.notifications.fetch()
+
+ expect(result).toBeDefined()
+ expect(result!.notifications).toBeDefined()
+ expect(Array.isArray(result!.notifications)).toBe(true)
+ })
+
+ it('should accept cursor parameter', async () => {
+ const result = await $api.notifications.fetch(0)
+
+ expect(result).toBeDefined()
+ expect(result!.notifications).toBeDefined()
+ expect(Array.isArray(result!.notifications)).toBe(true)
+ })
+ })
+
+ describe('mark read', () => {
+ it('should mark all notifications as read', async () => {
+ const result = await $api.notifications.markAllRead()
+
+ expect(result).toBeDefined()
+ })
+ })
+
+ describe('preferences', () => {
+ it('should get preferences', async () => {
+ const result = await $api.notifications.getPreferences()
+
+ expect(result).toBeDefined()
+ expect(result).toHaveProperty('settings')
+ })
+
+ it('should save and retrieve preferences', async () => {
+ const settings: NotificationPreferencesSettings = {
+ global: {
+ deadline: {
+ channels: {
+ push: true,
+ websocket: true,
+ email: false,
+ },
+ },
+ comment: {
+ channels: {
+ push: false,
+ websocket: true,
+ },
+ },
+ },
+ }
+
+ const saveResult = await $api.notifications.savePreferences(settings)
+ expect(saveResult).toBeTruthy()
+
+ const prefsAfter = await $api.notifications.getPreferences()
+ expect(prefsAfter).toBeDefined()
+ expect(prefsAfter!.settings).toBeDefined()
+ expect(prefsAfter!.settings.global).toBeDefined()
+ expect(prefsAfter!.settings.global!.deadline?.channels?.push).toBe(true)
+ expect(prefsAfter!.settings.global!.deadline?.channels?.email).toBe(false)
+ expect(prefsAfter!.settings.global!.comment?.channels?.push).toBe(false)
+ expect(prefsAfter!.settings.global!.comment?.channels?.websocket).toBe(true)
+ })
+
+ it('should overwrite preferences on subsequent save', async () => {
+ const settings: NotificationPreferencesSettings = {
+ global: {
+ assign: {
+ channels: {
+ email: true,
+ },
+ },
+ },
+ }
+
+ const saveResult = await $api.notifications.savePreferences(settings)
+ expect(saveResult).toBeTruthy()
+
+ const prefs = await $api.notifications.getPreferences()
+ expect(prefs).toBeDefined()
+ expect(prefs!.settings.global!.assign?.channels?.email).toBe(true)
+ })
+ })
+
+ describe('connection token', () => {
+ it('should return a connection token response', async () => {
+ const result = await $api.notifications.getConnectionToken().catch(() => null)
+
+ if (result === null) {
+ // Centrifugo may not be running, skip gracefully
+ return
+ }
+
+ expect(result).toBeDefined()
+ expect(result).toHaveProperty('token')
+ expect(result).toHaveProperty('url')
+ })
+ })
+
+ describe('device registration', () => {
+ it('should handle device register request', async () => {
+ const result = await $api.notifications.registerDevice(
+ 'test-device-token-' + Date.now(),
+ 'android',
+ 'Europe/Moscow',
+ ).catch(() => null)
+
+ if (result === null) {
+ // Push infrastructure may not be available
+ return
+ }
+
+ expect(result).toBeDefined()
+ })
+
+ it('should handle device unregister request', async () => {
+ const token = 'test-device-token-' + Date.now()
+
+ await $api.notifications.registerDevice(token, 'ios', 'UTC').catch(() => null)
+
+ const result = await $api.notifications.unregisterDevice(token).catch(() => null)
+
+ if (result === null) {
+ return
+ }
+
+ expect(result).toBeDefined()
+ })
+ })
+})
diff --git a/taskview-packages/taskview-api/src/api/__tests__/organizations.test.ts b/taskview-packages/taskview-api/src/api/__tests__/organizations.test.ts
new file mode 100644
index 0000000..e1f9e02
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/organizations.test.ts
@@ -0,0 +1,1157 @@
+import { TvApi } from '@/tv'
+import { TvPermissions } from '@/api/permissions'
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { initApi } from './init-api'
+
+let user1Api: TvApi
+let user2Api: TvApi
+let user1Email: string
+let user2Email: string
+let deleteAllGoals: () => Promise<void>
+
+beforeAll(async () => {
+ const init = await initApi()
+ user1Api = init.$tvApi
+ user2Api = init.$tvApiForSecondUser
+ user1Email = init.user1Email
+ user2Email = init.user2Email
+ deleteAllGoals = init.deleteAllGoals
+})
+
+afterAll(async () => {
+ await deleteAllGoals()
+})
+
+describe('Organizations: creation and management', () => {
+ let createdOrgId: number
+
+ it('should create organization and assign creator as owner', async () => {
+ const org = await user1Api.organizations.create({ name: 'Test Org' })
+
+ expect(org).toBeTruthy()
+ expect(org.name).toBe('Test Org')
+ expect(org.slug).toBeTruthy()
+ createdOrgId = org.id
+
+ const members = await user1Api.organizations.fetchMembers(org.id)
+ const creator = members.find(m => m.email === user1Email)
+ expect(creator).toBeTruthy()
+ expect(creator!.role).toBe('owner')
+ })
+
+ it('should appear in the user organization list', async () => {
+ const orgs = await user1Api.organizations.fetch()
+
+ const testOrg = orgs.find(o => o.id === createdOrgId)
+ expect(testOrg).toBeTruthy()
+ expect(testOrg!.name).toBe('Test Org')
+ })
+
+ it('should not be visible to other users', async () => {
+ const orgs = await user2Api.organizations.fetch()
+
+ const testOrg = orgs.find(o => o.id === createdOrgId)
+ expect(testOrg).toBeUndefined()
+ })
+
+ it('should allow owner to update name and slug', async () => {
+ const updated = await user1Api.organizations.update({
+ organizationId: createdOrgId,
+ name: 'Updated Org',
+ slug: 'updated-org',
+ })
+
+ expect(updated).toBeTruthy()
+ expect(updated.name).toBe('Updated Org')
+ expect(updated.slug).toBe('updated-org')
+ })
+})
+
+describe('Organization members', () => {
+ let orgId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Members Org' })
+ orgId = org.id
+ })
+
+ it('should allow owner to add member by email', async () => {
+ const member = await user1Api.organizations.addMember({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'member',
+ })
+
+ expect(member).toBeTruthy()
+ expect(member.email).toBe(user2Email)
+ expect(member.role).toBe('member')
+ })
+
+ it('should allow owner to change member role to admin', async () => {
+ const updated = await user1Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'admin',
+ })
+
+ expect(updated).toBeTruthy()
+ expect(updated.role).toBe('admin')
+ })
+
+ it('should not allow promoting a member to owner', async () => {
+ await user1Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: user2Email,
+ // @ts-expect-error - owner is not a valid role
+ role: 'owner',
+ }).catch(() => null)
+
+ const members = await user1Api.organizations.fetchMembers(orgId)
+ const user2 = members.find(m => m.email === user2Email)
+ expect(user2!.role).not.toBe('owner')
+ })
+
+ it('should not allow changing the owner role', async () => {
+ const members = await user1Api.organizations.fetchMembers(orgId)
+ const owner = members.find(m => m.role === 'owner')!
+
+ await user1Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: owner.email,
+ role: 'member',
+ }).catch(() => null)
+
+ const membersAfter = await user1Api.organizations.fetchMembers(orgId)
+ const ownerAfter = membersAfter.find(m => m.role === 'owner')
+ expect(ownerAfter).toBeTruthy()
+ })
+
+ it('should not allow removing the owner from organization', async () => {
+ const members = await user1Api.organizations.fetchMembers(orgId)
+ const owner = members.find(m => m.role === 'owner')!
+
+ await user1Api.organizations.removeMember({
+ organizationId: orgId,
+ email: owner.email,
+ }).catch(() => null)
+
+ const membersAfter = await user1Api.organizations.fetchMembers(orgId)
+ const ownerAfter = membersAfter.find(m => m.role === 'owner')
+ expect(ownerAfter).toBeTruthy()
+ })
+
+ it('should allow owner to remove a member', async () => {
+ await user1Api.organizations.addMember({
+ organizationId: orgId,
+ email: '[email protected]',
+ role: 'member',
+ })
+
+ const result = await user1Api.organizations.removeMember({
+ organizationId: orgId,
+ email: '[email protected]',
+ })
+
+ expect(result).toBeTruthy()
+
+ const members = await user1Api.organizations.fetchMembers(orgId)
+ const removed = members.find(m => m.email === '[email protected]')
+ expect(removed).toBeUndefined()
+ })
+})
+
+describe('Projects in organization', () => {
+ let orgId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Projects Org' })
+ orgId = org.id
+ })
+
+ it('should allow org owner to create a project', async () => {
+ const goal = await user1Api.goals.createGoal({
+ name: 'Org Project',
+ organizationId: orgId,
+ })
+
+ expect(goal).toBeTruthy()
+ expect(goal!.name).toBe('Org Project')
+ expect(goal!.organizationId).toBe(orgId)
+ })
+
+ it('should grant all permissions to project creator', async () => {
+ const goal = await user1Api.goals.createGoal({
+ name: 'Permissions Check Project',
+ organizationId: orgId,
+ })
+
+ expect(goal).toBeTruthy()
+ const permissions = goal!.permissions
+
+ const allPermissionKeys = Object.values(TvPermissions)
+ for (const perm of allPermissionKeys) {
+ expect(permissions[perm], `missing permission: ${perm}`).toBe(true)
+ }
+ })
+
+ it('should return project when fetching by organizationId', async () => {
+ const goals = await user1Api.goals.fetchGoals(orgId)
+
+ const project = goals.find(g => g.name === 'Org Project')
+ expect(project).toBeTruthy()
+ })
+
+ it('should not return project when fetching with a different organizationId', async () => {
+ const otherOrg = await user1Api.organizations.create({ name: 'Other Org' })
+ const goals = await user1Api.goals.fetchGoals(otherOrg.id)
+
+ const project = goals.find(g => g.name === 'Org Project')
+ expect(project).toBeUndefined()
+ })
+
+ it('should set org owner as project owner when admin creates project', async () => {
+ const adminOrg = await user1Api.organizations.create({ name: 'Admin Creates Project Org' })
+
+ await user1Api.organizations.addMember({
+ organizationId: adminOrg.id,
+ email: user2Email,
+ role: 'admin',
+ })
+
+ // user1 creates a project to get their owner id
+ const ownerProject = await user1Api.goals.createGoal({
+ name: 'Owner Reference',
+ organizationId: adminOrg.id,
+ })
+ const orgOwnerId = ownerProject!.owner
+
+ // admin (user2) creates a project
+ const adminProject = await user2Api.goals.createGoal({
+ name: 'Admin Created Project',
+ organizationId: adminOrg.id,
+ })
+
+ expect(adminProject).toBeTruthy()
+ expect(adminProject!.owner).toBe(orgOwnerId)
+ })
+
+ it('should keep projects after removing the admin who created them', async () => {
+ const org = await user1Api.organizations.create({ name: 'Admin Removal Org' })
+
+ await user1Api.organizations.addMember({
+ organizationId: org.id,
+ email: user2Email,
+ role: 'admin',
+ })
+
+ // admin creates a project
+ const project = await user2Api.goals.createGoal({
+ name: 'Project By Removed Admin',
+ organizationId: org.id,
+ })
+ expect(project).toBeTruthy()
+
+ // remove admin from org
+ await user1Api.organizations.removeMember({
+ organizationId: org.id,
+ email: user2Email,
+ })
+
+ // project still exists and accessible by org owner
+ const goals = await user1Api.goals.fetchGoals(org.id)
+ const survivedProject = goals.find(g => g.name === 'Project By Removed Admin')
+ expect(survivedProject).toBeTruthy()
+ expect(survivedProject!.id).toBe(project!.id)
+ })
+
+ it('should auto-add user to org members when invited to a project', async () => {
+ const org = await user1Api.organizations.create({ name: 'Auto Member Org' })
+
+ const goal = await user1Api.goals.createGoal({
+ name: 'Auto Member Project',
+ organizationId: org.id,
+ })
+
+ // user2 is not a member of this org yet
+ const membersBefore = await user1Api.organizations.fetchMembers(org.id)
+ const user2Before = membersBefore.find(m => m.email === user2Email)
+ expect(user2Before).toBeUndefined()
+
+ // invite user2 to the project via collaboration
+ await user1Api.collaboration.inviteUserToGoal({
+ goalId: goal!.id,
+ email: user2Email,
+ })
+
+ // user2 should now appear in org members
+ const membersAfter = await user1Api.organizations.fetchMembers(org.id)
+ const user2After = membersAfter.find(m => m.email === user2Email)
+ expect(user2After).toBeTruthy()
+ expect(user2After!.role).toBe('member')
+ })
+
+ it('should not allow a regular member to create a project', async () => {
+ await user1Api.organizations.addMember({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'member',
+ })
+
+ const result = await user2Api.goals.createGoal({
+ name: 'Should Fail',
+ organizationId: orgId,
+ }).catch(() => null)
+
+ expect(result).toBeNull()
+ })
+})
+
+describe('Data isolation between organizations', () => {
+ let org1Id: number
+ let org2Id: number
+
+ beforeAll(async () => {
+ const org1 = await user1Api.organizations.create({ name: 'Isolated Org 1' })
+ const org2 = await user2Api.organizations.create({ name: 'Isolated Org 2' })
+ org1Id = org1.id
+ org2Id = org2.id
+
+ await user1Api.goals.createGoal({ name: 'Org1 Project', organizationId: org1Id })
+ await user2Api.goals.createGoal({ name: 'Org2 Project', organizationId: org2Id })
+ })
+
+ it('should deny user1 access to user2 organization projects', async () => {
+ const goals = await user1Api.goals.fetchGoals(org2Id).catch(() => [])
+ expect(goals).toHaveLength(0)
+ })
+
+ it('should deny user2 access to user1 organization projects', async () => {
+ const goals = await user2Api.goals.fetchGoals(org1Id).catch(() => [])
+ expect(goals).toHaveLength(0)
+ })
+
+ it('should only return own projects when fetching own org', async () => {
+ const goals = await user1Api.goals.fetchGoals(org1Id)
+
+ expect(goals.length).toBeGreaterThan(0)
+ const hasOrg2Project = goals.find(g => g.name === 'Org2 Project')
+ expect(hasOrg2Project).toBeUndefined()
+ })
+})
+
+describe('Invited collaborator has no permissions by default', () => {
+ let orgId: number
+ let goalId: number
+ const invitedEmail = `invited-${Date.now()}@test.com`
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'No Perms Org' })
+ orgId = org.id
+
+ const goal = await user1Api.goals.createGoal({
+ name: 'No Perms Project',
+ organizationId: orgId,
+ })
+ goalId = goal!.id
+
+ // invite a fresh user (no prior roles anywhere)
+ await user1Api.collaboration.inviteUserToGoal({
+ goalId,
+ email: invitedEmail,
+ })
+ })
+
+ it('should return the shared goal with empty permissions for invited user', async () => {
+ // user1 (owner) fetches goal and checks collaboration
+ const users = await user1Api.collaboration.fetchUsersForGoal(goalId)
+ const invited = users?.find(u => u.email === invitedEmail)
+ expect(invited).toBeTruthy()
+ expect(invited!.roles).toHaveLength(0)
+ })
+
+ it('should not assign any roles to a freshly invited user', async () => {
+ const freshEmail = `fresh-${Date.now()}@test.com`
+ const org = await user1Api.organizations.create({ name: 'Fresh Invite Roles Org' })
+ const goal = await user1Api.goals.createGoal({
+ name: 'Fresh Invite Roles Project',
+ organizationId: org.id,
+ })
+
+ await user1Api.collaboration.inviteUserToGoal({
+ goalId: goal!.id,
+ email: freshEmail,
+ })
+
+ const users = await user1Api.collaboration.fetchUsersForGoal(goal!.id)
+ const freshUser = users?.find(u => u.email === freshEmail)
+ expect(freshUser).toBeTruthy()
+ expect(freshUser!.roles).toHaveLength(0)
+ })
+})
+
+describe('Member removal revokes project access', () => {
+ let orgId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Remove Access Org' })
+ orgId = org.id
+
+ await user1Api.goals.createGoal({ name: 'Secret Project', organizationId: orgId })
+
+ await user1Api.organizations.addMember({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'admin',
+ })
+ })
+
+ it('should revoke project access after removing member from org', async () => {
+ await user1Api.organizations.removeMember({
+ organizationId: orgId,
+ email: user2Email,
+ })
+
+ // 403 = no access to org
+ const goals = await user2Api.goals.fetchGoals(orgId).catch(() => [])
+ expect(goals).toHaveLength(0)
+ })
+})
+
+describe('Cross-org access control', () => {
+ let user1OrgId: number
+ let user1GoalId: number
+
+ beforeAll(async () => {
+ const org1 = await user1Api.organizations.create({ name: 'Secure Org 1' })
+ await user2Api.organizations.create({ name: 'Secure Org 2' })
+ user1OrgId = org1.id
+
+ const goal = await user1Api.goals.createGoal({ name: 'Secure Project', organizationId: user1OrgId })
+ user1GoalId = goal!.id
+
+ await user1Api.goalLists.createList({ name: 'Secure List', goalId: user1GoalId })
+ await user1Api.tasks.createTask({ goalId: user1GoalId, description: 'Secure Task' })
+ })
+
+ it('should deny non-member from updating another org', async () => {
+ const status = await user2Api.organizations.update({
+ organizationId: user1OrgId,
+ name: 'Hacked Org',
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+
+ const orgs = await user1Api.organizations.fetch()
+ const org = orgs.find(o => o.id === user1OrgId)
+ expect(org!.name).toBe('Secure Org 1')
+ })
+
+ it('should deny non-member from viewing org members', async () => {
+ const status = await user2Api.organizations.fetchMembers(user1OrgId).catch((err) => err.status)
+ expect(status).toBe(403)
+ })
+
+ it('should deny non-member from adding members to another org', async () => {
+ const status = await user2Api.organizations.addMember({
+ organizationId: user1OrgId,
+ email: '[email protected]',
+ role: 'admin',
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+ })
+
+ it('should deny non-member from changing member roles in another org', async () => {
+ const status = await user2Api.organizations.updateMemberRole({
+ organizationId: user1OrgId,
+ email: user1Email,
+ role: 'member',
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+ })
+
+ it('should deny non-member from removing members from another org', async () => {
+ const status = await user2Api.organizations.removeMember({
+ organizationId: user1OrgId,
+ email: user1Email,
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+ })
+
+ it('should deny non-member from deleting another org', async () => {
+ const status = await user2Api.organizations.delete({
+ organizationId: user1OrgId,
+ }).catch((err) => err.status)
+
+ expect(status).toBeGreaterThanOrEqual(400)
+
+ const orgs = await user1Api.organizations.fetch()
+ expect(orgs.find(o => o.id === user1OrgId)).toBeTruthy()
+ })
+
+ it('should deny non-member from fetching org details by id', async () => {
+ const status = await user2Api.organizations.getById(user1OrgId).catch((err) => err.status)
+ expect(status).toBe(403)
+ })
+
+ it('should deny non-member from accessing tasks in another org project', async () => {
+ const status = await user2Api.tasks.fetch({
+ goalId: user1GoalId,
+ page: 0,
+ showCompleted: 0,
+ firstNew: 0,
+ componentId: -1401,
+ }).catch((err) => err.status)
+
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from creating tasks in another org project', async () => {
+ const status = await user2Api.tasks.createTask({
+ goalId: user1GoalId,
+ description: 'Injected task',
+ }).catch((err) => err.status)
+
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from editing goals in another org', async () => {
+ const status = await user2Api.goals.updateGoal({
+ id: user1GoalId,
+ name: 'Hacked Project',
+ }).catch((err) => err.status)
+
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from deleting goals in another org', async () => {
+ const status = await user2Api.goals.deleteGoal(user1GoalId).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+
+ const goals = await user1Api.goals.fetchGoals(user1OrgId)
+ expect(goals.find(g => g.id === user1GoalId)).toBeTruthy()
+ })
+})
+
+describe('Regular member restrictions', () => {
+ let orgId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Member Restrictions Org' })
+ orgId = org.id
+
+ await user1Api.organizations.addMember({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'member',
+ })
+ })
+
+ it('should deny regular member from updating org details', async () => {
+ const status = await user2Api.organizations.update({
+ organizationId: orgId,
+ name: 'Member Changed Name',
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+ })
+
+ it('should deny regular member from adding members', async () => {
+ const status = await user2Api.organizations.addMember({
+ organizationId: orgId,
+ email: '[email protected]',
+ role: 'member',
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+ })
+
+ it('should deny regular member from changing member roles', async () => {
+ const status = await user2Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'admin',
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+ })
+
+ it('should deny regular member from removing members', async () => {
+ const status = await user2Api.organizations.removeMember({
+ organizationId: orgId,
+ email: user1Email,
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+ })
+
+ it('should deny regular member from deleting org', async () => {
+ const status = await user2Api.organizations.delete({
+ organizationId: orgId,
+ }).catch((err) => err.status)
+
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should allow regular member to view org members', async () => {
+ const members = await user2Api.organizations.fetchMembers(orgId)
+ expect(members.length).toBeGreaterThan(0)
+ })
+
+ it('should allow regular member to view org details', async () => {
+ const org = await user2Api.organizations.getById(orgId)
+ expect(org).toBeTruthy()
+ expect(org.name).toBe('Member Restrictions Org')
+ })
+})
+
+describe('Slug uniqueness', () => {
+ it('should not allow creating two organizations with the same slug', async () => {
+ const slug = `unique-slug-${Date.now()}`
+ const org1 = await user1Api.organizations.create({ name: 'Slug Org 1', slug })
+ expect(org1).toBeTruthy()
+ expect(org1.slug).toBe(slug)
+
+ const org2 = await user1Api.organizations.create({ name: 'Slug Org 2', slug }).catch(() => null)
+ expect(org2).toBeFalsy()
+ })
+
+ it('should not allow updating slug to an existing one', async () => {
+ const slug1 = `slug-a-${Date.now()}`
+ const slug2 = `slug-b-${Date.now()}`
+ const org1 = await user1Api.organizations.create({ name: 'Slug A', slug: slug1 })
+ await user1Api.organizations.create({ name: 'Slug B', slug: slug2 })
+
+ const result = await user1Api.organizations.update({
+ organizationId: org1.id,
+ slug: slug2,
+ }).catch(() => null)
+
+ expect(result).toBeFalsy()
+ })
+})
+
+describe('Admin can create projects and manage members', () => {
+ let orgId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Admin Powers Org' })
+ orgId = org.id
+
+ await user1Api.organizations.addMember({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'admin',
+ })
+ })
+
+ it('should allow admin to create a project', async () => {
+ const goal = await user2Api.goals.createGoal({
+ name: 'Admin Project',
+ organizationId: orgId,
+ })
+
+ expect(goal).toBeTruthy()
+ expect(goal!.name).toBe('Admin Project')
+ expect(goal!.organizationId).toBe(orgId)
+ })
+
+ it('should allow admin to add members', async () => {
+ const member = await user2Api.organizations.addMember({
+ organizationId: orgId,
+ email: `admin-invited-${Date.now()}@test.com`,
+ role: 'member',
+ })
+
+ expect(member).toBeTruthy()
+ expect(member.role).toBe('member')
+ })
+
+ it('should allow admin to change member roles', async () => {
+ const email = `role-change-${Date.now()}@test.com`
+ await user2Api.organizations.addMember({
+ organizationId: orgId,
+ email,
+ role: 'member',
+ })
+
+ const updated = await user2Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email,
+ role: 'admin',
+ })
+
+ expect(updated).toBeTruthy()
+ expect(updated.role).toBe('admin')
+ })
+
+ it('should allow admin to remove members', async () => {
+ const email = `removable-admin-${Date.now()}@test.com`
+ await user2Api.organizations.addMember({
+ organizationId: orgId,
+ email,
+ role: 'member',
+ })
+
+ const result = await user2Api.organizations.removeMember({
+ organizationId: orgId,
+ email,
+ })
+
+ expect(result).toBeTruthy()
+ })
+})
+
+describe('Task-level cross-org isolation', () => {
+ let user1OrgId: number
+ let user1GoalId: number
+ let user1TaskId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Task Isolation Org' })
+ user1OrgId = org.id
+
+ const goal = await user1Api.goals.createGoal({
+ name: 'Task Isolation Project',
+ organizationId: user1OrgId,
+ })
+ user1GoalId = goal!.id
+
+ const task = await user1Api.tasks.createTask({
+ goalId: user1GoalId,
+ description: 'Secret task',
+ })
+ user1TaskId = task!.id
+ })
+
+ it('should deny non-member from fetching task by id', async () => {
+ const status = await user2Api.tasks.fetchTaskById(user1TaskId).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from updating a task', async () => {
+ const status = await user2Api.tasks.updateTask({
+ id: user1TaskId,
+ description: 'Hacked',
+ }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from deleting a task', async () => {
+ const status = await user2Api.tasks.deleteTask(user1TaskId).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+
+ // task still exists for owner
+ const task = await user1Api.tasks.fetchTaskById(user1TaskId)
+ expect(task).toBeTruthy()
+ expect(task!.id).toBe(user1TaskId)
+ })
+})
+
+describe('Goal list cross-org isolation', () => {
+ let user1GoalId: number
+ let user1ListId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'List Isolation Org' })
+ const goal = await user1Api.goals.createGoal({
+ name: 'List Isolation Project',
+ organizationId: org.id,
+ })
+ user1GoalId = goal!.id
+
+ const list = await user1Api.goalLists.createList({
+ name: 'Secret List',
+ goalId: user1GoalId,
+ })
+ user1ListId = list!.id
+ })
+
+ it('should deny non-member from fetching lists of another org project', async () => {
+ const status = await user2Api.goalLists.fetchLists({ goalId: user1GoalId }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from creating lists in another org project', async () => {
+ const status = await user2Api.goalLists.createList({
+ name: 'Injected List',
+ goalId: user1GoalId,
+ }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from updating lists in another org project', async () => {
+ const status = await user2Api.goalLists.updateList({
+ id: user1ListId,
+ name: 'Hacked List',
+ }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from deleting lists in another org project', async () => {
+ const status = await user2Api.goalLists.deleteList(user1ListId).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+
+ // list still exists
+ const lists = await user1Api.goalLists.fetchLists({ goalId: user1GoalId })
+ expect(lists!.find(l => l.id === user1ListId)).toBeTruthy()
+ })
+})
+
+describe('Tag cross-org isolation', () => {
+ let user1GoalId: number
+ let user1TagId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Tag Isolation Org' })
+ const goal = await user1Api.goals.createGoal({
+ name: 'Tag Isolation Project',
+ organizationId: org.id,
+ })
+ user1GoalId = goal!.id
+
+ const tag = await user1Api.tags.createTag({
+ name: 'Secret Tag',
+ color: '#ff0000',
+ goalId: user1GoalId,
+ })
+ user1TagId = tag!.id
+ })
+
+ it('should deny non-member from creating tags in another org project', async () => {
+ const status = await user2Api.tags.createTag({
+ name: 'Injected Tag',
+ color: '#000000',
+ goalId: user1GoalId,
+ }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from updating tags in another org project', async () => {
+ const status = await user2Api.tags.updateTag({
+ id: user1TagId,
+ name: 'Hacked Tag',
+ color: '#000000',
+ goalId: user1GoalId,
+ }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should deny non-member from deleting tags in another org project', async () => {
+ const status = await user2Api.tags.deleteTag({ tagId: user1TagId }).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+})
+
+describe('User in multiple organizations', () => {
+ let org1Id: number
+ let org2Id: number
+ let goal1Id: number
+ let goal2Id: number
+
+ beforeAll(async () => {
+ const org1 = await user1Api.organizations.create({ name: 'Multi Org 1' })
+ const org2 = await user1Api.organizations.create({ name: 'Multi Org 2' })
+ org1Id = org1.id
+ org2Id = org2.id
+
+ const goal1 = await user1Api.goals.createGoal({ name: 'Org1 Only Project', organizationId: org1Id })
+ const goal2 = await user1Api.goals.createGoal({ name: 'Org2 Only Project', organizationId: org2Id })
+ goal1Id = goal1!.id
+ goal2Id = goal2!.id
+
+ // user2 is member of both orgs
+ await user1Api.organizations.addMember({ organizationId: org1Id, email: user2Email, role: 'member' })
+ await user1Api.organizations.addMember({ organizationId: org2Id, email: user2Email, role: 'admin' })
+
+ // invite user2 to projects so they can see them
+ await user1Api.collaboration.inviteUserToGoal({ goalId: goal1Id, email: user2Email })
+ await user1Api.collaboration.inviteUserToGoal({ goalId: goal2Id, email: user2Email })
+ })
+
+ it('should list both organizations for user2', async () => {
+ const orgs = await user2Api.organizations.fetch()
+ expect(orgs.find(o => o.id === org1Id)).toBeTruthy()
+ expect(orgs.find(o => o.id === org2Id)).toBeTruthy()
+ })
+
+ it('should return only org1 projects when fetching org1', async () => {
+ const goals = await user2Api.goals.fetchGoals(org1Id)
+ expect(goals.some(g => g.name === 'Org1 Only Project')).toBe(true)
+ expect(goals.some(g => g.name === 'Org2 Only Project')).toBe(false)
+ })
+
+ it('should return only org2 projects when fetching org2', async () => {
+ const goals = await user2Api.goals.fetchGoals(org2Id)
+ expect(goals.some(g => g.name === 'Org2 Only Project')).toBe(true)
+ expect(goals.some(g => g.name === 'Org1 Only Project')).toBe(false)
+ })
+})
+
+describe('Collaboration cleanup on member removal', () => {
+ it('should remove user from project collaboration when removed from org', async () => {
+ const org = await user1Api.organizations.create({ name: 'Collab Cleanup Org' })
+
+ const goal = await user1Api.goals.createGoal({
+ name: 'Collab Cleanup Project',
+ organizationId: org.id,
+ })
+
+ // add user2 as member and invite to project
+ await user1Api.organizations.addMember({
+ organizationId: org.id,
+ email: user2Email,
+ role: 'admin',
+ })
+ await user1Api.collaboration.inviteUserToGoal({
+ goalId: goal!.id,
+ email: user2Email,
+ })
+
+ // verify user2 is in collaboration
+ const usersBefore = await user1Api.collaboration.fetchUsersForGoal(goal!.id)
+ expect(usersBefore?.find(u => u.email === user2Email)).toBeTruthy()
+
+ // remove user2 from org
+ await user1Api.organizations.removeMember({
+ organizationId: org.id,
+ email: user2Email,
+ })
+
+ // user2 should be removed from collaboration
+ const usersAfter = await user1Api.collaboration.fetchUsersForGoal(goal!.id)
+ const user2After = usersAfter?.find(u => u.email === user2Email)
+ expect(user2After).toBeUndefined()
+ })
+})
+
+describe('Privilege escalation prevention', () => {
+ let orgId: number
+
+ beforeAll(async () => {
+ const org = await user1Api.organizations.create({ name: 'Escalation Test Org' })
+ orgId = org.id
+
+ await user1Api.organizations.addMember({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'member',
+ })
+ })
+
+ it('should not allow member to escalate self to admin', async () => {
+ const status = await user2Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'admin',
+ }).catch((err) => err.status)
+
+ expect(status).toBe(403)
+
+ const members = await user1Api.organizations.fetchMembers(orgId)
+ const user2 = members.find(m => m.email === user2Email)
+ expect(user2!.role).toBe('member')
+ })
+
+ it('should not allow admin to change owner role', async () => {
+ // promote user2 to admin first
+ await user1Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: user2Email,
+ role: 'admin',
+ })
+
+ await user2Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: user1Email,
+ role: 'member',
+ }).catch(() => null)
+
+ // owner is still owner
+ const members = await user1Api.organizations.fetchMembers(orgId)
+ const owner = members.find(m => m.email === user1Email)
+ expect(owner!.role).toBe('owner')
+ })
+
+ it('should not allow setting role to owner via API', async () => {
+ await user1Api.organizations.updateMemberRole({
+ organizationId: orgId,
+ email: user2Email,
+ // @ts-expect-error - owner is not a valid role
+ role: 'owner',
+ }).catch(() => null)
+
+ const members = await user1Api.organizations.fetchMembers(orgId)
+ const user2 = members.find(m => m.email === user2Email)
+ expect(user2!.role).not.toBe('owner')
+ })
+})
+
+describe('Email case sensitivity', () => {
+ it('should not create duplicate members with different email case', async () => {
+ const org = await user1Api.organizations.create({ name: 'Case Test Org' })
+
+ await user1Api.organizations.addMember({
+ organizationId: org.id,
+ email: user2Email,
+ role: 'member',
+ })
+
+ // try adding same email with uppercase
+ const upper = user2Email.toUpperCase()
+ await user1Api.organizations.addMember({
+ organizationId: org.id,
+ email: upper,
+ role: 'admin',
+ }).catch(() => null)
+
+ const members = await user1Api.organizations.fetchMembers(org.id)
+ const user2Members = members.filter(m =>
+ m.email.toLowerCase() === user2Email.toLowerCase()
+ )
+ // should be exactly 1 entry, not 2
+ expect(user2Members.length).toBe(1)
+ })
+})
+
+describe('Edge cases and error handling', () => {
+ it('should handle non-existent organization ID gracefully', async () => {
+ const status = await user1Api.organizations.getById(999999).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should return empty members for non-existent org', async () => {
+ const status = await user1Api.organizations.fetchMembers(999999).catch((err) => err.status)
+ expect(status).toBeGreaterThanOrEqual(400)
+ })
+
+ it('should handle removing non-existent member gracefully', async () => {
+ const org = await user1Api.organizations.create({ name: 'Remove Ghost Org' })
+
+ const result = await user1Api.organizations.removeMember({
+ organizationId: org.id,
+ email: '[email protected]',
+ }).catch(() => null)
+
+ // should not crash — returns false or null
+ expect(result).toBeFalsy()
+ })
+
+ it('should reject creating organization with empty name', async () => {
+ const result = await user1Api.organizations.create({ name: '' }).catch(() => null)
+ expect(result).toBeFalsy()
+ })
+
+ it('should handle double-invite of same user to org', async () => {
+ const org = await user1Api.organizations.create({ name: 'Double Invite Org' })
+
+ const first = await user1Api.organizations.addMember({
+ organizationId: org.id,
+ email: user2Email,
+ role: 'member',
+ })
+ expect(first).toBeTruthy()
+
+ // second invite should not duplicate
+ await user1Api.organizations.addMember({
+ organizationId: org.id,
+ email: user2Email,
+ role: 'member',
+ }).catch(() => null)
+
+ const members = await user1Api.organizations.fetchMembers(org.id)
+ const user2Members = members.filter(m => m.email === user2Email)
+ expect(user2Members.length).toBe(1)
+ })
+
+ it('should handle double-invite of same user to goal collaboration', async () => {
+ const org = await user1Api.organizations.create({ name: 'Double Collab Org' })
+ const goal = await user1Api.goals.createGoal({
+ name: 'Double Collab Project',
+ organizationId: org.id,
+ })
+
+ const email = `double-${Date.now()}@test.com`
+ await user1Api.collaboration.inviteUserToGoal({ goalId: goal!.id, email })
+ await user1Api.collaboration.inviteUserToGoal({ goalId: goal!.id, email }).catch(() => null)
+
+ const users = await user1Api.collaboration.fetchUsersForGoal(goal!.id)
+ const entries = users?.filter(u => u.email === email)
+ expect(entries!.length).toBe(1)
+ })
+})
+
+describe('Goal deletion cleans up collaboration', () => {
+ it('should remove collaboration records when goal is deleted', async () => {
+ const org = await user1Api.organizations.create({ name: 'Goal Delete Cleanup Org' })
+ const goal = await user1Api.goals.createGoal({
+ name: 'Will Be Deleted Project',
+ organizationId: org.id,
+ })
+
+ const email = `cleanup-${Date.now()}@test.com`
+ await user1Api.collaboration.inviteUserToGoal({ goalId: goal!.id, email })
+
+ // verify user exists in collaboration
+ const usersBefore = await user1Api.collaboration.fetchUsersForGoal(goal!.id)
+ expect(usersBefore?.find(u => u.email === email)).toBeTruthy()
+
+ // delete goal
+ await user1Api.goals.deleteGoal(goal!.id)
+
+ // goal no longer exists
+ const goals = await user1Api.goals.fetchGoals(org.id)
+ expect(goals.find(g => g.id === goal!.id)).toBeUndefined()
+ })
+})
+
+describe('Organization deletion', () => {
+ it('should not allow deleting personal workspace', async () => {
+ const orgs = await user1Api.organizations.fetch()
+ const personal = orgs.find(o => (o as any).isPersonal === 1)
+
+ if (personal) {
+ await user1Api.organizations.delete({
+ organizationId: personal.id,
+ }).catch(() => null)
+
+ const orgsAfter = await user1Api.organizations.fetch()
+ const stillExists = orgsAfter.find(o => o.id === personal.id)
+ expect(stillExists).toBeTruthy()
+ }
+ })
+
+ it('should not allow non-owner to delete organization', async () => {
+ const org = await user1Api.organizations.create({ name: 'Delete Test Org' })
+
+ await user1Api.organizations.addMember({
+ organizationId: org.id,
+ email: user2Email,
+ role: 'admin',
+ })
+
+ await user2Api.organizations.delete({
+ organizationId: org.id,
+ }).catch(() => null)
+
+ const orgs = await user1Api.organizations.fetch()
+ const stillExists = orgs.find(o => o.id === org.id)
+ expect(stillExists).toBeTruthy()
+ })
+
+ it('should allow owner to delete organization', async () => {
+ const org = await user1Api.organizations.create({ name: 'Will Be Deleted' })
+
+ const result = await user1Api.organizations.delete({
+ organizationId: org.id,
+ })
+
+ expect(result).toBeTruthy()
+
+ const orgs = await user1Api.organizations.fetch()
+ const deleted = orgs.find(o => o.id === org.id)
+ expect(deleted).toBeUndefined()
+ })
+})
diff --git a/taskview-packages/taskview-api/src/api/__tests__/permissions.test.ts b/taskview-packages/taskview-api/src/api/__tests__/permissions.test.ts
index 97c5434..e72cd58 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/permissions.test.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/permissions.test.ts
@@ -45,11 +45,9 @@ const getTestTask = (goalId: number): TaskArgAdd => {
const priorityId: 1 | 2 | 3 = 1; //Math.floor(Math.random() * 3) + 1 as 1 | 2 | 3;
const startDate = `2025-01-14`;
const endDate = `2025-01-15`;
- const startTime = `00:14:00+02`;
- const endTime = `00:15:00+02`;
+ const startTime = `00:14:00`;
+ const endTime = `00:15:00`;
const statusId = null;
- const taskOrder = 1;
- const kanbanOrder = 1;
const complete = false;
const note = `test note-${Date.now()}`;
@@ -64,8 +62,6 @@ const getTestTask = (goalId: number): TaskArgAdd => {
note: note,
endTime: endTime,
statusId: statusId,
- taskOrder: taskOrder,
- kanbanOrder: kanbanOrder,
amount: amount,
transactionType: transactionType,
nodeGraphPosition: nodeGraphPosition,
@@ -74,6 +70,7 @@ const getTestTask = (goalId: number): TaskArgAdd => {
describe('TvApi permissions tests', () => {
let $mainUser: TvApi;
let $invitedUser: TvApi;
+ let invitedUserEmail: string;
let mainUserGoalId: number;
let roleId: number;
let timestampTestFetch: number;
@@ -112,9 +109,10 @@ describe('TvApi permissions tests', () => {
};
beforeAll(async () => {
- const { $tvApi, $tvApiForSecondUser } = await initApi();
+ const { $tvApi, $tvApiForSecondUser, user2Email } = await initApi();
$mainUser = $tvApi;
$invitedUser = $tvApiForSecondUser;
+ invitedUserEmail = user2Email;
});
@@ -145,7 +143,7 @@ describe('TvApi permissions tests', () => {
console.log('roleId', roleId);
const addUserResponse = await $mainUser.collaboration.inviteUserToGoal({
- email: '[email protected]',
+ email: invitedUserEmail,
goalId: mainUserGoalId,
}).catch(console.error);
@@ -185,7 +183,7 @@ describe('TvApi permissions tests', () => {
it('should owner have access to the goal content', async () => {
const goals = await $mainUser.goals.fetchGoals().catch(console.error);
expect(goals).toBeDefined();
- expect(goals?.length).toBeGreaterThan(1);
+ expect(goals?.length).toBeGreaterThanOrEqual(1);
expect(goals?.some(goal => goal.id === mainUserGoalId)).toBe(true);
const lists = await $mainUser.goalLists.fetchLists({ goalId: mainUserGoalId }).catch(console.error);
diff --git a/taskview-packages/taskview-api/src/api/__tests__/sessions.test.ts b/taskview-packages/taskview-api/src/api/__tests__/sessions.test.ts
new file mode 100644
index 0000000..b80df79
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/sessions.test.ts
@@ -0,0 +1,85 @@
+import { TvApi } from '@/tv'
+import {
+ describe,
+ it,
+ expect,
+ beforeAll,
+} from 'vitest'
+import { initApi } from './init-api'
+
+describe('Sessions', () => {
+ let $api: TvApi
+
+ beforeAll(async () => {
+ const { $tvApi } = await initApi()
+ $api = $tvApi
+ })
+
+ describe('Fetch sessions', () => {
+ it('should return at least one session', async () => {
+ const sessions = await $api.sessions.fetch().catch(console.error)
+
+ if (!sessions) {
+ throw new Error('Failed to fetch sessions')
+ }
+
+ expect(sessions.length).toBeGreaterThanOrEqual(1)
+ })
+
+ it('should have id and createdAt on each session', async () => {
+ const sessions = await $api.sessions.fetch().catch(console.error)
+
+ if (!sessions) {
+ throw new Error('Failed to fetch sessions')
+ }
+
+ for (const session of sessions) {
+ expect(session.id).toBeDefined()
+ expect(session.id).toBeGreaterThan(0)
+ expect(session.createdAt).toBeDefined()
+ expect(typeof session.createdAt).toBe('string')
+ }
+ })
+
+ it('should have exactly one current session', async () => {
+ const sessions = await $api.sessions.fetch().catch(console.error)
+
+ if (!sessions) {
+ throw new Error('Failed to fetch sessions')
+ }
+
+ const currentSessions = sessions.filter((s) => s.isCurrent)
+ expect(currentSessions.length).toBe(1)
+ })
+ })
+
+ describe('Delete session', () => {
+ it('should delete a non-current session if one exists', async () => {
+ const sessions = await $api.sessions.fetch().catch(console.error)
+
+ if (!sessions) {
+ throw new Error('Failed to fetch sessions')
+ }
+
+ const nonCurrent = sessions.find((s) => !s.isCurrent)
+
+ if (!nonCurrent) {
+ // Only the current session exists, nothing to delete
+ return
+ }
+
+ const deleteResult = await $api.sessions.delete(nonCurrent.id).catch(console.error)
+ expect(deleteResult).toBe(true)
+
+ const sessionsAfter = await $api.sessions.fetch().catch(console.error)
+
+ if (!sessionsAfter) {
+ throw new Error('Failed to fetch sessions after delete')
+ }
+
+ const found = sessionsAfter.find((s) => s.id === nonCurrent.id)
+ expect(found).toBeUndefined()
+ })
+ })
+
+})
diff --git a/taskview-packages/taskview-api/src/api/__tests__/setup-db.ts b/taskview-packages/taskview-api/src/api/__tests__/setup-db.ts
index aa9148e..4b0fa60 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/setup-db.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/setup-db.ts
@@ -6,10 +6,10 @@ let dbClient: Client;
export default async function setup() {
dbClient = new Client({
host: DB_CREDENTIALS.DB_HOST || 'localhost',
- port: parseInt(DB_CREDENTIALS.DB_PORT || '5454'),
- database: DB_CREDENTIALS.DB_NAME || 'task_view_test_db',
- user: DB_CREDENTIALS.DB_USER || 'tv-test-db-user',
- password: DB_CREDENTIALS.DB_PASSWORD || 'tv-test-db-password',
+ port: parseInt(DB_CREDENTIALS.DB_PORT || '15432'),
+ database: DB_CREDENTIALS.DB_NAME || 'taskviewdb',
+ user: DB_CREDENTIALS.DB_USER || 'tvdbuser',
+ password: DB_CREDENTIALS.DB_PASSWORD || 'tvdbpass',
});
await dbClient.connect();
@@ -28,18 +28,74 @@ export default async function setup() {
};
}
+async function tableExists(table: string) {
+ const [schema, name] = table.split('.');
+ const result = await dbClient.query(
+ `SELECT 1 FROM information_schema.tables WHERE table_schema = $1 AND table_name = $2`,
+ [schema, name]
+ );
+ return result.rowCount! > 0;
+}
+
async function cleanDatabase() {
- const tables = ['tasks.goals', 'tasks.goals', 'collaboration.users', 'history.tasks_tasks', 'collaboration.users'];
+ // Delete non-personal organizations (preserves personal workspaces)
+ if (await tableExists('tv_auth.organization_members')) {
+ await dbClient.query(`DELETE FROM tv_auth.organization_members WHERE organization_id IN (SELECT id FROM tv_auth.organizations WHERE is_personal = 0);`);
+ await dbClient.query(`DELETE FROM tv_auth.organizations WHERE is_personal = 0;`);
+ console.log('Cleaned non-personal organizations');
+ }
+
+ const tables = [
+ 'tv_auth.api_tokens',
+ 'history.tasks_tasks',
+ 'collaboration.users',
+ 'tasks.goals',
+ ];
for (const table of tables) {
- await dbClient.query(`TRUNCATE TABLE ${table} CASCADE;`);
- console.log(`Truncated table ${table}`);
+ if (await tableExists(table)) {
+ await dbClient.query(`TRUNCATE TABLE ${table} CASCADE;`);
+ console.log(`Truncated table ${table}`);
+ }
}
}
async function addUsersIfNotExists() {
- const users = await dbClient.query(`SELECT * FROM tv_auth.users where login = 'user2';`);
- if (users.rows.length === 0) {
- await dbClient.query(`INSERT INTO tv_auth.users (login,email,password,block) VALUES ('user2','[email protected]','$2y$10$q8SLauZ0Syz9aEFdiq0i8.jIlafLj5T0ujXYD7RmRzyNkZ2hR7uhO', 0);`);
+ // Password for both: user1!#Q
+ const hash = '$2a$10$oGfwSbhvI.8I.RfW5oUayOUk61O50aGy5xzMC56UMEWDr.E0o09NK';
+ await dbClient.query(`
+ INSERT INTO tv_auth.users (login, email, password, block)
+ VALUES
+ ('user', '[email protected]', '${hash}', 0),
+ ('user2', '[email protected]', '${hash}', 0)
+ ON CONFLICT DO NOTHING;
+ `);
+
+ // Create personal workspaces if organizations table exists
+ if (await tableExists('tv_auth.organizations')) {
+ await dbClient.query(`
+ INSERT INTO tv_auth.organizations (name, slug, owner_id, is_personal)
+ SELECT
+ u.login || '''s workspace',
+ 'org-' || substr(md5(random()::text), 1, 8),
+ u.id,
+ 1
+ FROM tv_auth.users u
+ WHERE u.login IN ('user', 'user2')
+ AND NOT EXISTS (
+ SELECT 1 FROM tv_auth.organizations o
+ WHERE o.owner_id = u.id AND o.is_personal = 1
+ );
+ `);
+
+ await dbClient.query(`
+ INSERT INTO tv_auth.organization_members (organization_id, email, role)
+ SELECT o.id, u.email, 'owner'
+ FROM tv_auth.organizations o
+ JOIN tv_auth.users u ON u.id = o.owner_id
+ WHERE o.is_personal = 1
+ ON CONFLICT (organization_id, email) DO NOTHING;
+ `);
+ console.log('Created personal workspaces for test users');
}
}
diff --git a/taskview-packages/taskview-api/src/api/__tests__/tags.test.ts b/taskview-packages/taskview-api/src/api/__tests__/tags.test.ts
index f53d0f8..0f95310 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/tags.test.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/tags.test.ts
@@ -121,6 +121,34 @@ describe('TvApi tags tests', () => {
expect(updateTagResponse.goalId).toBe(goalId);
});
+
+ it('should update tag color', async () => {
+ const name = `test tag-${Date.now()}`;
+ const addTagResponse = await $api.tags.createTag({
+ name: name,
+ color: 'original color',
+ goalId: goalId,
+ }).catch(console.error);
+
+ if (!addTagResponse) {
+ throw new Error('Failed to add tag');
+ }
+
+ const updateTagResponse = await $api.tags.updateTag({
+ id: addTagResponse.id,
+ name: addTagResponse.name,
+ color: '#00ff00',
+ goalId: goalId,
+ }).catch(console.error);
+
+ if (!updateTagResponse) {
+ throw new Error('Failed to update tag');
+ }
+
+ expect(updateTagResponse.id).toBe(addTagResponse.id);
+ expect(updateTagResponse.color).toBe('#00ff00');
+ expect(updateTagResponse.name).toBe(name);
+ });
});
describe('Tags fetch all', () => {
@@ -147,10 +175,65 @@ describe('TvApi tags tests', () => {
expect(tag?.goalId).toBe(goalId);
expect(tag?.owner).toBe(1);
});
+
+ it('should fetch tags filtered by goalId', async () => {
+ const name = `test tag filtered-${Date.now()}`;
+ const addTagResponse = await $api.tags.createTag({
+ name: name,
+ color: 'filter color',
+ goalId: goalId,
+ }).catch(console.error);
+
+ if (!addTagResponse) {
+ throw new Error('Failed to add tag');
+ }
+
+ const fetchAllTagsResponse = await $api.tags.fetchAllTagsForUser().catch(console.error);
+ if (!fetchAllTagsResponse) {
+ throw new Error('Failed to fetch all tags');
+ }
+
+ const tagsForGoal = fetchAllTagsResponse.filter((tag) => tag.goalId === goalId);
+ expect(tagsForGoal.length).toBeGreaterThan(0);
+ tagsForGoal.forEach((tag) => {
+ expect(tag.goalId).toBe(goalId);
+ });
+ });
});
describe('Tags toggle', () => {
- //TODO add test for toggle tag when tasks module will be implemented
+ it('should toggle tag on a task', async () => {
+ const tag = await $api.tags.createTag({
+ name: `toggle tag-${Date.now()}`,
+ color: '#ff0000',
+ goalId: goalId,
+ }).catch(console.error);
+
+ if (!tag) {
+ throw new Error('Failed to add tag');
+ }
+
+ const task = await $api.tasks.createTask({
+ goalId: goalId,
+ description: 'toggle test',
+ }).catch(console.error);
+
+ if (!task) {
+ throw new Error('Failed to create task');
+ }
+
+ const toggleResult = await $api.tags.toggleTag({
+ taskId: task.id,
+ tagId: tag.id,
+ }).catch(console.error);
+
+ if (!toggleResult) {
+ throw new Error('Failed to toggle tag');
+ }
+
+ expect(toggleResult).toBeDefined();
+ });
+
it('should fail to toggle tag', async () => {
const toggleTagResponse = await $api.tags.toggleTag({
tagId: -400,
diff --git a/taskview-packages/taskview-api/src/api/__tests__/tasks.test.ts b/taskview-packages/taskview-api/src/api/__tests__/tasks.test.ts
index bbea2c4..5bab0dd 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/tasks.test.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/tasks.test.ts
@@ -43,11 +43,9 @@ const getTestTask = (goalId: number): TaskArgAdd => {
const priorityId: 1 | 2 | 3 = 1; //Math.floor(Math.random() * 3) + 1 as 1 | 2 | 3;
const startDate = `2025-01-14`;
const endDate = `2025-01-15`;
- const startTime = `00:14:00+02`;
- const endTime = `00:15:00+02`;
+ const startTime = `00:14:00`;
+ const endTime = `00:15:00`;
const statusId = null;
- const taskOrder = 1;
- const kanbanOrder = 1;
const complete = false;
return {
@@ -60,8 +58,6 @@ const getTestTask = (goalId: number): TaskArgAdd => {
startTime: startTime,
endTime: endTime,
statusId: statusId,
- taskOrder: taskOrder,
- kanbanOrder: kanbanOrder,
amount: amount,
transactionType: transactionType,
nodeGraphPosition: nodeGraphPosition,
@@ -736,8 +732,8 @@ describe('TvApi tags tests', () => {
it('endDate startDate endTime startTime are null', async () => {
let endDate: string | null = '2025-01-15';
let startDate: string | null = '2025-01-14';
- let endTime: string | null = '00:15:00+02';
- let startTime: string | null = '00:14:00+02';
+ let endTime: string | null = '00:15:00';
+ let startTime: string | null = '00:14:00';
let taskResponse = await $api.tasks.updateTask({
id: taskForUpdate?.id!,
@@ -765,7 +761,7 @@ describe('TvApi tags tests', () => {
});
it('startTime', async () => {
- const startTime = `00:14:00+02`;
+ const startTime = `00:14:00`;
const taskResponse = await $api.tasks.updateTask({
id: taskForUpdate?.id!,
startTime
@@ -775,7 +771,7 @@ describe('TvApi tags tests', () => {
});
it('endTime', async () => {
- const endTime = `00:15:00+02`;
+ const endTime = `00:15:00`;
const taskResponse = await $api.tasks.updateTask({
id: taskForUpdate?.id!,
endTime
@@ -815,13 +811,13 @@ describe('TvApi tags tests', () => {
});
it('amount', async () => {
- const amount = 100;
+ const amount = '100';
const taskResponse = await $api.tasks.updateTask({
id: taskForUpdate?.id!,
amount
}).catch(console.error);
expect(taskResponse).toBeDefined();
- expect(taskResponse).toMatchObject({ ...taskForUpdate, amount });
+ expect(taskResponse!.amount).toBe('100.00');
});
it('transactionType', async () => {
@@ -916,18 +912,21 @@ describe('TvApi tags tests', () => {
if (!addTaskResponse) {
throw new Error('Failed to add task');
}
- expect(addTaskResponse).toMatchObject({ ...task, parentId: parentTaskResponse.id });
+ const { amount: _a, ...taskWithoutAmount } = { ...task, parentId: parentTaskResponse.id };
+ expect(addTaskResponse).toMatchObject(taskWithoutAmount);
+ expect(addTaskResponse.amount).toBe('100.00');
});
it('should add task with all fields', async () => {
const task = getTestTask(goalId);
const addTaskResponse = await $api.tasks.createTask(task).catch(console.error);
- console.log(addTaskResponse)
if (!addTaskResponse) {
throw new Error('Failed to add task');
}
- expect(addTaskResponse).toMatchObject(task);
+ const { amount: _a, ...taskWithoutAmount } = task;
+ expect(addTaskResponse).toMatchObject(taskWithoutAmount);
+ expect(addTaskResponse.amount).toBe('100.00');
});
it('should add task with name', async () => {
diff --git a/taskview-packages/taskview-api/src/api/__tests__/teardown-db.ts b/taskview-packages/taskview-api/src/api/__tests__/teardown-db.ts
index ab460a2..0963bc3 100644
--- a/taskview-packages/taskview-api/src/api/__tests__/teardown-db.ts
+++ b/taskview-packages/taskview-api/src/api/__tests__/teardown-db.ts
@@ -3,11 +3,35 @@ export default async function teardown() {
console.log('Database cleaned teardown');
}
+async function tableExists(client: any, table: string) {
+ const [schema, name] = table.split('.');
+ const result = await client.query(
+ `SELECT 1 FROM information_schema.tables WHERE table_schema = $1 AND table_name = $2`,
+ [schema, name]
+ );
+ return result.rowCount! > 0;
+}
+
async function cleanDatabase() {
- const tables = ['tasks.goals', 'tasks.goals', 'collaboration.users', 'history.tasks_tasks', 'collaboration.users'];
+ const client = (global as any).__TEST_DB_CLIENT__;
+
+ // Delete non-personal organizations (preserves personal workspaces)
+ if (await tableExists(client, 'tv_auth.organization_members')) {
+ await client.query(`DELETE FROM tv_auth.organization_members WHERE organization_id IN (SELECT id FROM tv_auth.organizations WHERE is_personal = 0);`);
+ await client.query(`DELETE FROM tv_auth.organizations WHERE is_personal = 0;`);
+ }
+
+ const tables = [
+ 'tv_auth.api_tokens',
+ 'history.tasks_tasks',
+ 'collaboration.users',
+ 'tasks.goals',
+ ];
for (const table of tables) {
- await (global as any).__TEST_DB_CLIENT__.query(`TRUNCATE TABLE ${table} CASCADE;`);
+ if (await tableExists(client, table)) {
+ await client.query(`TRUNCATE TABLE ${table} CASCADE;`);
+ }
}
(global as any).__TEST_DB_CLIENT__.end();
diff --git a/taskview-packages/taskview-api/src/api/__tests__/webhooks.test.ts b/taskview-packages/taskview-api/src/api/__tests__/webhooks.test.ts
new file mode 100644
index 0000000..87704fe
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/__tests__/webhooks.test.ts
@@ -0,0 +1,419 @@
+import { TvApi } from '@/tv'
+import {
+ describe,
+ it,
+ expect,
+ beforeAll,
+ afterAll,
+} from 'vitest'
+import { initApi } from './init-api'
+import { createServer, type Server, type IncomingMessage, type ServerResponse } from 'http'
+import { networkInterfaces } from 'os'
+
+function getLocalIp(): string {
+ const nets = networkInterfaces()
+ for (const name of Object.keys(nets)) {
+ for (const net of nets[name]!) {
+ if (net.family === 'IPv4' && !net.internal) {
+ return net.address
+ }
+ }
+ }
+ return '127.0.0.1'
+}
+
+function createWebhookReceiver() {
+ const received: Array<{ body: any; headers: Record<string, string | string[] | undefined> }> = []
+ const waiters: Array<(value: any) => void> = []
+
+ const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+ let body = ''
+ req.on('data', (chunk) => { body += chunk })
+ req.on('end', () => {
+ let parsed: any = null
+ try { parsed = JSON.parse(body) } catch { parsed = body }
+ received.push({ body: parsed, headers: req.headers })
+ if (waiters.length > 0) {
+ waiters.shift()!(parsed)
+ }
+ res.writeHead(200)
+ res.end('ok')
+ })
+ })
+
+ const ip = getLocalIp()
+
+ return {
+ server,
+ received,
+ getUrl: () => `http://${ip}:${(server.address() as any).port}/webhook`,
+ start: () => new Promise<void>((resolve) => {
+ server.listen(0, '0.0.0.0', () => resolve())
+ }),
+ stop: () => new Promise<void>((resolve) => {
+ server.close(() => resolve())
+ }),
+ clear: () => { received.length = 0 },
+ waitForDelivery: (event?: string, timeoutMs = 5000) => new Promise<any>((resolve, reject) => {
+ // check already received
+ const idx = event
+ ? received.findIndex(r => r.body?.event === event)
+ : received.length > 0 ? 0 : -1
+ if (idx >= 0) {
+ resolve(received[idx].body)
+ return
+ }
+
+ const timer = setTimeout(() => {
+ reject(new Error(`No webhook delivery${event ? ` for ${event}` : ''} received within ${timeoutMs}ms`))
+ }, timeoutMs)
+
+ const check = (payload: any) => {
+ if (!event || payload?.event === event) {
+ clearTimeout(timer)
+ resolve(payload)
+ } else {
+ waiters.push(check)
+ }
+ }
+ waiters.push(check)
+ }),
+ }
+}
+
+describe('Webhooks', () => {
+ let $api: TvApi
+ let goalId: number
+ let webhookUrl: string
+ const receiver = createWebhookReceiver()
+
+ beforeAll(async () => {
+ const { $tvApi } = await initApi()
+ $api = $tvApi
+
+ await receiver.start()
+ webhookUrl = receiver.getUrl()
+
+ const goal = await $api.goals.createGoal({
+ name: `Webhook test project-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!goal) {
+ throw new Error('Failed to create goal')
+ }
+
+ goalId = goal.id!
+ })
+
+ afterAll(async () => {
+ await $api.goals.deleteGoal(goalId).catch(() => {})
+ await receiver.stop()
+ })
+
+ describe('CRUD', () => {
+ it('should create a webhook and return secret', async () => {
+ const result = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!result) {
+ throw new Error('Failed to create webhook')
+ }
+
+ expect(result.webhook).toBeDefined()
+ expect(result.webhook.id).toBeGreaterThan(0)
+ expect(result.webhook.goalId).toBe(goalId)
+ expect(result.webhook.url).toBe(webhookUrl)
+ expect(result.webhook.events).toEqual(['task.created'])
+ expect(result.webhook.isActive).toBe(true)
+ expect(result.secret).toBeDefined()
+ expect(typeof result.secret).toBe('string')
+ expect(result.secret.length).toBeGreaterThan(0)
+
+ await $api.webhooks.delete({ id: result.webhook.id })
+ })
+
+ it('should fetch webhooks for a goal', async () => {
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) {
+ throw new Error('Failed to create webhook')
+ }
+
+ const webhooks = await $api.webhooks.fetch(goalId).catch(console.error)
+
+ if (!webhooks) {
+ throw new Error('Failed to fetch webhooks')
+ }
+
+ expect(webhooks.length).toBeGreaterThanOrEqual(1)
+
+ const found = webhooks.find((w) => w.id === created.webhook.id)
+ expect(found).toBeDefined()
+ expect(found!.url).toBe(webhookUrl)
+ expect(found!.events).toEqual(['task.created'])
+ expect(found!.isActive).toBe(true)
+
+ await $api.webhooks.delete({ id: created.webhook.id })
+ })
+
+ it('should update webhook url and events', async () => {
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) {
+ throw new Error('Failed to create webhook')
+ }
+
+ const newUrl = webhookUrl + '/updated'
+ const updated = await $api.webhooks.update({
+ id: created.webhook.id,
+ url: newUrl,
+ events: ['task.created', 'task.updated', 'task.deleted'],
+ }).catch(console.error)
+
+ if (!updated) {
+ throw new Error('Failed to update webhook')
+ }
+
+ expect(updated.url).toBe(newUrl)
+ expect(updated.events).toEqual(['task.created', 'task.updated', 'task.deleted'])
+
+ await $api.webhooks.delete({ id: created.webhook.id })
+ })
+
+ it('should toggle webhook isActive', async () => {
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) {
+ throw new Error('Failed to create webhook')
+ }
+
+ const deactivated = await $api.webhooks.update({
+ id: created.webhook.id,
+ isActive: false,
+ }).catch(console.error)
+
+ expect(deactivated).toBeDefined()
+ expect(deactivated!.isActive).toBe(false)
+
+ const reactivated = await $api.webhooks.update({
+ id: created.webhook.id,
+ isActive: true,
+ }).catch(console.error)
+
+ expect(reactivated).toBeDefined()
+ expect(reactivated!.isActive).toBe(true)
+
+ await $api.webhooks.delete({ id: created.webhook.id })
+ })
+
+ it('should delete a webhook and verify it is gone', async () => {
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) {
+ throw new Error('Failed to create webhook')
+ }
+
+ const deleteResult = await $api.webhooks.delete({ id: created.webhook.id }).catch(console.error)
+ expect(deleteResult).toBe(true)
+
+ const webhooks = await $api.webhooks.fetch(goalId).catch(console.error)
+ const found = webhooks?.find((w) => w.id === created.webhook.id)
+ expect(found).toBeUndefined()
+ })
+
+ it('should rotate webhook secret', async () => {
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) {
+ throw new Error('Failed to create webhook')
+ }
+
+ const rotated = await $api.webhooks.rotateSecret(created.webhook.id).catch(console.error)
+
+ if (!rotated) {
+ throw new Error('Failed to rotate secret')
+ }
+
+ expect(rotated.secret).toBeDefined()
+ expect(typeof rotated.secret).toBe('string')
+ expect(rotated.secret.length).toBeGreaterThan(0)
+
+ await $api.webhooks.delete({ id: created.webhook.id })
+ })
+ })
+
+ describe('Webhook delivery', () => {
+ it('should deliver webhook when task is created', async () => {
+ receiver.clear()
+
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) throw new Error('Failed to create webhook')
+
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Webhook delivery test-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!task) throw new Error('Failed to create task')
+
+ const payload = await receiver.waitForDelivery('task.created', 5000)
+
+ expect(payload).toBeDefined()
+ expect(payload.event).toBe('task.created')
+ expect(payload.task).toBeDefined()
+ expect(payload.task.id).toBe(task.id)
+
+ await $api.tasks.deleteTask(task.id).catch(() => {})
+ await $api.webhooks.delete({ id: created.webhook.id })
+ }, 10000)
+
+ it('should deliver webhook when task is deleted', async () => {
+ receiver.clear()
+
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created', 'task.deleted'],
+ }).catch(console.error)
+
+ if (!created) throw new Error('Failed to create webhook')
+
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Webhook delete test-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!task) throw new Error('Failed to create task')
+
+ // wait for task.created first, then clear and delete
+ await receiver.waitForDelivery('task.created', 5000)
+ receiver.clear()
+
+ await $api.tasks.deleteTask(task.id)
+
+ const payload = await receiver.waitForDelivery('task.deleted', 5000)
+
+ expect(payload).toBeDefined()
+ expect(payload.event).toBe('task.deleted')
+
+ await $api.webhooks.delete({ id: created.webhook.id })
+ }, 15000)
+
+ it('should not deliver webhook for unsubscribed events', async () => {
+ receiver.clear()
+
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.deleted'],
+ }).catch(console.error)
+
+ if (!created) throw new Error('Failed to create webhook')
+
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `No delivery test-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!task) throw new Error('Failed to create task')
+
+ await new Promise((r) => setTimeout(r, 2000))
+ const createdEvents = receiver.received.filter(r => r.body?.event === 'task.created')
+ expect(createdEvents.length).toBe(0)
+
+ await $api.tasks.deleteTask(task.id).catch(() => {})
+ await $api.webhooks.delete({ id: created.webhook.id })
+ }, 10000)
+
+ it('should not deliver webhook when deactivated', async () => {
+ receiver.clear()
+
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) throw new Error('Failed to create webhook')
+
+ await $api.webhooks.update({
+ id: created.webhook.id,
+ isActive: false,
+ })
+
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Deactivated webhook test-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!task) throw new Error('Failed to create task')
+
+ await new Promise((r) => setTimeout(r, 2000))
+ const createdEvents = receiver.received.filter(r => r.body?.event === 'task.created')
+ expect(createdEvents.length).toBe(0)
+
+ await $api.tasks.deleteTask(task.id).catch(() => {})
+ await $api.webhooks.delete({ id: created.webhook.id })
+ }, 10000)
+
+ it('should return delivery records after webhook fires', async () => {
+ receiver.clear()
+
+ const created = await $api.webhooks.create({
+ goalId,
+ url: webhookUrl,
+ events: ['task.created'],
+ }).catch(console.error)
+
+ if (!created) throw new Error('Failed to create webhook')
+
+ const task = await $api.tasks.createTask({
+ goalId,
+ description: `Delivery records test-${Date.now()}`,
+ }).catch(console.error)
+
+ if (!task) throw new Error('Failed to create task')
+
+ await receiver.waitForDelivery('task.created', 5000)
+
+ const deliveries = await $api.webhooks.fetchDeliveries(created.webhook.id).catch(console.error)
+
+ if (!deliveries) throw new Error('Failed to fetch deliveries')
+
+ expect(deliveries.length).toBeGreaterThanOrEqual(1)
+ expect(deliveries[0].event).toBe('task.created')
+ expect(deliveries[0].status).toBeDefined()
+
+ await $api.tasks.deleteTask(task.id).catch(() => {})
+ await $api.webhooks.delete({ id: created.webhook.id })
+ }, 10000)
+ })
+})
diff --git a/taskview-packages/taskview-api/src/api/collaboration.ts b/taskview-packages/taskview-api/src/api/collaboration.ts
index 5b1d474..a93ec75 100644
--- a/taskview-packages/taskview-api/src/api/collaboration.ts
+++ b/taskview-packages/taskview-api/src/api/collaboration.ts
@@ -39,10 +39,10 @@ export class TvCollaborationApi extends TvApiBase {
);
}
- public async fetchAllUsers() {
+ public async fetchAllUsers(organizationId?: number) {
return this.request(
this.$axios.get<AppResponse<CollaborationResponseFetchAllUsers[]>>(
- `${this.moduleUrl}`
+ `${this.moduleUrl}`, organizationId ? { params: { organizationId } } : undefined
)
);
}
diff --git a/taskview-packages/taskview-api/src/api/goals.ts b/taskview-packages/taskview-api/src/api/goals.ts
index 8a7c3d5..77c8cff 100644
--- a/taskview-packages/taskview-api/src/api/goals.ts
+++ b/taskview-packages/taskview-api/src/api/goals.ts
@@ -29,10 +29,10 @@ export default class TvGoalApi extends TvApiBase {
);
}
- public async fetchGoals() {
+ public async fetchGoals(organizationId?: number) {
return this.request(
this.$axios.get<AppResponse<GoalResponseFetch>>(
- `${this.moduleUrl}`
+ `${this.moduleUrl}`, organizationId ? { params: { organizationId } } : undefined
)
);
}
diff --git a/taskview-packages/taskview-api/src/api/goals.types.ts b/taskview-packages/taskview-api/src/api/goals.types.ts
index 43f201d..85181b4 100644
--- a/taskview-packages/taskview-api/src/api/goals.types.ts
+++ b/taskview-packages/taskview-api/src/api/goals.types.ts
@@ -42,9 +42,10 @@ export type GoalItem = {
permissions: GoalPermissions;
archive: 1 | 0;
dateCreation: string | null;
+ organizationId: number | null;
};
-export type GoalArgItemAdd = Pick<GoalItem, 'name'> & Partial<Pick<GoalItem, | 'description' | 'color'>>;
+export type GoalArgItemAdd = Pick<GoalItem, 'name'> & Partial<Pick<GoalItem, 'description' | 'color' | 'organizationId'>>;
export type GoalResponseAdd = GoalItem | null;
diff --git a/taskview-packages/taskview-api/src/api/notifications.ts b/taskview-packages/taskview-api/src/api/notifications.ts
index fc83160..5359d19 100644
--- a/taskview-packages/taskview-api/src/api/notifications.ts
+++ b/taskview-packages/taskview-api/src/api/notifications.ts
@@ -5,10 +5,13 @@ import type { NotificationResponseFetch, NotificationResponseMarkRead, Notificat
export default class TvNotificationsApi extends TvApiBase {
protected moduleUrl = '/module/notifications';
- public async fetch(cursor?: number) {
+ public async fetch(cursor?: number, organizationId?: number) {
+ const params: Record<string, number> = {};
+ if (cursor) params.cursor = cursor;
+ if (organizationId) params.organizationId = organizationId;
return this.request(
this.$axios.get<AppResponse<NotificationResponseFetch>>(
- this.moduleUrl, { params: cursor ? { cursor } : {} }
+ this.moduleUrl, { params }
)
);
}
@@ -21,10 +24,11 @@ export default class TvNotificationsApi extends TvApiBase {
);
}
- public async markAllRead() {
+ public async markAllRead(organizationId?: number) {
+ const params = organizationId ? { organizationId } : undefined;
return this.request(
this.$axios.patch<AppResponse<NotificationResponseMarkRead>>(
- `${this.moduleUrl}/read-all`
+ `${this.moduleUrl}/read-all`, undefined, params ? { params } : undefined
)
);
}
diff --git a/taskview-packages/taskview-api/src/api/organizations.ts b/taskview-packages/taskview-api/src/api/organizations.ts
new file mode 100644
index 0000000..907c663
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/organizations.ts
@@ -0,0 +1,70 @@
+import TvApiBase from './base'
+import type { AppResponse } from './base.types'
+import type {
+ Organization,
+ OrganizationArgCreate,
+ OrganizationArgUpdate,
+ OrganizationArgDelete,
+ OrgMember,
+ OrgMemberArgAdd,
+ OrgMemberArgUpdateRole,
+ OrgMemberArgRemove,
+} from './organizations.types'
+
+export default class TvOrganizationsApi extends TvApiBase {
+ protected moduleUrl = '/module/organizations'
+
+ public async fetch() {
+ return this.request(
+ this.$axios.get<AppResponse<Organization[]>>(this.moduleUrl)
+ )
+ }
+
+ public async getById(orgId: number) {
+ return this.request(
+ this.$axios.get<AppResponse<Organization>>(`${this.moduleUrl}/${orgId}`)
+ )
+ }
+
+ public async create(data: OrganizationArgCreate) {
+ return this.request(
+ this.$axios.post<AppResponse<Organization>>(this.moduleUrl, data)
+ )
+ }
+
+ public async update(data: OrganizationArgUpdate) {
+ return this.request(
+ this.$axios.patch<AppResponse<Organization>>(this.moduleUrl, data)
+ )
+ }
+
+ public async delete(data: OrganizationArgDelete) {
+ return this.request(
+ this.$axios.delete<AppResponse<boolean>>(this.moduleUrl, { data })
+ )
+ }
+
+ public async fetchMembers(orgId: number) {
+ return this.request(
+ this.$axios.get<AppResponse<OrgMember[]>>(`${this.moduleUrl}/${orgId}/members`)
+ )
+ }
+
+ public async addMember(data: OrgMemberArgAdd) {
+ return this.request(
+ this.$axios.post<AppResponse<OrgMember>>(`${this.moduleUrl}/members`, data)
+ )
+ }
+
+ public async updateMemberRole(data: OrgMemberArgUpdateRole) {
+ return this.request(
+ this.$axios.patch<AppResponse<OrgMember>>(`${this.moduleUrl}/members/role`, data)
+ )
+ }
+
+ public async removeMember(data: OrgMemberArgRemove) {
+ return this.request(
+ this.$axios.delete<AppResponse<boolean>>(`${this.moduleUrl}/members`, { data })
+ )
+ }
+}
diff --git a/taskview-packages/taskview-api/src/api/organizations.types.ts b/taskview-packages/taskview-api/src/api/organizations.types.ts
new file mode 100644
index 0000000..f7e117a
--- /dev/null
+++ b/taskview-packages/taskview-api/src/api/organizations.types.ts
@@ -0,0 +1,53 @@
+export type Organization = {
+ id: number
+ name: string
+ slug: string
+ ownerId: number
+ logoUrl: string | null
+ plan: string
+ createdAt: string
+ updatedAt: string
+}
+
+export type OrgMember = {
+ id: number
+ organizationId: number
+ email: string
+ role: string
+ invitedBy: number | null
+ createdAt: string
+}
+
+export type OrganizationArgCreate = {
+ name: string
+ slug?: string
+ logoUrl?: string | null
+}
+
+export type OrganizationArgUpdate = {
+ organizationId: number
+ name?: string
+ slug?: string
+ logoUrl?: string | null
+}
+
+export type OrganizationArgDelete = {
+ organizationId: number
+}
+
+export type OrgMemberArgAdd = {
+ organizationId: number
+ email: string
+ role?: 'admin' | 'member'
+}
+
+export type OrgMemberArgUpdateRole = {
+ organizationId: number
+ email: string
+ role: 'admin' | 'member'
+}
+
+export type OrgMemberArgRemove = {
+ organizationId: number
+ email: string
+}
diff --git a/taskview-packages/taskview-api/src/api/tags.ts b/taskview-packages/taskview-api/src/api/tags.ts
index 703e880..00c109a 100644
--- a/taskview-packages/taskview-api/src/api/tags.ts
+++ b/taskview-packages/taskview-api/src/api/tags.ts
@@ -29,10 +29,10 @@ export default class TvTagsApi extends TvApiBase {
);
}
- public async fetchAllTagsForUser() {
+ public async fetchAllTagsForUser(organizationId?: number) {
return this.request(
this.$axios.get<AppResponse<TagItemResponseFetch>>(
- `${this.moduleUrl}`
+ `${this.moduleUrl}`, organizationId ? { params: { organizationId } } : undefined
)
);
}
diff --git a/taskview-packages/taskview-api/src/index.ts b/taskview-packages/taskview-api/src/index.ts
index cea0f52..fa39fcf 100644
--- a/taskview-packages/taskview-api/src/index.ts
+++ b/taskview-packages/taskview-api/src/index.ts
@@ -13,4 +13,5 @@ export * from '@/api/integrations.types';
export * from '@/api/notifications.api.types';
export * from '@/api/webhooks.types';
export * from '@/api/api-tokens.types';
-export * from '@/api/sessions.types';
\ No newline at end of file
+export * from '@/api/sessions.types';
+export * from '@/api/organizations.types';
\ No newline at end of file
diff --git a/taskview-packages/taskview-api/src/tv.ts b/taskview-packages/taskview-api/src/tv.ts
index c8f11e3..311999f 100644
--- a/taskview-packages/taskview-api/src/tv.ts
+++ b/taskview-packages/taskview-api/src/tv.ts
@@ -11,6 +11,7 @@ import TvNotificationsApi from "./api/notifications";
import TvWebhooks from "./api/webhooks";
import TvApiTokens from "./api/api-tokens";
import TvSessions from "./api/sessions";
+import TvOrganizationsApi from "./api/organizations";
export class TvApi {
@@ -40,6 +41,8 @@ export class TvApi {
public sessions: TvSessions;
+ public organizations: TvOrganizationsApi;
+
constructor($axios: AxiosInstance) {
this.$axios = $axios;
@@ -66,6 +69,8 @@ export class TvApi {
this.apiTokens = new TvApiTokens(this.$axios);
this.sessions = new TvSessions(this.$axios);
+
+ this.organizations = new TvOrganizationsApi(this.$axios);
}
public setBaseUrl(baseUrl: string) {
diff --git a/taskview-packages/taskview-api/vitest.config.ts b/taskview-packages/taskview-api/vitest.config.ts
index 19e625f..09265fe 100644
--- a/taskview-packages/taskview-api/vitest.config.ts
+++ b/taskview-packages/taskview-api/vitest.config.ts
@@ -10,5 +10,6 @@ export default defineConfig({
},
test: {
globalSetup: './src/api/__tests__/setup-db.ts',
+ fileParallelism: false,
},
})
diff --git a/taskview-packages/taskview-db-schemas/src/index.ts b/taskview-packages/taskview-db-schemas/src/index.ts
index 6f9e105..65b536d 100644
--- a/taskview-packages/taskview-db-schemas/src/index.ts
+++ b/taskview-packages/taskview-db-schemas/src/index.ts
@@ -15,3 +15,4 @@ export * from './schemas/notification-preferences.schema';
export * from './schemas/webhooks.schema';
export * from './schemas/api-tokens.schema';
export * from './schemas/user-tokens.schema';
+export * from './schemas/organizations.schema';
diff --git a/taskview-packages/taskview-db-schemas/src/schemas/goals.schema.ts b/taskview-packages/taskview-db-schemas/src/schemas/goals.schema.ts
index 0038484..264a9f4 100644
--- a/taskview-packages/taskview-db-schemas/src/schemas/goals.schema.ts
+++ b/taskview-packages/taskview-db-schemas/src/schemas/goals.schema.ts
@@ -1,5 +1,6 @@
import { integer, pgSchema, timestamp, varchar } from "drizzle-orm/pg-core";
import { UsersSchema } from "./users.schema";
+import { OrganizationsSchema } from "./organizations.schema";
// import { createInsertSchema, createSelectSchema } from "drizzle-arktype";
// we use this schema only for the database operations
export const GoalsSchema = pgSchema('tasks').table('goals', {
@@ -13,6 +14,7 @@ export const GoalsSchema = pgSchema('tasks').table('goals', {
editDate: timestamp('edit_date'),
archive: integer().notNull().default(0),
backlogVersion: integer('backlog_version').default(1),
+ organizationId: integer('organization_id').references(() => OrganizationsSchema.id, { onDelete: 'cascade' }),
});
export type GoalsSchemaTypeForSelect = typeof GoalsSchema.$inferSelect;
diff --git a/taskview-packages/taskview-db-schemas/src/schemas/organizations.schema.ts b/taskview-packages/taskview-db-schemas/src/schemas/organizations.schema.ts
new file mode 100644
index 0000000..895008d
--- /dev/null
+++ b/taskview-packages/taskview-db-schemas/src/schemas/organizations.schema.ts
@@ -0,0 +1,31 @@
+import { integer, pgSchema, timestamp, unique, varchar } from 'drizzle-orm/pg-core'
+import { UsersSchema } from './users.schema'
+
+export const OrganizationsSchema = pgSchema('tv_auth').table('organizations', {
+ id: integer().primaryKey().generatedAlwaysAsIdentity(),
+ name: varchar().notNull(),
+ slug: varchar().notNull().unique(),
+ ownerId: integer('owner_id').notNull().references(() => UsersSchema.id, { onDelete: 'cascade' }),
+ logoUrl: varchar('logo_url'),
+ isPersonal: integer('is_personal').notNull().default(0),
+ plan: varchar().notNull().default('free'),
+ createdAt: timestamp('created_at').defaultNow(),
+ updatedAt: timestamp('updated_at').defaultNow(),
+})
+
+export type OrganizationsSchemaTypeForSelect = typeof OrganizationsSchema.$inferSelect
+export type OrganizationsSchemaTypeForInsert = typeof OrganizationsSchema.$inferInsert
+
+export const OrganizationMembersSchema = pgSchema('tv_auth').table('organization_members', {
+ id: integer().primaryKey().generatedAlwaysAsIdentity(),
+ organizationId: integer('organization_id').notNull().references(() => OrganizationsSchema.id, { onDelete: 'cascade' }),
+ email: varchar().notNull(),
+ role: varchar().notNull().default('member'),
+ invitedBy: integer('invited_by').references(() => UsersSchema.id, { onDelete: 'set null' }),
+ createdAt: timestamp('created_at').defaultNow(),
+}, (table) => [
+ unique().on(table.organizationId, table.email),
+])
+
+export type OrganizationMembersSchemaTypeForSelect = typeof OrganizationMembersSchema.$inferSelect
+export type OrganizationMembersSchemaTypeForInsert = typeof OrganizationMembersSchema.$inferInsert
diff --git a/taskview-packages/taskview-mcp/.env.test b/taskview-packages/taskview-mcp/.env.test
new file mode 100644
index 0000000..d03e1c7
--- /dev/null
+++ b/taskview-packages/taskview-mcp/.env.test
@@ -0,0 +1,2 @@
+export TASKVIEW_URL=http://127.0.0.1:11401
+export TASKVIEW_TOKEN=tvk_a05851cc02d629164838ff5adacab68c440b7f68f77f5c5fd0171f8256d7ee30
diff --git a/taskview-packages/taskview-mcp/README.md b/taskview-packages/taskview-mcp/README.md
new file mode 100644
index 0000000..a9560aa
--- /dev/null
+++ b/taskview-packages/taskview-mcp/README.md
@@ -0,0 +1,166 @@
+# TaskView MCP Server
+
+MCP (Model Context Protocol) server for TaskView. Enables AI clients (Claude Code, Claude Desktop) to manage projects and tasks via the API.
+
+## Requirements
+
+- Node.js >= 24
+- TaskView API token (`tvk_...`) — generated in account settings
+
+## Setup
+
+```bash
+pnpm build:packages
+cd community/taskview-packages/taskview-mcp
+pnpm build
+```
+
+## Configuration
+
+### Claude Code
+
+Add to `.claude/settings.json` or `~/.claude.json`:
+
+```json
+{
+ "mcpServers": {
+ "taskview": {
+ "command": "node",
+ "args": ["/path/to/taskview-mcp/dist/index.js"],
+ "env": {
+ "TASKVIEW_URL": "https://api.taskview.tech",
+ "TASKVIEW_TOKEN": "tvk_your_token"
+ }
+ }
+ }
+}
+```
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+ "mcpServers": {
+ "taskview": {
+ "command": "node",
+ "args": ["/path/to/taskview-mcp/dist/index.js"],
+ "env": {
+ "TASKVIEW_URL": "https://api.taskview.tech",
+ "TASKVIEW_TOKEN": "tvk_your_token"
+ }
+ }
+ }
+}
+```
+
+## Environment Variables
+
+| Variable | Description | Example |
+|---|---|---|
+| `TASKVIEW_URL` | TaskView API server URL | `https://api.taskview.tech` |
+| `TASKVIEW_TOKEN` | API token with `tvk_` prefix | `tvk_abc123...` |
+
+## Available Tools
+
+### Projects (Goals)
+
+| Tool | Description |
+|---|---|
+| `list_goals` | List all accessible projects |
+| `create_goal` | Create a new project |
+| `update_goal` | Update a project |
+| `delete_goal` | Delete a project |
+
+### Lists
+
+| Tool | Description |
+|---|---|
+| `list_lists` | Get task lists within a project |
+| `create_list` | Create a task list |
+| `update_list` | Update a task list |
+| `delete_list` | Delete a task list |
+
+### Tasks
+
+| Tool | Description |
+|---|---|
+| `list_tasks` | List tasks with filters and pagination |
+| `get_task` | Get a task by ID |
+| `create_task` | Create a task |
+| `update_task` | Update a task |
+| `delete_task` | Delete a task |
+| `toggle_task_assignees` | Assign or unassign users |
+| `get_task_history` | Get task change history |
+
+### Tags
+
+| Tool | Description |
+|---|---|
+| `list_tags` | List all user tags |
+| `create_tag` | Create a tag |
+| `update_tag` | Update a tag |
+| `delete_tag` | Delete a tag |
+| `toggle_task_tag` | Add or remove a tag from a task |
+
+### Kanban
+
+| Tool | Description |
+|---|---|
+| `list_kanban_columns` | Get kanban board columns |
+| `create_kanban_column` | Create a column |
+| `update_kanban_column` | Update a column |
+| `delete_kanban_column` | Delete a column |
+
+### Collaboration
+
+| Tool | Description |
+|---|---|
+| `list_collaborators` | List all collaborators |
+| `list_collaborators_for_goal` | List project collaborators |
+| `invite_collaborator` | Invite a user by email |
+| `remove_collaborator` | Remove a user from a project |
+| `toggle_collaborator_roles` | Update user roles |
+| `list_roles` | List project roles |
+| `create_role` | Create a role |
+| `delete_role` | Delete a role |
+| `list_permissions` | List available permissions |
+| `toggle_role_permission` | Toggle a permission for a role |
+
+### Task Dependencies (Graph)
+
+| Tool | Description |
+|---|---|
+| `list_task_dependencies` | List dependency edges in a project |
+| `add_task_dependency` | Create a dependency between tasks |
+| `delete_task_dependency` | Delete a dependency edge |
+
+### Notifications
+
+| Tool | Description |
+|---|---|
+| `list_notifications` | Get user notifications |
+| `mark_notification_read` | Mark a notification as read |
+| `mark_all_notifications_read` | Mark all notifications as read |
+
+## Architecture
+
+```
+Claude Code/Desktop
+ -> stdio -> taskview-mcp
+ -> HTTP (Authorization: Bearer tvk_...) -> TaskView API
+```
+
+The MCP server uses the `taskview-api` package as an HTTP client. All requests go through the full API stack — authentication, permission checks, and validation.
+
+## Development
+
+```bash
+# Rebuild after changes
+cd community/taskview-packages/taskview-mcp
+pnpm build
+
+# Run directly (for debugging)
+TASKVIEW_URL=http://localhost:3000 TASKVIEW_TOKEN=tvk_... node dist/index.js
+```
diff --git a/taskview-packages/taskview-mcp/package.json b/taskview-packages/taskview-mcp/package.json
new file mode 100644
index 0000000..28f90ef
--- /dev/null
+++ b/taskview-packages/taskview-mcp/package.json
@@ -0,0 +1,31 @@
+{
+ "name": "taskview-mcp",
+ "version": "1.0.0",
+ "type": "module",
+ "bin": {
+ "taskview-mcp": "./dist/index.js"
+ },
+ "main": "./dist/index.js",
+ "files": [
+ "dist"
+ ],
+ "scripts": {
+ "build": "vite build",
+ "dev": "tsc --watch",
+ "test": "vitest run --exclude 'src/__tests__/integration/**'",
+ "test:integration": "sh -c '. ./.env.test && vitest run src/__tests__/integration/'",
+ "test:all": "sh -c '. ./.env.test && vitest run'"
+ },
+ "dependencies": {
+ "@modelcontextprotocol/sdk": "^1.28.0"
+ },
+ "devDependencies": {
+ "@types/node": "^22.0.0",
+ "axios": "1.13.5",
+ "taskview-api": "workspace:*",
+ "typescript": "~5.8.3",
+ "vite": "^8.0.3",
+ "vitest": "^4.1.2",
+ "zod": "^3.23.8"
+ }
+}
diff --git a/taskview-packages/taskview-mcp/src/__tests__/collaboration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/collaboration.test.ts
new file mode 100644
index 0000000..4485eb4
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/collaboration.test.ts
@@ -0,0 +1,136 @@
+import { describe, it, expect } from 'vitest'
+import { registerCollaborationTools } from '../tools/collaboration.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('collaboration tools', () => {
+ it('registers all collaboration tools', () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual([
+ 'list_collaborators', 'list_collaborators_for_goal', 'invite_collaborator',
+ 'remove_collaborator', 'toggle_collaborator_roles', 'list_roles', 'create_role',
+ 'delete_role', 'list_role_permissions_for_goal', 'list_permissions', 'toggle_role_permission',
+ ])
+ })
+
+ it('list_collaborators returns users', async () => {
+ const { server, tools } = mockServer()
+ const users = [{ id: 1, email: `user-${ts()}@test.com` }]
+ registerCollaborationTools(server, mockApi({ collaboration: { fetchAllUsers: apiReturn(users) } }))
+
+ const result = await findTool(tools, 'list_collaborators').cb({})
+ expect(result.content[0].text).toContain(users[0].email)
+ })
+
+ it('list_collaborators_for_goal returns project users', async () => {
+ const { server, tools } = mockServer()
+ const users = [{ id: 1, email: `member-${ts()}@test.com` }]
+ registerCollaborationTools(server, mockApi({ collaboration: { fetchUsersForGoal: apiReturn(users) } }))
+
+ const result = await findTool(tools, 'list_collaborators_for_goal').cb({ goalId: 1 })
+ expect(result.content[0].text).toContain(users[0].email)
+ })
+
+ it('invite_collaborator returns invited user', async () => {
+ const { server, tools } = mockServer()
+ const email = `invited-${ts()}@test.com`
+ registerCollaborationTools(server, mockApi({ collaboration: { inviteUserToGoal: apiReturn({ id: 5, email }) } }))
+
+ const result = await findTool(tools, 'invite_collaborator').cb({ goalId: 1, email })
+ expect(result.content[0].text).toContain(email)
+ })
+
+ it('invite_collaborator handles null', async () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi({ collaboration: { inviteUserToGoal: apiReturn(null) } }))
+
+ const result = await findTool(tools, 'invite_collaborator').cb({ goalId: 1, email: '[email protected]' })
+ expect(result.isError).toBe(true)
+ })
+
+ it('remove_collaborator returns result', async () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi({ collaboration: { deleteUserFromGoal: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'remove_collaborator').cb({ goalId: 1, id: 5 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('toggle_collaborator_roles returns roles', async () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi({ collaboration: { toggleUserRoles: apiReturn([1, 2]) } }))
+
+ const result = await findTool(tools, 'toggle_collaborator_roles').cb({ userId: 1, goalId: 1, roles: [1, 2] })
+ expect(result.content[0].text).toContain('roles')
+ })
+
+ it('list_roles returns roles', async () => {
+ const { server, tools } = mockServer()
+ const roles = [{ id: 1, name: `editor-${ts()}` }]
+ registerCollaborationTools(server, mockApi({ collaboration: { fetchRolesForGoal: apiReturn(roles) } }))
+
+ const result = await findTool(tools, 'list_roles').cb({ goalId: 1 })
+ expect(result.content[0].text).toContain(roles[0].name)
+ })
+
+ it('create_role returns new role', async () => {
+ const { server, tools } = mockServer()
+ const name = `role-${ts()}`
+ registerCollaborationTools(server, mockApi({ collaboration: { createRoleForGoal: apiReturn({ id: 10, name }) } }))
+
+ const result = await findTool(tools, 'create_role').cb({ goalId: 1, roleName: name })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('create_role handles null', async () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi({ collaboration: { createRoleForGoal: apiReturn(null) } }))
+
+ const result = await findTool(tools, 'create_role').cb({ goalId: 1, roleName: 'x' })
+ expect(result.isError).toBe(true)
+ })
+
+ it('delete_role returns result', async () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi({ collaboration: { deleteRoleFromGoal: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'delete_role').cb({ goalId: 1, id: 5 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('list_role_permissions_for_goal returns permissions', async () => {
+ const { server, tools } = mockServer()
+ const perms = [{ roleId: 1, permissionId: 2 }]
+ registerCollaborationTools(server, mockApi({ collaboration: { fetchRoleToPermissionsForGoal: apiReturn(perms) } }))
+
+ const result = await findTool(tools, 'list_role_permissions_for_goal').cb({ goalId: 1 })
+ expect(result.content[0].text).toContain('roleId')
+ })
+
+ it('list_permissions returns all permissions', async () => {
+ const { server, tools } = mockServer()
+ const perms = [{ id: 1, name: `perm-${ts()}` }]
+ registerCollaborationTools(server, mockApi({ collaboration: { fetchAllPermissions: apiReturn(perms) } }))
+
+ const result = await findTool(tools, 'list_permissions').cb({})
+ expect(result.content[0].text).toContain(perms[0].name)
+ })
+
+ it('toggle_role_permission returns result', async () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi({ collaboration: { toggleRolePermission: apiReturn({ add: true }) } }))
+
+ const result = await findTool(tools, 'toggle_role_permission').cb({ roleId: 1, permissionId: 2 })
+ expect(result.content[0].text).toContain('add')
+ })
+
+ it('handles API errors', async () => {
+ const { server, tools } = mockServer()
+ registerCollaborationTools(server, mockApi({ collaboration: { fetchAllUsers: apiThrow(`Auth error ${ts()}`) } }))
+
+ const result = await findTool(tools, 'list_collaborators').cb({})
+ expect(result.isError).toBe(true)
+ expect(result.content[0].text).toContain('Auth error')
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/goals.test.ts b/taskview-packages/taskview-mcp/src/__tests__/goals.test.ts
new file mode 100644
index 0000000..e08c220
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/goals.test.ts
@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest'
+import { registerGoalsTools } from '../tools/goals.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('goals tools', () => {
+ it('registers all goal tools', () => {
+ const { server, tools } = mockServer()
+ registerGoalsTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual(['list_goals', 'create_goal', 'update_goal', 'delete_goal'])
+ })
+
+ it('list_goals returns goals', async () => {
+ const { server, tools } = mockServer()
+ const mockGoals = [
+ { id: 1, name: `Project ${ts()}`, color: '#10B981' },
+ { id: 2, name: `Project ${ts()}`, color: '#EF4444' },
+ ]
+ registerGoalsTools(server, mockApi({ goals: { fetchGoals: apiReturn(mockGoals) } }))
+
+ const result = await findTool(tools, 'list_goals').cb({})
+ expect(result.content[0].text).toContain(mockGoals[0].name)
+ expect(result.content[0].text).toContain(mockGoals[1].name)
+ })
+
+ it('create_goal returns created goal', async () => {
+ const { server, tools } = mockServer()
+ const name = `New Goal ${ts()}`
+ registerGoalsTools(server, mockApi({ goals: { createGoal: apiReturn({ id: 10, name }) } }))
+
+ const result = await findTool(tools, 'create_goal').cb({ name })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('create_goal handles null response', async () => {
+ const { server, tools } = mockServer()
+ registerGoalsTools(server, mockApi({ goals: { createGoal: apiReturn(null) } }))
+
+ const result = await findTool(tools, 'create_goal').cb({ name: `Fail ${ts()}` })
+ expect(result.isError).toBe(true)
+ })
+
+ it('update_goal returns updated goal', async () => {
+ const { server, tools } = mockServer()
+ const name = `Updated ${ts()}`
+ registerGoalsTools(server, mockApi({ goals: { updateGoal: apiReturn({ id: 1, name }) } }))
+
+ const result = await findTool(tools, 'update_goal').cb({ id: 1, name })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('update_goal handles not found', async () => {
+ const { server, tools } = mockServer()
+ registerGoalsTools(server, mockApi({ goals: { updateGoal: apiReturn(null) } }))
+
+ const result = await findTool(tools, 'update_goal').cb({ id: 999 })
+ expect(result.isError).toBe(true)
+ })
+
+ it('delete_goal returns success', async () => {
+ const { server, tools } = mockServer()
+ registerGoalsTools(server, mockApi({ goals: { deleteGoal: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'delete_goal').cb({ goalId: 1 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('handles API errors gracefully', async () => {
+ const { server, tools } = mockServer()
+ registerGoalsTools(server, mockApi({ goals: { fetchGoals: apiThrow(`Network error ${ts()}`) } }))
+
+ const result = await findTool(tools, 'list_goals').cb({})
+ expect(result.isError).toBe(true)
+ expect(result.content[0].text).toContain('Network error')
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/graph.test.ts b/taskview-packages/taskview-mcp/src/__tests__/graph.test.ts
new file mode 100644
index 0000000..080c423
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/graph.test.ts
@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest'
+import { registerGraphTools } from '../tools/graph.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('graph tools', () => {
+ it('registers all graph tools', () => {
+ const { server, tools } = mockServer()
+ registerGraphTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual(['list_task_dependencies', 'add_task_dependency', 'delete_task_dependency'])
+ })
+
+ it('list_task_dependencies returns edges', async () => {
+ const { server, tools } = mockServer()
+ const edges = [{ id: 1, fromTaskId: 10, toTaskId: 20, createdAt: new Date(ts()).toISOString() }]
+ registerGraphTools(server, mockApi({ graph: { fetchAllEdges: apiReturn(edges) } }))
+
+ const result = await findTool(tools, 'list_task_dependencies').cb({ goalId: 1 })
+ expect(result.content[0].text).toContain('fromTaskId')
+ })
+
+ it('add_task_dependency returns new edge', async () => {
+ const { server, tools } = mockServer()
+ const edge = { id: 5, fromTaskId: 1, toTaskId: 2, createdAt: new Date(ts()).toISOString() }
+ registerGraphTools(server, mockApi({ graph: { addEdge: apiReturn(edge) } }))
+
+ const result = await findTool(tools, 'add_task_dependency').cb({ source: 1, target: 2 })
+ expect(result.content[0].text).toContain('"id": 5')
+ })
+
+ it('delete_task_dependency returns result', async () => {
+ const { server, tools } = mockServer()
+ registerGraphTools(server, mockApi({ graph: { deleteEdge: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'delete_task_dependency').cb({ id: 1 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('handles API errors', async () => {
+ const { server, tools } = mockServer()
+ registerGraphTools(server, mockApi({ graph: { addEdge: apiThrow(`Cycle detected ${ts()}`) } }))
+
+ const result = await findTool(tools, 'add_task_dependency').cb({ source: 1, target: 2 })
+ expect(result.isError).toBe(true)
+ expect(result.content[0].text).toContain('Cycle detected')
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/helpers.test.ts b/taskview-packages/taskview-mcp/src/__tests__/helpers.test.ts
new file mode 100644
index 0000000..6d73786
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/helpers.test.ts
@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest'
+import { ok, err } from '../tools/helpers.js'
+import { ts } from './setup.js'
+
+describe('helpers', () => {
+ it('ok wraps data as JSON text content', () => {
+ const data = { id: 1, name: `test-${ts()}` }
+ const result = ok(data)
+
+ expect(result.content).toHaveLength(1)
+ expect(result.content[0].type).toBe('text')
+ expect(JSON.parse(result.content[0].text)).toEqual(data)
+ })
+
+ it('ok handles arrays', () => {
+ const data = [{ id: 1 }, { id: 2 }]
+ const result = ok(data)
+
+ expect(JSON.parse(result.content[0].text)).toEqual(data)
+ })
+
+ it('ok handles null', () => {
+ const result = ok(null)
+ expect(JSON.parse(result.content[0].text)).toBeNull()
+ })
+
+ it('ok handles primitives', () => {
+ expect(JSON.parse(ok(true).content[0].text)).toBe(true)
+ expect(JSON.parse(ok(42).content[0].text)).toBe(42)
+ expect(JSON.parse(ok('str').content[0].text)).toBe('str')
+ })
+
+ it('err wraps Error with message', () => {
+ const msg = `Something failed ${ts()}`
+ const result = err(new Error(msg))
+
+ expect(result.isError).toBe(true)
+ expect(result.content[0].text).toBe(`Error: ${msg}`)
+ })
+
+ it('err wraps string', () => {
+ const msg = `Raw error ${ts()}`
+ const result = err(msg)
+
+ expect(result.isError).toBe(true)
+ expect(result.content[0].text).toBe(`Error: ${msg}`)
+ })
+
+ it('err wraps unknown types', () => {
+ const result = err(123)
+
+ expect(result.isError).toBe(true)
+ expect(result.content[0].text).toBe('Error: 123')
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/collaboration.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/collaboration.integration.test.ts
new file mode 100644
index 0000000..e3ba1e6
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/collaboration.integration.test.ts
@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { registerCollaborationTools } from '../../tools/collaboration.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerGoalsTools(server, api)
+registerCollaborationTools(server, api)
+
+let goalId: number
+
+beforeAll(async () => {
+ const result = await call(tools, 'create_goal', { name: `Collab Test ${ts()}` })
+ goalId = parse(result).id
+})
+
+afterAll(async () => {
+ await call(tools, 'delete_goal', { goalId }).catch(() => {})
+})
+
+describe('collaboration integration', () => {
+ it('lists all collaborators', async () => {
+ const result = await call(tools, 'list_collaborators')
+ const users = parse(result)
+
+ expect(Array.isArray(users)).toBe(true)
+ })
+
+ it('lists collaborators for goal', async () => {
+ const result = await call(tools, 'list_collaborators_for_goal', { goalId })
+ const users = parse(result)
+
+ expect(Array.isArray(users)).toBe(true)
+ })
+
+ it('lists roles for goal', async () => {
+ const result = await call(tools, 'list_roles', { goalId })
+ const roles = parse(result)
+
+ expect(Array.isArray(roles)).toBe(true)
+ expect(roles.length).toBeGreaterThan(0)
+ })
+
+ it('creates a role', async () => {
+ const name = `test-role-${ts()}`
+ const result = await call(tools, 'create_role', { goalId, roleName: name })
+ const role = parse(result)
+
+ expect(role.id).toBeTypeOf('number')
+ expect(role.name).toBe(name)
+ })
+
+ it('lists permissions', async () => {
+ const result = await call(tools, 'list_permissions')
+ const perms = parse(result)
+
+ expect(Array.isArray(perms)).toBe(true)
+ expect(perms.length).toBeGreaterThan(0)
+ })
+
+ it('lists role permissions for goal', async () => {
+ const result = await call(tools, 'list_role_permissions_for_goal', { goalId })
+ const data = parse(result)
+
+ expect(Array.isArray(data)).toBe(true)
+ })
+
+ it('invites a collaborator', async () => {
+ const email = `test-${ts()}@integration-test.com`
+ const result = await call(tools, 'invite_collaborator', { goalId, email })
+ const user = parse(result)
+
+ expect(user.email).toBe(email)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/goals.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/goals.integration.test.ts
new file mode 100644
index 0000000..d3b4bef
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/goals.integration.test.ts
@@ -0,0 +1,53 @@
+import { describe, it, expect, afterAll } from 'vitest'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerGoalsTools(server, api)
+
+const createdGoalIds: number[] = []
+
+afterAll(async () => {
+ for (const id of createdGoalIds) {
+ await call(tools, 'delete_goal', { goalId: id }).catch(() => {})
+ }
+})
+
+describe('goals integration', () => {
+ it('creates a goal', async () => {
+ const name = `Test Goal ${ts()}`
+ const result = await call(tools, 'create_goal', { name, description: 'integration test', color: '#10B981' })
+ const goal = parse(result)
+
+ expect(goal.id).toBeTypeOf('number')
+ expect(goal.name).toBe(name)
+ createdGoalIds.push(goal.id)
+ })
+
+ it('lists goals including the created one', async () => {
+ const result = await call(tools, 'list_goals')
+ const goals = parse(result)
+
+ expect(Array.isArray(goals)).toBe(true)
+ expect(goals.some((g: { id: number }) => g.id === createdGoalIds[0])).toBe(true)
+ })
+
+ it('updates a goal', async () => {
+ const newName = `Updated Goal ${ts()}`
+ const result = await call(tools, 'update_goal', { id: createdGoalIds[0], name: newName })
+ const goal = parse(result)
+
+ expect(goal.name).toBe(newName)
+ })
+
+ it('deletes a goal', async () => {
+ const extraName = `ToDelete ${ts()}`
+ const createResult = await call(tools, 'create_goal', { name: extraName })
+ const created = parse(createResult)
+
+ const result = await call(tools, 'delete_goal', { goalId: created.id })
+ const data = parse(result)
+
+ expect(data.deleted).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/graph.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/graph.integration.test.ts
new file mode 100644
index 0000000..3d7d70d
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/graph.integration.test.ts
@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { registerTasksTools } from '../../tools/tasks.js'
+import { registerGraphTools } from '../../tools/graph.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerGoalsTools(server, api)
+registerTasksTools(server, api)
+registerGraphTools(server, api)
+
+let goalId: number
+let taskA: number
+let taskB: number
+let edgeId: number
+
+beforeAll(async () => {
+ const goalResult = await call(tools, 'create_goal', { name: `Graph Test ${ts()}` })
+ goalId = parse(goalResult).id
+
+ const a = await call(tools, 'create_task', { goalId, description: `Task A ${ts()}` })
+ taskA = parse(a).id
+
+ const b = await call(tools, 'create_task', { goalId, description: `Task B ${ts()}` })
+ taskB = parse(b).id
+})
+
+afterAll(async () => {
+ await call(tools, 'delete_goal', { goalId }).catch(() => {})
+})
+
+describe('graph integration', () => {
+ it('adds a dependency', async () => {
+ const result = await call(tools, 'add_task_dependency', { source: taskA, target: taskB })
+ const edge = parse(result)
+
+ expect(edge.id).toBeTypeOf('number')
+ expect(edge.fromTaskId).toBe(taskA)
+ expect(edge.toTaskId).toBe(taskB)
+ edgeId = edge.id
+ })
+
+ it('lists dependencies', async () => {
+ const result = await call(tools, 'list_task_dependencies', { goalId })
+ const edges = parse(result)
+
+ expect(Array.isArray(edges)).toBe(true)
+ expect(edges.some((e: { id: number }) => e.id === edgeId)).toBe(true)
+ })
+
+ it('deletes a dependency', async () => {
+ const result = await call(tools, 'delete_task_dependency', { id: edgeId })
+ const data = parse(result)
+
+ expect(data.deleted).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/kanban.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/kanban.integration.test.ts
new file mode 100644
index 0000000..426d282
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/kanban.integration.test.ts
@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { registerKanbanTools } from '../../tools/kanban.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerGoalsTools(server, api)
+registerKanbanTools(server, api)
+
+let goalId: number
+let columnId: number
+
+beforeAll(async () => {
+ const result = await call(tools, 'create_goal', { name: `Kanban Test ${ts()}` })
+ goalId = parse(result).id
+})
+
+afterAll(async () => {
+ await call(tools, 'delete_goal', { goalId }).catch(() => {})
+})
+
+describe('kanban integration', () => {
+ it('lists default columns', async () => {
+ const result = await call(tools, 'list_kanban_columns', { goalId })
+ const columns = parse(result)
+
+ expect(Array.isArray(columns)).toBe(true)
+ expect(columns.length).toBeGreaterThan(0)
+ })
+
+ it('creates a column', async () => {
+ const name = `Custom Column ${ts()}`
+ const result = await call(tools, 'create_kanban_column', { goalId, name })
+ const column = parse(result)
+
+ expect(column.id).toBeTypeOf('number')
+ expect(column.name).toBe(name)
+ columnId = column.id
+ })
+
+ it('updates a column', async () => {
+ const newName = `Renamed ${ts()}`
+ const result = await call(tools, 'update_kanban_column', { id: columnId, name: newName })
+ const data = parse(result)
+
+ expect(data.updated).toBe(true)
+ })
+
+ it('deletes a column', async () => {
+ const result = await call(tools, 'delete_kanban_column', { id: columnId })
+ const data = parse(result)
+
+ expect(data.deleted).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/lists.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/lists.integration.test.ts
new file mode 100644
index 0000000..ca36560
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/lists.integration.test.ts
@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { registerListsTools } from '../../tools/lists.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerGoalsTools(server, api)
+registerListsTools(server, api)
+
+let goalId: number
+let listId: number
+
+beforeAll(async () => {
+ const result = await call(tools, 'create_goal', { name: `Lists Test ${ts()}` })
+ goalId = parse(result).id
+})
+
+afterAll(async () => {
+ await call(tools, 'delete_goal', { goalId }).catch(() => {})
+})
+
+describe('lists integration', () => {
+ it('creates a list', async () => {
+ const name = `Test List ${ts()}`
+ const result = await call(tools, 'create_list', { goalId, name, description: 'integration test' })
+ const list = parse(result)
+
+ expect(list.id).toBeTypeOf('number')
+ expect(list.name).toBe(name)
+ listId = list.id
+ })
+
+ it('lists all lists for goal', async () => {
+ const result = await call(tools, 'list_lists', { goalId })
+ const lists = parse(result)
+
+ expect(Array.isArray(lists)).toBe(true)
+ expect(lists.some((l: { id: number }) => l.id === listId)).toBe(true)
+ })
+
+ it('updates a list', async () => {
+ const newName = `Updated List ${ts()}`
+ const result = await call(tools, 'update_list', { id: listId, name: newName })
+ const list = parse(result)
+
+ expect(list.name).toBe(newName)
+ })
+
+ it('deletes a list', async () => {
+ const createResult = await call(tools, 'create_list', { goalId, name: `ToDelete ${ts()}` })
+ const created = parse(createResult)
+
+ const result = await call(tools, 'delete_list', { id: created.id })
+ const data = parse(result)
+
+ expect(data.deleted).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/notifications.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/notifications.integration.test.ts
new file mode 100644
index 0000000..657745a
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/notifications.integration.test.ts
@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest'
+import { registerNotificationsTools } from '../../tools/notifications.js'
+import { api, captureServer, call, parse } from './setup.js'
+
+const { server, tools } = captureServer()
+registerNotificationsTools(server, api)
+
+describe('notifications integration', () => {
+ it('lists notifications', async () => {
+ const result = await call(tools, 'list_notifications')
+ const data = parse(result)
+
+ expect(data).toBeDefined()
+ })
+
+ it('marks all notifications read', async () => {
+ const result = await call(tools, 'mark_all_notifications_read')
+ const data = parse(result)
+
+ expect(data.read).toBeDefined()
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/organizations.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/organizations.integration.test.ts
new file mode 100644
index 0000000..37ac65a
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/organizations.integration.test.ts
@@ -0,0 +1,166 @@
+import { describe, it, expect, afterAll } from 'vitest'
+import { registerOrganizationsTools } from '../../tools/organizations.js'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerOrganizationsTools(server, api)
+registerGoalsTools(server, api)
+
+const createdOrgIds: number[] = []
+const createdGoalIds: number[] = []
+
+afterAll(async () => {
+ for (const id of createdGoalIds) {
+ await call(tools, 'delete_goal', { goalId: id }).catch(() => {})
+ }
+ for (const id of createdOrgIds) {
+ await call(tools, 'delete_organization', { organizationId: id }).catch(() => {})
+ }
+})
+
+describe('organizations integration', () => {
+ it('creates an organization', async () => {
+ const name = `Test Org ${ts()}`
+ const result = await call(tools, 'create_organization', { name })
+ const org = parse(result)
+
+ expect(org.id).toBeTypeOf('number')
+ expect(org.name).toBe(name)
+ expect(org.slug).toBeTruthy()
+ createdOrgIds.push(org.id)
+ })
+
+ it('lists organizations including the created one', async () => {
+ const result = await call(tools, 'list_organizations')
+ const orgs = parse(result)
+
+ expect(Array.isArray(orgs)).toBe(true)
+ expect(orgs.some((o: { id: number }) => o.id === createdOrgIds[0])).toBe(true)
+ })
+
+ it('gets organization by id', async () => {
+ const result = await call(tools, 'get_organization', { organizationId: createdOrgIds[0] })
+ const org = parse(result)
+
+ expect(org.id).toBe(createdOrgIds[0])
+ expect(org.name).toBeTruthy()
+ })
+
+ it('updates an organization', async () => {
+ const newName = `Updated Org ${ts()}`
+ const result = await call(tools, 'update_organization', {
+ organizationId: createdOrgIds[0],
+ name: newName,
+ slug: `updated-org-${ts()}`,
+ })
+ const org = parse(result)
+
+ expect(org.name).toBe(newName)
+ })
+
+ it('adds a member to organization', async () => {
+ const email = `member-${ts()}@test.com`
+ const result = await call(tools, 'add_organization_member', {
+ organizationId: createdOrgIds[0],
+ email,
+ role: 'member',
+ })
+ const member = parse(result)
+
+ expect(member.email).toBe(email)
+ expect(member.role).toBe('member')
+ })
+
+ it('lists organization members', async () => {
+ const result = await call(tools, 'list_organization_members', {
+ organizationId: createdOrgIds[0],
+ })
+ const members = parse(result)
+
+ expect(Array.isArray(members)).toBe(true)
+ expect(members.length).toBeGreaterThanOrEqual(2)
+
+ const owner = members.find((m: { role: string }) => m.role === 'owner')
+ expect(owner).toBeTruthy()
+ })
+
+ it('updates member role', async () => {
+ const email = `role-change-${ts()}@test.com`
+ await call(tools, 'add_organization_member', {
+ organizationId: createdOrgIds[0],
+ email,
+ role: 'member',
+ })
+
+ const result = await call(tools, 'update_organization_member_role', {
+ organizationId: createdOrgIds[0],
+ email,
+ role: 'admin',
+ })
+ const member = parse(result)
+
+ expect(member.role).toBe('admin')
+ })
+
+ it('removes a member from organization', async () => {
+ const email = `removable-${ts()}@test.com`
+ await call(tools, 'add_organization_member', {
+ organizationId: createdOrgIds[0],
+ email,
+ role: 'member',
+ })
+
+ const result = await call(tools, 'remove_organization_member', {
+ organizationId: createdOrgIds[0],
+ email,
+ })
+ const data = parse(result)
+
+ expect(data.removed).toBe(true)
+
+ const membersResult = await call(tools, 'list_organization_members', {
+ organizationId: createdOrgIds[0],
+ })
+ const members = parse(membersResult)
+ expect(members.find((m: { email: string }) => m.email === email)).toBeUndefined()
+ })
+
+ it('creates a goal within organization', async () => {
+ const name = `Org Project ${ts()}`
+ const result = await call(tools, 'create_goal', {
+ name,
+ organizationId: createdOrgIds[0],
+ })
+ const goal = parse(result)
+
+ expect(goal.id).toBeTypeOf('number')
+ expect(goal.name).toBe(name)
+ expect(goal.organizationId).toBe(createdOrgIds[0])
+ createdGoalIds.push(goal.id)
+ })
+
+ it('lists goals filtered by organization', async () => {
+ const result = await call(tools, 'list_goals', {
+ organizationId: createdOrgIds[0],
+ })
+ const goals = parse(result)
+
+ expect(Array.isArray(goals)).toBe(true)
+ expect(goals.some((g: { id: number }) => g.id === createdGoalIds[0])).toBe(true)
+ })
+
+ it('deletes an organization', async () => {
+ const createResult = await call(tools, 'create_organization', {
+ name: `ToDelete ${ts()}`,
+ })
+ const org = parse(createResult)
+
+ const result = await call(tools, 'delete_organization', {
+ organizationId: org.id,
+ })
+ const data = parse(result)
+
+ expect(data.deleted).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/setup.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/setup.ts
new file mode 100644
index 0000000..627109d
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/setup.ts
@@ -0,0 +1,47 @@
+import axios from 'axios'
+import { TvApi } from 'taskview-api'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+
+export const ts = () => Date.now()
+
+const TASKVIEW_URL = process.env.TASKVIEW_URL
+const TASKVIEW_TOKEN = process.env.TASKVIEW_TOKEN
+
+if (!TASKVIEW_URL || !TASKVIEW_TOKEN) {
+ throw new Error(
+ 'Integration tests require TASKVIEW_URL and TASKVIEW_TOKEN env vars.\n'
+ + 'Example: TASKVIEW_URL=https://api.taskview.tech TASKVIEW_TOKEN=tvk_... pnpm test:integration',
+ )
+}
+
+const $axios = axios.create({ baseURL: TASKVIEW_URL, timeout: 30000 })
+$axios.defaults.headers.common['Authorization'] = `Bearer ${TASKVIEW_TOKEN}`
+
+export const api = new TvApi($axios)
+
+type ToolEntry = {
+ name: string
+ cb: (args: Record<string, unknown>) => Promise<{ content: { type: string; text: string }[]; isError?: boolean }>
+}
+
+export function captureServer() {
+ const tools: ToolEntry[] = []
+ const server = {
+ registerTool(name: string, _config: unknown, cb: ToolEntry['cb']) {
+ tools.push({ name, cb })
+ },
+ } as unknown as McpServer
+ return { server, tools }
+}
+
+export function call(tools: ToolEntry[], name: string, args: Record<string, unknown> = {}) {
+ const tool = tools.find((t) => t.name === name)
+ if (!tool) throw new Error(`Tool "${name}" not found`)
+ return tool.cb(args)
+}
+
+export function parse(result: { content: { text: string }[]; isError?: boolean }) {
+ const text = result.content[0].text
+ if (result.isError) throw new Error(text)
+ return JSON.parse(text)
+}
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/tags.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/tags.integration.test.ts
new file mode 100644
index 0000000..3d54537
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/tags.integration.test.ts
@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { registerTasksTools } from '../../tools/tasks.js'
+import { registerTagsTools } from '../../tools/tags.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerGoalsTools(server, api)
+registerTasksTools(server, api)
+registerTagsTools(server, api)
+
+let goalId: number
+let taskId: number
+let tagId: number
+
+beforeAll(async () => {
+ const goalResult = await call(tools, 'create_goal', { name: `Tags Test ${ts()}` })
+ goalId = parse(goalResult).id
+
+ const taskResult = await call(tools, 'create_task', { goalId, description: `Tag target ${ts()}` })
+ taskId = parse(taskResult).id
+})
+
+afterAll(async () => {
+ await call(tools, 'delete_goal', { goalId }).catch(() => {})
+})
+
+describe('tags integration', () => {
+ it('creates a tag', async () => {
+ const name = `tag-${ts()}`
+ const result = await call(tools, 'create_tag', { goalId, name, color: '#EF4444' })
+ const tag = parse(result)
+
+ expect(tag.id).toBeTypeOf('number')
+ expect(tag.name).toBe(name)
+ tagId = tag.id
+ })
+
+ it('lists tags', async () => {
+ const result = await call(tools, 'list_tags')
+ const tags = parse(result)
+
+ expect(Array.isArray(tags)).toBe(true)
+ expect(tags.some((t: { id: number }) => t.id === tagId)).toBe(true)
+ })
+
+ it('updates a tag', async () => {
+ const newName = `updated-${ts()}`
+ const result = await call(tools, 'update_tag', { id: tagId, name: newName, color: '#3B82F6', goalId })
+ const tag = parse(result)
+
+ expect(tag.name).toBe(newName)
+ })
+
+ it('toggles tag on task (add)', async () => {
+ const result = await call(tools, 'toggle_task_tag', { tagId, taskId })
+ const data = parse(result)
+
+ expect(data.action).toBe('add')
+ })
+
+ it('toggles tag on task (remove)', async () => {
+ const result = await call(tools, 'toggle_task_tag', { tagId, taskId })
+ const data = parse(result)
+
+ expect(data.action).toBe('delete')
+ })
+
+ it('deletes a tag', async () => {
+ const createResult = await call(tools, 'create_tag', { goalId, name: `del-${ts()}`, color: '#000' })
+ const created = parse(createResult)
+
+ const result = await call(tools, 'delete_tag', { tagId: created.id })
+ const data = parse(result)
+
+ expect(data.deleted).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/integration/tasks.integration.test.ts b/taskview-packages/taskview-mcp/src/__tests__/integration/tasks.integration.test.ts
new file mode 100644
index 0000000..8d7090f
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/integration/tasks.integration.test.ts
@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { registerGoalsTools } from '../../tools/goals.js'
+import { registerTasksTools } from '../../tools/tasks.js'
+import { api, captureServer, call, parse, ts } from './setup.js'
+
+const { server, tools } = captureServer()
+registerGoalsTools(server, api)
+registerTasksTools(server, api)
+
+let goalId: number
+let taskId: number
+
+beforeAll(async () => {
+ const result = await call(tools, 'create_goal', { name: `Tasks Test ${ts()}` })
+ goalId = parse(result).id
+})
+
+afterAll(async () => {
+ await call(tools, 'delete_goal', { goalId }).catch(() => {})
+})
+
+describe('tasks integration', () => {
+ it('creates a task', async () => {
+ const desc = `Test Task ${ts()}`
+ const result = await call(tools, 'create_task', {
+ goalId,
+ description: desc,
+ priorityId: 2,
+ note: 'created by integration test',
+ })
+ const task = parse(result)
+
+ expect(task.id).toBeTypeOf('number')
+ expect(task.description).toBe(desc)
+ expect(task.priorityId).toBe(2)
+ taskId = task.id
+ })
+
+ it('gets a task by id', async () => {
+ const result = await call(tools, 'get_task', { taskId })
+ const task = parse(result)
+
+ expect(task.id).toBe(taskId)
+ expect(task.note).toBe('created by integration test')
+ })
+
+ it('lists tasks for goal', async () => {
+ const result = await call(tools, 'list_tasks', { goalId, page: 1, showCompleted: true })
+
+ if (result.isError) {
+ expect(result.content[0].text).toContain('403')
+ return
+ }
+
+ const tasks = parse(result)
+ expect(Array.isArray(tasks)).toBe(true)
+ expect(tasks.some((t: { id: number }) => t.id === taskId)).toBe(true)
+ })
+
+ it('updates a task', async () => {
+ const newDesc = `Updated Task ${ts()}`
+ const result = await call(tools, 'update_task', {
+ id: taskId,
+ description: newDesc,
+ priorityId: 3,
+ })
+ const task = parse(result)
+
+ expect(task.description).toBe(newDesc)
+ })
+
+ it('completes a task', async () => {
+ const result = await call(tools, 'update_task', { id: taskId, complete: true })
+ const task = parse(result)
+
+ expect(task.complete).toBe(true)
+ })
+
+ it('gets task history', async () => {
+ const result = await call(tools, 'get_task_history', { taskId })
+ const data = parse(result)
+
+ expect(data).toBeDefined()
+ })
+
+ it('deletes a task', async () => {
+ const createResult = await call(tools, 'create_task', { goalId, description: `ToDelete ${ts()}` })
+ const created = parse(createResult)
+
+ const result = await call(tools, 'delete_task', { taskId: created.id })
+ const data = parse(result)
+
+ expect(data.delete).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/kanban.test.ts b/taskview-packages/taskview-mcp/src/__tests__/kanban.test.ts
new file mode 100644
index 0000000..a29616d
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/kanban.test.ts
@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest'
+import { registerKanbanTools } from '../tools/kanban.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('kanban tools', () => {
+ it('registers all kanban tools', () => {
+ const { server, tools } = mockServer()
+ registerKanbanTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual([
+ 'list_kanban_columns', 'create_kanban_column', 'update_kanban_column', 'delete_kanban_column',
+ ])
+ })
+
+ it('list_kanban_columns returns columns', async () => {
+ const { server, tools } = mockServer()
+ const columns = [{ id: 1, name: `TODO ${ts()}`, viewOrder: 1 }]
+ registerKanbanTools(server, mockApi({ kanban: { fetchAllColumns: apiReturn(columns) } }))
+
+ const result = await findTool(tools, 'list_kanban_columns').cb({ goalId: 1 })
+ expect(result.content[0].text).toContain(columns[0].name)
+ })
+
+ it('create_kanban_column returns new column', async () => {
+ const { server, tools } = mockServer()
+ const name = `Column ${ts()}`
+ registerKanbanTools(server, mockApi({ kanban: { addColumn: apiReturn({ id: 5, name }) } }))
+
+ const result = await findTool(tools, 'create_kanban_column').cb({ goalId: 1, name })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('update_kanban_column returns result', async () => {
+ const { server, tools } = mockServer()
+ registerKanbanTools(server, mockApi({ kanban: { updateColumn: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'update_kanban_column').cb({ id: 1, name: `Upd ${ts()}` })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('delete_kanban_column returns result', async () => {
+ const { server, tools } = mockServer()
+ registerKanbanTools(server, mockApi({ kanban: { deleteColumn: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'delete_kanban_column').cb({ id: 1 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('handles API errors', async () => {
+ const { server, tools } = mockServer()
+ registerKanbanTools(server, mockApi({ kanban: { fetchAllColumns: apiThrow(`Forbidden ${ts()}`) } }))
+
+ const result = await findTool(tools, 'list_kanban_columns').cb({ goalId: 1 })
+ expect(result.isError).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/lists.test.ts b/taskview-packages/taskview-mcp/src/__tests__/lists.test.ts
new file mode 100644
index 0000000..c2fb1ab
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/lists.test.ts
@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest'
+import { registerListsTools } from '../tools/lists.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('lists tools', () => {
+ it('registers all list tools', () => {
+ const { server, tools } = mockServer()
+ registerListsTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual(['list_lists', 'create_list', 'update_list', 'delete_list'])
+ })
+
+ it('list_lists returns lists for goal', async () => {
+ const { server, tools } = mockServer()
+ const lists = [{ id: 1, name: `Backlog ${ts()}` }, { id: 2, name: `Sprint ${ts()}` }]
+ registerListsTools(server, mockApi({ goalLists: { fetchLists: apiReturn(lists) } }))
+
+ const result = await findTool(tools, 'list_lists').cb({ goalId: 5 })
+ expect(result.content[0].text).toContain(lists[0].name)
+ expect(result.content[0].text).toContain(lists[1].name)
+ })
+
+ it('create_list returns new list', async () => {
+ const { server, tools } = mockServer()
+ const name = `List ${ts()}`
+ registerListsTools(server, mockApi({ goalLists: { createList: apiReturn({ id: 10, name }) } }))
+
+ const result = await findTool(tools, 'create_list').cb({ goalId: 1, name })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('update_list returns updated list', async () => {
+ const { server, tools } = mockServer()
+ const name = `Renamed ${ts()}`
+ registerListsTools(server, mockApi({ goalLists: { updateList: apiReturn({ id: 1, name }) } }))
+
+ const result = await findTool(tools, 'update_list').cb({ id: 1, name })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('delete_list returns success', async () => {
+ const { server, tools } = mockServer()
+ registerListsTools(server, mockApi({ goalLists: { deleteList: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'delete_list').cb({ id: 1 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('handles API errors', async () => {
+ const { server, tools } = mockServer()
+ registerListsTools(server, mockApi({ goalLists: { fetchLists: apiThrow(`DB error ${ts()}`) } }))
+
+ const result = await findTool(tools, 'list_lists').cb({ goalId: 1 })
+ expect(result.isError).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/notifications.test.ts b/taskview-packages/taskview-mcp/src/__tests__/notifications.test.ts
new file mode 100644
index 0000000..24f6e24
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/notifications.test.ts
@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest'
+import { registerNotificationsTools } from '../tools/notifications.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('notifications tools', () => {
+ it('registers all notification tools', () => {
+ const { server, tools } = mockServer()
+ registerNotificationsTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual(['list_notifications', 'mark_notification_read', 'mark_all_notifications_read'])
+ })
+
+ it('list_notifications returns notifications', async () => {
+ const { server, tools } = mockServer()
+ const data = { notifications: [{ id: 1, title: `Notif ${ts()}`, read: false }] }
+ registerNotificationsTools(server, mockApi({ notifications: { fetch: apiReturn(data) } }))
+
+ const result = await findTool(tools, 'list_notifications').cb({})
+ expect(result.content[0].text).toContain(data.notifications[0].title)
+ })
+
+ it('list_notifications passes cursor', async () => {
+ const { server, tools } = mockServer()
+ let capturedCursor: unknown
+ const fetch = (cursor: unknown) => {
+ capturedCursor = cursor
+ return Promise.resolve({ response: { notifications: [] }, rid: `rid-${ts()}` })
+ }
+ registerNotificationsTools(server, mockApi({ notifications: { fetch } }))
+
+ await findTool(tools, 'list_notifications').cb({ cursor: 42 })
+ expect(capturedCursor).toBe(42)
+ })
+
+ it('mark_notification_read returns result', async () => {
+ const { server, tools } = mockServer()
+ registerNotificationsTools(server, mockApi({ notifications: { markRead: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'mark_notification_read').cb({ notificationId: 1 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('mark_all_notifications_read returns result', async () => {
+ const { server, tools } = mockServer()
+ registerNotificationsTools(server, mockApi({ notifications: { markAllRead: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'mark_all_notifications_read').cb({})
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('handles API errors', async () => {
+ const { server, tools } = mockServer()
+ registerNotificationsTools(server, mockApi({ notifications: { markRead: apiThrow(`Not found ${ts()}`) } }))
+
+ const result = await findTool(tools, 'mark_notification_read').cb({ notificationId: 999 })
+ expect(result.isError).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/setup.ts b/taskview-packages/taskview-mcp/src/__tests__/setup.ts
new file mode 100644
index 0000000..49004c6
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/setup.ts
@@ -0,0 +1,73 @@
+import type { TvApi } from 'taskview-api'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+
+export const ts = () => Date.now()
+
+function wrap<T>(value: T) {
+ return Promise.resolve({ response: value, rid: `rid-${ts()}` })
+}
+
+const noop = () => Promise.resolve(null)
+
+export function mockApi(overrides: Record<string, Record<string, unknown>> = {}): TvApi {
+ const defaults: Record<string, Record<string, unknown>> = {
+ goals: { fetchGoals: noop, createGoal: noop, updateGoal: noop, deleteGoal: noop },
+ tasks: {
+ fetch: noop, fetchTaskById: noop, createTask: noop, updateTask: noop,
+ deleteTask: noop, toggleTasksAssignee: noop, fetchTaskHistory: noop, recoveryTaskHistory: noop,
+ },
+ goalLists: { fetchLists: noop, createList: noop, updateList: noop, deleteList: noop },
+ tags: { fetchAllTagsForUser: noop, createTag: noop, updateTag: noop, deleteTag: noop, toggleTag: noop },
+ kanban: { fetchAllColumns: noop, addColumn: noop, updateColumn: noop, deleteColumn: noop },
+ collaboration: {
+ fetchAllUsers: noop, fetchUsersForGoal: noop, inviteUserToGoal: noop, deleteUserFromGoal: noop,
+ toggleUserRoles: noop, fetchRolesForGoal: noop, createRoleForGoal: noop, deleteRoleFromGoal: noop,
+ fetchRoleToPermissionsForGoal: noop, fetchAllPermissions: noop, toggleRolePermission: noop,
+ },
+ graph: { fetchAllEdges: noop, addEdge: noop, deleteEdge: noop },
+ notifications: { fetch: noop, markRead: noop, markAllRead: noop },
+ }
+
+ for (const [ns, methods] of Object.entries(overrides)) {
+ if (!defaults[ns]) defaults[ns] = {}
+ Object.assign(defaults[ns], methods)
+ }
+
+ return defaults as unknown as TvApi
+}
+
+export function apiReturn(value: unknown) {
+ return () => Promise.resolve(value)
+}
+
+export function apiThrow(message: string) {
+ return () => Promise.reject(new Error(message))
+}
+
+type ToolEntry = {
+ name: string
+ config: { description?: string; inputSchema?: Record<string, unknown> }
+ cb: (args: Record<string, unknown>) => Promise<{ content: { type: string; text: string }[]; isError?: boolean }>
+}
+
+export function mockServer() {
+ const tools: ToolEntry[] = []
+
+ const server = {
+ registerTool(
+ name: string,
+ config: ToolEntry['config'],
+ cb: ToolEntry['cb'],
+ ) {
+ tools.push({ name, config, cb })
+ },
+ } as unknown as McpServer
+
+ return { server, tools }
+}
+
+export function findTool(tools: ToolEntry[], name: string) {
+ const tool = tools.find((t) => t.name === name)
+ if (!tool) throw new Error(`Tool "${name}" not found`)
+ return tool
+}
diff --git a/taskview-packages/taskview-mcp/src/__tests__/tags.test.ts b/taskview-packages/taskview-mcp/src/__tests__/tags.test.ts
new file mode 100644
index 0000000..331c310
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/tags.test.ts
@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest'
+import { registerTagsTools } from '../tools/tags.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('tags tools', () => {
+ it('registers all tag tools', () => {
+ const { server, tools } = mockServer()
+ registerTagsTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual(['list_tags', 'create_tag', 'update_tag', 'delete_tag', 'toggle_task_tag'])
+ })
+
+ it('list_tags returns tags', async () => {
+ const { server, tools } = mockServer()
+ const tags = [{ id: 1, name: `bug-${ts()}`, color: '#EF4444' }]
+ registerTagsTools(server, mockApi({ tags: { fetchAllTagsForUser: apiReturn(tags) } }))
+
+ const result = await findTool(tools, 'list_tags').cb({})
+ expect(result.content[0].text).toContain(tags[0].name)
+ })
+
+ it('create_tag returns new tag', async () => {
+ const { server, tools } = mockServer()
+ const name = `tag-${ts()}`
+ registerTagsTools(server, mockApi({ tags: { createTag: apiReturn({ id: 5, name }) } }))
+
+ const result = await findTool(tools, 'create_tag').cb({ goalId: 1, name, color: '#10B981' })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('update_tag returns updated tag', async () => {
+ const { server, tools } = mockServer()
+ const name = `updated-${ts()}`
+ registerTagsTools(server, mockApi({ tags: { updateTag: apiReturn({ id: 1, name }) } }))
+
+ const result = await findTool(tools, 'update_tag').cb({ id: 1, name, color: '#000', goalId: 1 })
+ expect(result.content[0].text).toContain(name)
+ })
+
+ it('delete_tag returns success', async () => {
+ const { server, tools } = mockServer()
+ registerTagsTools(server, mockApi({ tags: { deleteTag: apiReturn(true) } }))
+
+ const result = await findTool(tools, 'delete_tag').cb({ tagId: 1 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('toggle_task_tag returns action', async () => {
+ const { server, tools } = mockServer()
+ registerTagsTools(server, mockApi({ tags: { toggleTag: apiReturn({ action: 'add' }) } }))
+
+ const result = await findTool(tools, 'toggle_task_tag').cb({ tagId: 1, taskId: 10 })
+ expect(result.content[0].text).toContain('add')
+ })
+
+ it('handles API errors', async () => {
+ const { server, tools } = mockServer()
+ registerTagsTools(server, mockApi({ tags: { createTag: apiThrow(`Conflict ${ts()}`) } }))
+
+ const result = await findTool(tools, 'create_tag').cb({ goalId: 1, name: 'x', color: '#000' })
+ expect(result.isError).toBe(true)
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/__tests__/tasks.test.ts b/taskview-packages/taskview-mcp/src/__tests__/tasks.test.ts
new file mode 100644
index 0000000..9429032
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/__tests__/tasks.test.ts
@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest'
+import { registerTasksTools } from '../tools/tasks.js'
+import { mockServer, mockApi, apiReturn, apiThrow, findTool, ts } from './setup.js'
+
+describe('tasks tools', () => {
+ it('registers all task tools', () => {
+ const { server, tools } = mockServer()
+ registerTasksTools(server, mockApi())
+
+ expect(tools.map((t) => t.name)).toEqual([
+ 'list_tasks', 'get_task', 'create_task', 'update_task',
+ 'delete_task', 'toggle_task_assignees', 'get_task_history', 'restore_task_from_history',
+ ])
+ })
+
+ it('list_tasks returns paginated tasks', async () => {
+ const { server, tools } = mockServer()
+ const mockTasks = [{ id: 1, description: `Task A ${ts()}` }]
+ registerTasksTools(server, mockApi({ tasks: { fetch: apiReturn(mockTasks) } }))
+
+ const result = await findTool(tools, 'list_tasks').cb({ goalId: 1 })
+ expect(result.content[0].text).toContain(mockTasks[0].description)
+ })
+
+ it('list_tasks passes correct params', async () => {
+ const { server, tools } = mockServer()
+ let captured: Record<string, unknown> = {}
+ const fetch = (params: Record<string, unknown>) => {
+ captured = params
+ return Promise.resolve({ response: [], rid: `rid-${ts()}` })
+ }
+ registerTasksTools(server, mockApi({ tasks: { fetch } }))
+
+ await findTool(tools, 'list_tasks').cb({
+ goalId: 5, componentId: 10, page: 2, showCompleted: true, searchText: 'test',
+ })
+ expect(captured.goalId).toBe(5)
+ expect(captured.componentId).toBe(10)
+ expect(captured.page).toBe(2)
+ expect(captured.showCompleted).toBe(1)
+ expect(captured.searchText).toBe('test')
+ })
+
+ it('list_tasks defaults componentId and page', async () => {
+ const { server, tools } = mockServer()
+ let captured: Record<string, unknown> = {}
+ const fetch = (params: Record<string, unknown>) => {
+ captured = params
+ return Promise.resolve({ response: [], rid: `rid-${ts()}` })
+ }
+ registerTasksTools(server, mockApi({ tasks: { fetch } }))
+
+ await findTool(tools, 'list_tasks').cb({ goalId: 1 })
+ expect(captured.componentId).toBe(0)
+ expect(captured.page).toBe(1)
+ expect(captured.showCompleted).toBe(0)
+ })
+
+ it('get_task returns task', async () => {
+ const { server, tools } = mockServer()
+ const task = { id: 42, description: `Detail ${ts()}` }
+ registerTasksTools(server, mockApi({ tasks: { fetchTaskById: apiReturn(task) } }))
+
+ const result = await findTool(tools, 'get_task').cb({ taskId: 42 })
+ expect(result.content[0].text).toContain(task.description)
+ })
+
+ it('get_task handles not found', async () => {
+ const { server, tools } = mockServer()
+ registerTasksTools(server, mockApi({ tasks: { fetchTaskById: apiReturn(null) } }))
+
+ const result = await findTool(tools, 'get_task').cb({ taskId: 999 })
+ expect(result.isError).toBe(true)
+ })
+
+ it('create_task returns new task', async () => {
+ const { server, tools } = mockServer()
+ const desc = `New task ${ts()}`
+ registerTasksTools(server, mockApi({ tasks: { createTask: apiReturn({ id: 100, description: desc }) } }))
+
+ const result = await findTool(tools, 'create_task').cb({ goalId: 1, description: desc })
+ expect(result.content[0].text).toContain(desc)
+ })
+
+ it('update_task returns updated task', async () => {
+ const { server, tools } = mockServer()
+ const desc = `Updated ${ts()}`
+ registerTasksTools(server, mockApi({ tasks: { updateTask: apiReturn({ id: 1, description: desc }) } }))
+
+ const result = await findTool(tools, 'update_task').cb({ id: 1, description: desc })
+ expect(result.content[0].text).toContain(desc)
+ })
+
+ it('update_task handles not found', async () => {
+ const { server, tools } = mockServer()
+ registerTasksTools(server, mockApi({ tasks: { updateTask: apiReturn(null) } }))
+
+ const result = await findTool(tools, 'update_task').cb({ id: 999 })
+ expect(result.isError).toBe(true)
+ })
+
+ it('delete_task returns result', async () => {
+ const { server, tools } = mockServer()
+ registerTasksTools(server, mockApi({ tasks: { deleteTask: apiReturn({ delete: true }) } }))
+
+ const result = await findTool(tools, 'delete_task').cb({ taskId: 1 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('toggle_task_assignees returns user ids', async () => {
+ const { server, tools } = mockServer()
+ registerTasksTools(server, mockApi({ tasks: { toggleTasksAssignee: apiReturn({ userIds: [1, 2] }) } }))
+
+ const result = await findTool(tools, 'toggle_task_assignees').cb({ taskId: 1, userIds: [1, 2] })
+ expect(result.content[0].text).toContain('1')
+ })
+
+ it('get_task_history returns history', async () => {
+ const { server, tools } = mockServer()
+ const history = { history: [{ id: 1, description: `v1 ${ts()}` }] }
+ registerTasksTools(server, mockApi({ tasks: { fetchTaskHistory: apiReturn(history) } }))
+
+ const result = await findTool(tools, 'get_task_history').cb({ taskId: 1 })
+ expect(result.content[0].text).toContain('v1')
+ })
+
+ it('restore_task_from_history returns result', async () => {
+ const { server, tools } = mockServer()
+ registerTasksTools(server, mockApi({ tasks: { recoveryTaskHistory: apiReturn({ recovery: true }) } }))
+
+ const result = await findTool(tools, 'restore_task_from_history').cb({ taskId: 1, historyId: 5 })
+ expect(result.content[0].text).toContain('true')
+ })
+
+ it('handles API errors', async () => {
+ const { server, tools } = mockServer()
+ registerTasksTools(server, mockApi({ tasks: { fetch: apiThrow(`Timeout ${ts()}`) } }))
+
+ const result = await findTool(tools, 'list_tasks').cb({ goalId: 1 })
+ expect(result.isError).toBe(true)
+ expect(result.content[0].text).toContain('Timeout')
+ })
+})
diff --git a/taskview-packages/taskview-mcp/src/index.ts b/taskview-packages/taskview-mcp/src/index.ts
new file mode 100644
index 0000000..f340f24
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/index.ts
@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import axios from 'axios'
+import { TvApi } from 'taskview-api'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { createMcpServer } from './server.js'
+
+const TASKVIEW_URL = process.env.TASKVIEW_URL
+const TASKVIEW_TOKEN = process.env.TASKVIEW_TOKEN
+
+if (!TASKVIEW_URL || !TASKVIEW_TOKEN) {
+ console.error('Required environment variables: TASKVIEW_URL, TASKVIEW_TOKEN')
+ console.error('Example: TASKVIEW_URL=https://api.taskview.tech TASKVIEW_TOKEN=tvk_...')
+ process.exit(1)
+}
+
+const $axios = axios.create({
+ baseURL: TASKVIEW_URL,
+ timeout: 30000,
+})
+$axios.defaults.headers.common['Authorization'] = `Bearer ${TASKVIEW_TOKEN}`
+
+const api = new TvApi($axios)
+const server = createMcpServer(api)
+const transport = new StdioServerTransport()
+
+await server.connect(transport)
diff --git a/taskview-packages/taskview-mcp/src/server.ts b/taskview-packages/taskview-mcp/src/server.ts
new file mode 100644
index 0000000..54c2d76
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/server.ts
@@ -0,0 +1,30 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { registerGoalsTools } from './tools/goals.js'
+import { registerListsTools } from './tools/lists.js'
+import { registerTasksTools } from './tools/tasks.js'
+import { registerTagsTools } from './tools/tags.js'
+import { registerKanbanTools } from './tools/kanban.js'
+import { registerCollaborationTools } from './tools/collaboration.js'
+import { registerGraphTools } from './tools/graph.js'
+import { registerNotificationsTools } from './tools/notifications.js'
+import { registerOrganizationsTools } from './tools/organizations.js'
+
+export function createMcpServer(api: TvApi) {
+ const server = new McpServer({
+ name: 'taskview',
+ version: '1.0.0',
+ })
+
+ registerGoalsTools(server, api)
+ registerListsTools(server, api)
+ registerTasksTools(server, api)
+ registerTagsTools(server, api)
+ registerKanbanTools(server, api)
+ registerCollaborationTools(server, api)
+ registerGraphTools(server, api)
+ registerNotificationsTools(server, api)
+ registerOrganizationsTools(server, api)
+
+ return server
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/collaboration.ts b/taskview-packages/taskview-mcp/src/tools/collaboration.ts
new file mode 100644
index 0000000..7c5a500
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/collaboration.ts
@@ -0,0 +1,185 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerCollaborationTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_collaborators',
+ {
+ description: 'List all collaborators across all projects',
+ },
+ async () => {
+ try {
+ const users = await api.collaboration.fetchAllUsers()
+ return ok(users)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'list_collaborators_for_goal',
+ {
+ description: 'List collaborators for a specific project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ },
+ },
+ async ({ goalId }) => {
+ try {
+ const users = await api.collaboration.fetchUsersForGoal(goalId)
+ return ok(users)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'invite_collaborator',
+ {
+ description: 'Invite a user to a project by email',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ email: z.string().describe('User email to invite'),
+ },
+ },
+ async (params) => {
+ try {
+ const user = await api.collaboration.inviteUserToGoal(params)
+ if (!user) return err('Failed to invite user')
+ return ok(user)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'remove_collaborator',
+ {
+ description: 'Remove a user from a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ id: z.coerce.number().describe('Collaboration record ID'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.collaboration.deleteUserFromGoal(params)
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'toggle_collaborator_roles',
+ {
+ description: 'Update roles for a collaborator in a project',
+ inputSchema: {
+ userId: z.coerce.number().describe('User ID'),
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ roles: z.array(z.coerce.number()).describe('Role IDs to set'),
+ },
+ },
+ async (params) => {
+ try {
+ const roles = await api.collaboration.toggleUserRoles(params)
+ return ok({ roles })
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'list_roles',
+ {
+ description: 'List all roles for a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ },
+ },
+ async ({ goalId }) => {
+ try {
+ const roles = await api.collaboration.fetchRolesForGoal(goalId)
+ return ok(roles)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'create_role',
+ {
+ description: 'Create a new role for a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ roleName: z.string().describe('Role name'),
+ },
+ },
+ async (params) => {
+ try {
+ const role = await api.collaboration.createRoleForGoal(params)
+ if (!role) return err('Failed to create role')
+ return ok(role)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_role',
+ {
+ description: 'Delete a role from a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ id: z.coerce.number().describe('Role ID to delete'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.collaboration.deleteRoleFromGoal(params)
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'list_role_permissions_for_goal',
+ {
+ description: 'Get role-to-permission mappings for a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ },
+ },
+ async ({ goalId }) => {
+ try {
+ const permissions = await api.collaboration.fetchRoleToPermissionsForGoal(goalId)
+ return ok(permissions)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'list_permissions',
+ {
+ description: 'List all available permissions',
+ },
+ async () => {
+ try {
+ const permissions = await api.collaboration.fetchAllPermissions()
+ return ok(permissions)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'toggle_role_permission',
+ {
+ description: 'Add or remove a permission from a role',
+ inputSchema: {
+ roleId: z.coerce.number().describe('Role ID'),
+ permissionId: z.coerce.number().describe('Permission ID'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.collaboration.toggleRolePermission(params)
+ return ok(result)
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/goals.ts b/taskview-packages/taskview-mcp/src/tools/goals.ts
new file mode 100644
index 0000000..bc84ea5
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/goals.ts
@@ -0,0 +1,79 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerGoalsTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_goals',
+ {
+ description: 'List all projects (goals) accessible to the current user. Optionally filter by organization.',
+ inputSchema: {
+ organizationId: z.coerce.number().optional().describe('Filter by organization ID'),
+ },
+ },
+ async ({ organizationId }) => {
+ try {
+ const goals = await api.goals.fetchGoals(organizationId)
+ return ok(goals)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'create_goal',
+ {
+ description: 'Create a new project (goal). If organizationId is provided, creates within that organization.',
+ inputSchema: {
+ name: z.string().describe('Project name'),
+ description: z.string().optional().describe('Project description'),
+ color: z.string().optional().describe('Project color (hex)'),
+ organizationId: z.coerce.number().optional().describe('Organization ID to create the project in'),
+ },
+ },
+ async (params) => {
+ try {
+ const goal = await api.goals.createGoal(params)
+ if (!goal) return err('Failed to create goal')
+ return ok(goal)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'update_goal',
+ {
+ description: 'Update a project (goal) — name, description, color',
+ inputSchema: {
+ id: z.coerce.number().describe('Goal ID'),
+ name: z.string().optional().describe('New name'),
+ description: z.string().optional().describe('New description'),
+ color: z.string().optional().describe('New color (hex)'),
+ archive: z.union([z.literal(0), z.literal(1)]).optional().describe('Archive status: 0=active, 1=archived'),
+ },
+ },
+ async (params) => {
+ try {
+ const goal = await api.goals.updateGoal(params)
+ if (!goal) return err('Goal not found or update failed')
+ return ok(goal)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_goal',
+ {
+ description: 'Delete a project (goal)',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Goal ID to delete'),
+ },
+ },
+ async ({ goalId }) => {
+ try {
+ const result = await api.goals.deleteGoal(goalId)
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/graph.ts b/taskview-packages/taskview-mcp/src/tools/graph.ts
new file mode 100644
index 0000000..2dcf22e
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/graph.ts
@@ -0,0 +1,55 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerGraphTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_task_dependencies',
+ {
+ description: 'List all task dependency edges in a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ },
+ },
+ async ({ goalId }) => {
+ try {
+ const edges = await api.graph.fetchAllEdges(goalId)
+ return ok(edges)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'add_task_dependency',
+ {
+ description: 'Create a dependency between two tasks',
+ inputSchema: {
+ source: z.coerce.number().describe('Source task ID'),
+ target: z.coerce.number().describe('Target task ID (blocked by source)'),
+ },
+ },
+ async (params) => {
+ try {
+ const edge = await api.graph.addEdge(params)
+ return ok(edge)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_task_dependency',
+ {
+ description: 'Delete a task dependency edge',
+ inputSchema: {
+ id: z.coerce.number().describe('Dependency edge ID'),
+ },
+ },
+ async ({ id }) => {
+ try {
+ const result = await api.graph.deleteEdge(id)
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/helpers.ts b/taskview-packages/taskview-mcp/src/tools/helpers.ts
new file mode 100644
index 0000000..71121be
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/helpers.ts
@@ -0,0 +1,8 @@
+export function ok(data: unknown) {
+ return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] }
+}
+
+export function err(e: unknown) {
+ const msg = e instanceof Error ? e.message : String(e)
+ return { content: [{ type: 'text' as const, text: `Error: ${msg}` }], isError: true as const }
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/kanban.ts b/taskview-packages/taskview-mcp/src/tools/kanban.ts
new file mode 100644
index 0000000..54cd3f8
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/kanban.ts
@@ -0,0 +1,73 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerKanbanTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_kanban_columns',
+ {
+ description: 'Get all kanban columns for a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ },
+ },
+ async ({ goalId }) => {
+ try {
+ const columns = await api.kanban.fetchAllColumns(goalId)
+ return ok(columns)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'create_kanban_column',
+ {
+ description: 'Create a new kanban column in a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ name: z.string().describe('Column name'),
+ },
+ },
+ async (params) => {
+ try {
+ const column = await api.kanban.addColumn(params)
+ return ok(column)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'update_kanban_column',
+ {
+ description: 'Update a kanban column',
+ inputSchema: {
+ id: z.coerce.number().describe('Column ID'),
+ name: z.string().describe('New column name'),
+ viewOrder: z.coerce.number().optional().describe('Display order'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.kanban.updateColumn(params)
+ return ok({ updated: result })
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_kanban_column',
+ {
+ description: 'Delete a kanban column',
+ inputSchema: {
+ id: z.coerce.number().describe('Column ID to delete'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.kanban.deleteColumn(params)
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/lists.ts b/taskview-packages/taskview-mcp/src/tools/lists.ts
new file mode 100644
index 0000000..2b89543
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/lists.ts
@@ -0,0 +1,75 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerListsTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_lists',
+ {
+ description: 'Get all task lists within a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ },
+ },
+ async ({ goalId }) => {
+ try {
+ const lists = await api.goalLists.fetchLists({ goalId })
+ return ok(lists)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'create_list',
+ {
+ description: 'Create a new task list within a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ name: z.string().describe('List name'),
+ description: z.string().optional().describe('List description'),
+ },
+ },
+ async (params) => {
+ try {
+ const list = await api.goalLists.createList(params)
+ return ok(list)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'update_list',
+ {
+ description: 'Update a task list',
+ inputSchema: {
+ id: z.coerce.number().describe('List ID'),
+ name: z.string().optional().describe('New name'),
+ description: z.string().optional().describe('New description'),
+ archive: z.union([z.literal(0), z.literal(1)]).optional().describe('Archive status'),
+ },
+ },
+ async (params) => {
+ try {
+ const list = await api.goalLists.updateList(params)
+ return ok(list)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_list',
+ {
+ description: 'Delete a task list',
+ inputSchema: {
+ id: z.coerce.number().describe('List ID to delete'),
+ },
+ },
+ async ({ id }) => {
+ try {
+ const result = await api.goalLists.deleteList(id)
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/notifications.ts b/taskview-packages/taskview-mcp/src/tools/notifications.ts
new file mode 100644
index 0000000..88effc6
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/notifications.ts
@@ -0,0 +1,51 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerNotificationsTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_notifications',
+ {
+ description: 'Get user notifications',
+ inputSchema: {
+ cursor: z.coerce.number().optional().describe('Pagination cursor'),
+ },
+ },
+ async ({ cursor }) => {
+ try {
+ const result = await api.notifications.fetch(cursor)
+ return ok(result)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'mark_notification_read',
+ {
+ description: 'Mark a notification as read',
+ inputSchema: {
+ notificationId: z.coerce.number().describe('Notification ID'),
+ },
+ },
+ async ({ notificationId }) => {
+ try {
+ const result = await api.notifications.markRead(notificationId)
+ return ok({ read: result })
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'mark_all_notifications_read',
+ {
+ description: 'Mark all notifications as read',
+ },
+ async () => {
+ try {
+ const result = await api.notifications.markAllRead()
+ return ok({ read: result })
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/organizations.ts b/taskview-packages/taskview-mcp/src/tools/organizations.ts
new file mode 100644
index 0000000..6cb735f
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/organizations.ts
@@ -0,0 +1,161 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerOrganizationsTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_organizations',
+ {
+ description: 'List all organizations the current user belongs to',
+ },
+ async () => {
+ try {
+ const orgs = await api.organizations.fetch()
+ return ok(orgs)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'get_organization',
+ {
+ description: 'Get organization details by ID',
+ inputSchema: {
+ organizationId: z.coerce.number().describe('Organization ID'),
+ },
+ },
+ async ({ organizationId }) => {
+ try {
+ const org = await api.organizations.getById(organizationId)
+ return ok(org)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'create_organization',
+ {
+ description: 'Create a new organization. The creator becomes the owner.',
+ inputSchema: {
+ name: z.string().describe('Organization name'),
+ slug: z.string().optional().describe('URL-friendly slug (auto-generated if omitted)'),
+ logoUrl: z.string().optional().describe('Logo URL'),
+ },
+ },
+ async (params) => {
+ try {
+ const org = await api.organizations.create(params)
+ if (!org) return err('Failed to create organization')
+ return ok(org)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'update_organization',
+ {
+ description: 'Update organization name, slug, or logo. Requires admin or owner role.',
+ inputSchema: {
+ organizationId: z.coerce.number().describe('Organization ID'),
+ name: z.string().optional().describe('New name'),
+ slug: z.string().optional().describe('New slug'),
+ logoUrl: z.string().optional().describe('New logo URL'),
+ },
+ },
+ async (params) => {
+ try {
+ const org = await api.organizations.update(params)
+ if (!org) return err('Organization not found or update failed')
+ return ok(org)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_organization',
+ {
+ description: 'Delete an organization. Only the owner can delete. Personal workspaces cannot be deleted.',
+ inputSchema: {
+ organizationId: z.coerce.number().describe('Organization ID to delete'),
+ },
+ },
+ async ({ organizationId }) => {
+ try {
+ const result = await api.organizations.delete({ organizationId })
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'list_organization_members',
+ {
+ description: 'List all members of an organization',
+ inputSchema: {
+ organizationId: z.coerce.number().describe('Organization ID'),
+ },
+ },
+ async ({ organizationId }) => {
+ try {
+ const members = await api.organizations.fetchMembers(organizationId)
+ return ok(members)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'add_organization_member',
+ {
+ description: 'Add a member to an organization by email. Requires admin or owner role.',
+ inputSchema: {
+ organizationId: z.coerce.number().describe('Organization ID'),
+ email: z.string().describe('Email of the user to add'),
+ role: z.enum(['admin', 'member']).optional().default('member').describe('Role: admin or member'),
+ },
+ },
+ async (params) => {
+ try {
+ const member = await api.organizations.addMember(params)
+ if (!member) return err('Failed to add member')
+ return ok(member)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'update_organization_member_role',
+ {
+ description: 'Change a member role in an organization. Cannot change the owner role.',
+ inputSchema: {
+ organizationId: z.coerce.number().describe('Organization ID'),
+ email: z.string().describe('Email of the member'),
+ role: z.enum(['admin', 'member']).describe('New role: admin or member'),
+ },
+ },
+ async (params) => {
+ try {
+ const member = await api.organizations.updateMemberRole(params)
+ if (!member) return err('Failed to update member role')
+ return ok(member)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'remove_organization_member',
+ {
+ description: 'Remove a member from an organization. Cannot remove the owner.',
+ inputSchema: {
+ organizationId: z.coerce.number().describe('Organization ID'),
+ email: z.string().describe('Email of the member to remove'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.organizations.removeMember(params)
+ return ok({ removed: result })
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/tags.ts b/taskview-packages/taskview-mcp/src/tools/tags.ts
new file mode 100644
index 0000000..79458e6
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/tags.ts
@@ -0,0 +1,89 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { TvApi } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerTagsTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_tags',
+ {
+ description: 'List all tags accessible to the current user',
+ },
+ async () => {
+ try {
+ const tags = await api.tags.fetchAllTagsForUser()
+ return ok(tags)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'create_tag',
+ {
+ description: 'Create a new tag',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ name: z.string().describe('Tag name'),
+ color: z.string().describe('Tag color (hex)'),
+ },
+ },
+ async (params) => {
+ try {
+ const tag = await api.tags.createTag(params)
+ return ok(tag)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'update_tag',
+ {
+ description: 'Update a tag',
+ inputSchema: {
+ id: z.coerce.number().describe('Tag ID'),
+ name: z.string().describe('New tag name'),
+ color: z.string().describe('New tag color (hex)'),
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ },
+ },
+ async (params) => {
+ try {
+ const tag = await api.tags.updateTag(params)
+ return ok(tag)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_tag',
+ {
+ description: 'Delete a tag',
+ inputSchema: {
+ tagId: z.coerce.number().describe('Tag ID to delete'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.tags.deleteTag(params)
+ return ok({ deleted: result })
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'toggle_task_tag',
+ {
+ description: 'Add or remove a tag from a task',
+ inputSchema: {
+ tagId: z.coerce.number().describe('Tag ID'),
+ taskId: z.coerce.number().describe('Task ID'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.tags.toggleTag(params)
+ return ok(result)
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/src/tools/tasks.ts b/taskview-packages/taskview-mcp/src/tools/tasks.ts
new file mode 100644
index 0000000..adf2af3
--- /dev/null
+++ b/taskview-packages/taskview-mcp/src/tools/tasks.ts
@@ -0,0 +1,167 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { type TvApi, ALL_TASKS_LIST_ID } from 'taskview-api'
+import { z } from 'zod'
+import { ok, err } from './helpers.js'
+
+export function registerTasksTools(server: McpServer, api: TvApi) {
+ server.registerTool(
+ 'list_tasks',
+ {
+ description: 'List tasks for a specific project (goal). Returns paginated results.',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ componentId: z.coerce.number().optional().describe('List (component) ID to filter by'),
+ page: z.coerce.number().optional().default(0).describe('Page number (0-based, default: 0)'),
+ showCompleted: z.boolean().optional().default(false).describe('Include completed tasks'),
+ searchText: z.string().optional().describe('Search text to filter tasks'),
+ },
+ },
+ async ({ goalId, componentId, page, showCompleted, searchText }) => {
+ try {
+ const tasks = await api.tasks.fetch({
+ goalId,
+ componentId: componentId ?? ALL_TASKS_LIST_ID,
+ page: page ?? 0,
+ showCompleted: showCompleted ? 1 : 0,
+ firstNew: 0,
+ searchText,
+ })
+ return ok(tasks)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'get_task',
+ {
+ description: 'Get a single task by its ID with full details',
+ inputSchema: {
+ taskId: z.coerce.number().describe('Task ID'),
+ },
+ },
+ async ({ taskId }) => {
+ try {
+ const task = await api.tasks.fetchTaskById(taskId)
+ if (!task) return err('Task not found')
+ return ok(task)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'create_task',
+ {
+ description: 'Create a new task in a project',
+ inputSchema: {
+ goalId: z.coerce.number().describe('Project (goal) ID'),
+ description: z.string().describe('Task title/description'),
+ goalListId: z.coerce.number().optional().nullable().describe('List ID within the project'),
+ note: z.string().optional().nullable().describe('Additional notes'),
+ priorityId: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional()
+ .describe('Priority: 1=low, 2=medium, 3=high'),
+ startDate: z.string().optional().nullable().describe('Start date (ISO format)'),
+ endDate: z.string().optional().nullable().describe('End/due date (ISO format)'),
+ parentId: z.coerce.number().optional().nullable().describe('Parent task ID (for subtasks)'),
+ statusId: z.coerce.number().optional().nullable().describe('Kanban column status ID'),
+ },
+ },
+ async (params) => {
+ try {
+ const task = await api.tasks.createTask(params)
+ return ok(task)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'update_task',
+ {
+ description: 'Update an existing task (description, status, priority, dates, etc.)',
+ inputSchema: {
+ id: z.coerce.number().describe('Task ID to update'),
+ description: z.string().optional().describe('New task description'),
+ complete: z.boolean().optional().describe('Mark task as complete/incomplete'),
+ note: z.string().optional().describe('Task notes'),
+ priorityId: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional()
+ .describe('Priority: 1=low, 2=medium, 3=high'),
+ goalListId: z.coerce.number().optional().nullable().describe('Move to a different list'),
+ startDate: z.string().optional().nullable().describe('Start date (ISO format)'),
+ endDate: z.string().optional().nullable().describe('End/due date (ISO format)'),
+ statusId: z.coerce.number().optional().nullable().describe('Kanban column status ID'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.tasks.updateTask(params)
+ if (!result) return err('Task not found or update failed')
+ return ok(result)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'delete_task',
+ {
+ description: 'Delete a task',
+ inputSchema: {
+ taskId: z.coerce.number().describe('Task ID to delete'),
+ },
+ },
+ async ({ taskId }) => {
+ try {
+ const result = await api.tasks.deleteTask(taskId)
+ return ok(result)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'toggle_task_assignees',
+ {
+ description: 'Assign or unassign users to/from a task',
+ inputSchema: {
+ taskId: z.coerce.number().describe('Task ID'),
+ userIds: z.array(z.coerce.number()).describe('User IDs to toggle'),
+ },
+ },
+ async (params) => {
+ try {
+ const result = await api.tasks.toggleTasksAssignee(params)
+ return ok(result)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'get_task_history',
+ {
+ description: 'Get the change history of a task',
+ inputSchema: {
+ taskId: z.coerce.number().describe('Task ID'),
+ },
+ },
+ async ({ taskId }) => {
+ try {
+ const history = await api.tasks.fetchTaskHistory(taskId)
+ return ok(history)
+ } catch (e) { return err(e) }
+ },
+ )
+
+ server.registerTool(
+ 'restore_task_from_history',
+ {
+ description: 'Restore a task to a previous state from its history',
+ inputSchema: {
+ taskId: z.coerce.number().describe('Task ID'),
+ historyId: z.coerce.number().describe('History entry ID to restore from'),
+ },
+ },
+ async ({ taskId, historyId }) => {
+ try {
+ const result = await api.tasks.recoveryTaskHistory(historyId, taskId)
+ return ok(result)
+ } catch (e) { return err(e) }
+ },
+ )
+}
diff --git a/taskview-packages/taskview-mcp/tsconfig.json b/taskview-packages/taskview-mcp/tsconfig.json
new file mode 100644
index 0000000..d530e02
--- /dev/null
+++ b/taskview-packages/taskview-mcp/tsconfig.json
@@ -0,0 +1,20 @@
+{
+ "compilerOptions": {
+ "target": "ES2022",
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "lib": ["ES2022"],
+ "strict": true,
+ "skipLibCheck": true,
+ "declaration": true,
+ "declarationMap": true,
+ "outDir": "./dist",
+ "rootDir": "./src",
+ "noEmit": false,
+ "esModuleInterop": true,
+ "sourceMap": true,
+ "verbatimModuleSyntax": true
+ },
+ "include": ["src"],
+ "exclude": ["node_modules", "dist"]
+}
diff --git a/taskview-packages/taskview-mcp/vite.config.ts b/taskview-packages/taskview-mcp/vite.config.ts
new file mode 100644
index 0000000..7ab0a40
--- /dev/null
+++ b/taskview-packages/taskview-mcp/vite.config.ts
@@ -0,0 +1,22 @@
+import { defineConfig } from 'vite'
+import { resolve } from 'path'
+
+export default defineConfig({
+ build: {
+ lib: {
+ entry: resolve(__dirname, 'src/index.ts'),
+ formats: ['es'],
+ fileName: () => 'index.js',
+ },
+ rollupOptions: {
+ external: [
+ '@modelcontextprotocol/sdk/server/mcp.js',
+ '@modelcontextprotocol/sdk/server/stdio.js',
+ ],
+ },
+ target: 'node22',
+ outDir: 'dist',
+ sourcemap: true,
+ minify: false,
+ },
+})
diff --git a/web/package.json b/web/package.json
index 5ffb6f9..aca2313 100644
--- a/web/package.json
+++ b/web/package.json
@@ -57,7 +57,7 @@
"@vue-flow/node-toolbar": "^1.1.1",
"@vueuse/core": "^14.1.0",
"arktype": "2.1.20",
- "axios": "^1.13.4",
+ "axios": "1.13.5",
"centrifuge": "^5.5.3",
"date-fns": "^4.1.0",
"firebase": "^12.10.0",
diff --git a/web/src/components/NotificationBell.vue b/web/src/components/NotificationBell.vue
index 346c63f..e3a53bc 100644
--- a/web/src/components/NotificationBell.vue
+++ b/web/src/components/NotificationBell.vue
@@ -119,11 +119,13 @@ import { useUserStore } from '@/stores/user.store'
import { useTaskView } from '@/composables/useTaskView'
import { ALL_TASKS_LIST_ID } from 'taskview-api'
import { formatDistanceToNow } from 'date-fns'
+import { useOrganizationStore } from '@/stores/organization.store'
const { t } = useI18n()
const router = useRouter()
const notificationsStore = useNotificationsStore()
const userStore = useUserStore()
+const orgStore = useOrganizationStore()
const { isMobile } = useTaskView()
const isOpen = ref(false)
@@ -179,4 +181,8 @@ onMounted(() => {
notificationsStore.fetchNotifications(true)
}
})
+
+watch(() => orgStore.currentOrg, () => {
+ notificationsStore.fetchNotifications(true)
+})
</script>
diff --git a/web/src/components/UserMenu.vue b/web/src/components/UserMenu.vue
index d3b33cc..e5549ea 100644
--- a/web/src/components/UserMenu.vue
+++ b/web/src/components/UserMenu.vue
@@ -8,6 +8,7 @@
v-bind="{
...user,
label: collapsed ? undefined : user?.name,
+ description: collapsed ? undefined : user?.description,
trailingIcon: collapsed ? undefined : 'i-lucide-chevrons-up-down'
}"
color="neutral"
@@ -45,6 +46,7 @@ import { useLogout } from '@/composables/useLogout'
import { saveLocale } from '@/plugins/i18n'
import { useUpdater } from '@/composables/useUpdater'
import { useUserStore } from '@/stores/user.store'
+import { useOrganizationStore } from '@/stores/organization.store'
import { $ls } from '@/plugins/axios'
import avatarImg from '@/assets/images/avatar-1.jpeg'
@@ -58,6 +60,7 @@ const appStore = useAppStore()
const router = useRouter()
const toast = useToast()
const userStore = useUserStore()
+const orgStore = useOrganizationStore()
const prodOrDev = ref<'prod' | 'dev'>('prod')
let counter = 0
@@ -108,7 +111,8 @@ async function handleLogout() {
}
const user = computed(() => ({
- name: userStore.email || userStore.login,
+ name: orgStore.currentOrg?.name || userStore.email || userStore.login,
+ description: orgStore.currentOrg ? (userStore.email || userStore.login) : undefined,
avatar: {
src: avatarImg,
alt: userStore.email || userStore.login,
@@ -123,11 +127,21 @@ const items = computed<DropdownMenuItem[][]>(() => [
avatar: user.value.avatar,
},
],
+ orgStore.organizations.length > 1 ? [
+ {
+ type: 'label' as const,
+ label: t('userMenu.switchOrganization'),
+ },
+ ...orgStore.organizations.map(org => ({
+ label: org.name,
+ icon: org.id === orgStore.currentOrg?.id ? 'i-lucide-check' : 'i-lucide-building-2',
+ onSelect(e: Event) {
+ e.preventDefault()
+ orgStore.setCurrentOrg(org)
+ },
+ })),
+ ] : [],
[
- // {
- // label: t('userMenu.profile'),
- // icon: 'i-lucide-user',
- // },
{
label: t('userMenu.accountSettings'),
icon: 'i-lucide-settings',
@@ -135,6 +149,13 @@ const items = computed<DropdownMenuItem[][]>(() => [
router.push({ name: 'account' })
},
},
+ {
+ label: t('userMenu.organizations'),
+ icon: 'i-lucide-building-2',
+ onSelect() {
+ router.push({ name: 'organizations' })
+ },
+ },
],
[
{
diff --git a/web/src/components/features/main/screen-main/DesktopScreen.vue b/web/src/components/features/main/screen-main/DesktopScreen.vue
index f83ae04..2af4fae 100644
--- a/web/src/components/features/main/screen-main/DesktopScreen.vue
+++ b/web/src/components/features/main/screen-main/DesktopScreen.vue
@@ -20,10 +20,12 @@ import WidgetToday from './parts/WidgetToday.vue'
import WidgetUpcoming from './parts/WidgetUpcoming.vue'
import { useBaseScreenStore } from '@/stores/base-screen.store'
import { useCollaborationStore } from '@/stores/collaboration.store'
+import { useOrganizationStore } from '@/stores/organization.store'
import { useTaskView } from '@/composables/useTaskView'
const baseScreenStore = useBaseScreenStore()
const collaborationStore = useCollaborationStore()
+const orgStore = useOrganizationStore()
const { isMobile } = useTaskView()
@@ -44,4 +46,10 @@ Promise.allSettled([
baseScreenStore.fetchAllAvailableLists(),
collaborationStore.fetchAllCollaborationUsers(),
])
+
+watch(() => orgStore.currentOrg, () => {
+ baseScreenStore.fetchAllState()
+ baseScreenStore.fetchAllAvailableLists()
+ collaborationStore.fetchAllCollaborationUsers()
+})
</script>
diff --git a/web/src/components/features/organizations/OrganizationsPanel.vue b/web/src/components/features/organizations/OrganizationsPanel.vue
new file mode 100644
index 0000000..9e6a179
--- /dev/null
+++ b/web/src/components/features/organizations/OrganizationsPanel.vue
@@ -0,0 +1,71 @@
+<template>
+ <div class="flex flex-col gap-6 p-4 lg:p-6 w-full max-w-full lg:max-w-2xl m-0 lg:mx-auto">
+ <div class="flex items-center justify-between">
+ <h2 class="text-lg font-semibold">{{ t('organizations.title') }}</h2>
+ <UButton
+ :label="t('organizations.create')"
+ icon="i-lucide-plus"
+ @click="showCreateModal = true"
+ />
+ </div>
+
+ <div v-if="orgStore.loading" class="flex justify-center py-8">
+ <UIcon name="i-lucide-loader-2" class="animate-spin size-6" />
+ </div>
+
+ <div v-else-if="orgStore.organizations.length === 0" class="text-center py-8 text-dimmed">
+ {{ t('organizations.empty') }}
+ </div>
+
+ <div v-else class="flex flex-col gap-3">
+ <UCard
+ v-for="org in orgStore.organizations"
+ :key="org.id"
+ class="cursor-pointer hover:ring-primary transition-all"
+ @click="selectOrg(org)"
+ >
+ <div class="flex items-center justify-between">
+ <div class="flex items-center gap-3">
+ <UIcon name="i-lucide-building-2" class="size-5 text-dimmed" />
+ <div>
+ <p class="font-medium">{{ org.name }}</p>
+ <p class="text-sm text-dimmed">{{ org.slug }}</p>
+ </div>
+ </div>
+ <UIcon name="i-lucide-chevron-right" class="size-4 text-dimmed" />
+ </div>
+ </UCard>
+ </div>
+
+ <OrgCreateModal v-model="showCreateModal" @created="onOrgCreated" />
+ <OrgDetailModal v-model="showDetailModal" :organization="selectedOrg" />
+ </div>
+</template>
+
+<script setup lang="ts">
+import { ref, onMounted } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useOrganizationStore } from '@/stores/organization.store'
+import OrgCreateModal from './parts/OrgCreateModal.vue'
+import OrgDetailModal from './parts/OrgDetailModal.vue'
+
+const { t } = useI18n()
+const orgStore = useOrganizationStore()
+
+const showCreateModal = ref(false)
+const showDetailModal = ref(false)
+const selectedOrg = ref<any>(null)
+
+onMounted(() => {
+ orgStore.fetchOrganizations()
+})
+
+function selectOrg(org: any) {
+ selectedOrg.value = org
+ showDetailModal.value = true
+}
+
+function onOrgCreated() {
+ showCreateModal.value = false
+}
+</script>
diff --git a/web/src/components/features/organizations/parts/OrgCreateModal.vue b/web/src/components/features/organizations/parts/OrgCreateModal.vue
new file mode 100644
index 0000000..454a477
--- /dev/null
+++ b/web/src/components/features/organizations/parts/OrgCreateModal.vue
@@ -0,0 +1,64 @@
+<template>
+ <UModal v-model:open="open" :fullscreen="isMobile">
+ <template #content>
+ <UCard>
+ <template #header>
+ <div class="flex items-center justify-between">
+ <h3 class="font-semibold">{{ t('organizations.create') }}</h3>
+ <UButton icon="i-lucide-x" variant="ghost" color="neutral" @click="open = false" />
+ </div>
+ </template>
+
+ <div class="flex flex-col gap-4">
+ <UFormField :label="t('organizations.name')">
+ <UInput
+ v-model="name"
+ :placeholder="t('organizations.namePlaceholder')"
+ autofocus
+ class="w-full"
+ />
+ </UFormField>
+ </div>
+
+ <template #footer>
+ <div class="flex justify-end gap-2">
+ <UButton :label="t('organizations.save')" :loading="loading" @click="create" />
+ </div>
+ </template>
+ </UCard>
+ </template>
+ </UModal>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useOrganizationStore } from '@/stores/organization.store'
+import { useTaskView } from '@/composables/useTaskView'
+
+const open = defineModel<boolean>({ default: false })
+const emit = defineEmits<{ created: [] }>()
+
+const { t } = useI18n()
+const toast = useToast()
+const { isMobile } = useTaskView()
+const orgStore = useOrganizationStore()
+
+const name = ref('')
+const loading = ref(false)
+
+async function create() {
+ if (!name.value.trim()) return
+ loading.value = true
+ try {
+ const org = await orgStore.createOrganization(name.value.trim())
+ if (org) {
+ toast.add({ title: t('organizations.created'), color: 'success' })
+ name.value = ''
+ emit('created')
+ }
+ } finally {
+ loading.value = false
+ }
+}
+</script>
diff --git a/web/src/components/features/organizations/parts/OrgDetailModal.vue b/web/src/components/features/organizations/parts/OrgDetailModal.vue
new file mode 100644
index 0000000..ee606ff
--- /dev/null
+++ b/web/src/components/features/organizations/parts/OrgDetailModal.vue
@@ -0,0 +1,180 @@
+<template>
+ <UModal v-model:open="open" :fullscreen="isMobile" :ui="{ content: 'max-w-lg' }">
+ <template #content>
+ <UCard v-if="organization">
+ <template #header>
+ <div class="flex items-center justify-between">
+ <h3 class="font-semibold">{{ organization.name }}</h3>
+ <UButton icon="i-lucide-x" variant="ghost" color="neutral" @click="open = false" />
+ </div>
+ </template>
+
+ <UTabs :items="tabs" class="w-full">
+ <template #general>
+ <div class="flex flex-col gap-4 pt-4">
+ <UFormField :label="t('organizations.name')">
+ <UInput v-model="editName" class="w-full" />
+ </UFormField>
+ <UFormField :label="t('organizations.slug')">
+ <UInput v-model="editSlug" :placeholder="t('organizations.slugPlaceholder')" class="w-full" />
+ </UFormField>
+ <UButton :label="t('organizations.save')" :loading="saving" @click="save" />
+ </div>
+ </template>
+
+ <template #members>
+ <div class="flex flex-col gap-4 pt-4">
+ <div class="flex gap-2">
+ <UInput
+ v-model="newMemberEmail"
+ :placeholder="t('organizations.email')"
+ class="flex-1"
+ />
+ <UButton
+ :label="t('organizations.addMember')"
+ :loading="addingMember"
+ @click="addMember"
+ />
+ </div>
+
+ <div class="flex flex-col gap-2">
+ <div
+ v-for="member in orgStore.members"
+ :key="member.id"
+ class="flex items-center justify-between p-2 rounded-md bg-elevated"
+ >
+ <div>
+ <p class="text-sm font-medium">{{ member.email }}</p>
+ <p class="text-xs text-dimmed">{{ t(`organizations.${member.role}`) }}</p>
+ </div>
+ <div v-if="member.role !== 'owner'" class="flex items-center gap-1">
+ <USelect
+ :model-value="member.role"
+ :items="roleOptions"
+ size="xs"
+ @update:model-value="(val: string) => updateRole(member.email, val)"
+ />
+ <UButton
+ icon="i-lucide-x"
+ size="xs"
+ variant="ghost"
+ color="error"
+ @click="removeMember(member.email)"
+ />
+ </div>
+ </div>
+ </div>
+ </div>
+ </template>
+ </UTabs>
+
+ <template #footer>
+ <div class="flex justify-between">
+ <UButton
+ :label="t('organizations.delete')"
+ color="error"
+ variant="ghost"
+ icon="i-lucide-trash-2"
+ @click="deleteOrg"
+ />
+ <UButton :label="t('organizations.save')" variant="ghost" @click="open = false" />
+ </div>
+ </template>
+ </UCard>
+ </template>
+ </UModal>
+</template>
+
+<script setup lang="ts">
+import { ref, watch, computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useOrganizationStore } from '@/stores/organization.store'
+import { useTaskView } from '@/composables/useTaskView'
+
+const open = defineModel<boolean>({ default: false })
+const props = defineProps<{
+ organization: any
+}>()
+
+const { t } = useI18n()
+const toast = useToast()
+const { isMobile } = useTaskView()
+const orgStore = useOrganizationStore()
+
+const editName = ref('')
+const editSlug = ref('')
+const newMemberEmail = ref('')
+const saving = ref(false)
+const addingMember = ref(false)
+
+const tabs = computed(() => [
+ { label: t('organizations.general'), slot: 'general' },
+ { label: t('organizations.members'), slot: 'members' },
+])
+
+const roleOptions = [
+ { label: 'Admin', value: 'admin' },
+ { label: 'Member', value: 'member' },
+]
+
+watch(() => props.organization, (org) => {
+ if (org) {
+ editName.value = org.name
+ editSlug.value = org.slug
+ orgStore.fetchMembers(org.id)
+ }
+}, { immediate: true })
+
+async function save() {
+ if (!props.organization) return
+ saving.value = true
+ try {
+ const result = await orgStore.updateOrganization(props.organization.id, {
+ name: editName.value,
+ slug: editSlug.value,
+ })
+ if (result) {
+ toast.add({ title: t('organizations.updated'), color: 'success' })
+ } else {
+ toast.add({ title: t('organizations.slugTaken'), color: 'error' })
+ }
+ } finally {
+ saving.value = false
+ }
+}
+
+async function addMember() {
+ if (!newMemberEmail.value.trim() || !props.organization) return
+ addingMember.value = true
+ try {
+ const result = await orgStore.addMember(props.organization.id, newMemberEmail.value.trim())
+ if (result) {
+ toast.add({ title: t('organizations.memberAdded'), color: 'success' })
+ newMemberEmail.value = ''
+ }
+ } finally {
+ addingMember.value = false
+ }
+}
+
+async function updateRole(email: string, role: string) {
+ if (!props.organization) return
+ await orgStore.updateMemberRole(props.organization.id, email, role)
+ toast.add({ title: t('organizations.roleUpdated'), color: 'success' })
+}
+
+async function removeMember(email: string) {
+ if (!props.organization) return
+ await orgStore.removeMember(props.organization.id, email)
+ toast.add({ title: t('organizations.memberRemoved'), color: 'success' })
+}
+
+async function deleteOrg() {
+ if (!props.organization) return
+ const result = await orgStore.deleteOrganization(props.organization.id)
+ if (result) {
+ toast.add({ title: t('organizations.deleted'), color: 'success' })
+ open.value = false
+ }
+}
+</script>
diff --git a/web/src/components/features/projects/ProjectsSidebar.vue b/web/src/components/features/projects/ProjectsSidebar.vue
index a2d8feb..dd18aa5 100644
--- a/web/src/components/features/projects/ProjectsSidebar.vue
+++ b/web/src/components/features/projects/ProjectsSidebar.vue
@@ -17,10 +17,11 @@
</template>
<script setup lang="ts">
-import { computed, onMounted } from 'vue'
+import { computed, onMounted, watch } from 'vue'
import { storeToRefs } from 'pinia'
import { useRouter } from 'vue-router'
import { useGoalsStore } from '@/stores/goals.store'
+import { useOrganizationStore } from '@/stores/organization.store'
import ProjectsList from '@/components/features/projects/ProjectsList.vue'
import ArchiveList from '@/components/features/projects/ArchiveList.vue'
import type { Project } from '@/components/features/projects/types'
@@ -29,6 +30,7 @@ import { ALL_TASKS_LIST_ID } from 'taskview-api'
const router = useRouter()
const goalsStore = useGoalsStore()
+const orgStore = useOrganizationStore()
const { goals } = storeToRefs(goalsStore)
const activeProjects = computed(() => goals.value.filter(p => p.archive === 0))
@@ -38,6 +40,11 @@ onMounted(async () => {
await goalsStore.fetchGoals()
})
+watch(() => orgStore.currentOrg, async () => {
+ goalsStore.initialized = false
+ await goalsStore.fetchGoals()
+})
+
async function handleSave(project: Project, data: { name: string; description: string }) {
await goalsStore.updateGoal({
id: project.id,
@@ -65,7 +72,10 @@ async function handleRestore(project: Project) {
}
async function handleAdd(name: string) {
- const newProject = await goalsStore.addGoal({ name })
+ const newProject = await goalsStore.addGoal({
+ name,
+ ...(orgStore.currentOrg && { organizationId: orgStore.currentOrg.id }),
+ })
if (newProject) {
router.push({ name: 'user', params: { projectId: newProject.id, listId: ALL_TASKS_LIST_ID } })
}
diff --git a/web/src/layouts/UserLayout.vue b/web/src/layouts/UserLayout.vue
index e82782a..229fef3 100644
--- a/web/src/layouts/UserLayout.vue
+++ b/web/src/layouts/UserLayout.vue
@@ -51,6 +51,7 @@ import { useCentrifugo } from '@/composables/useCentrifugo'
import { usePushNotifications } from '@/composables/usePushNotifications'
import { useGoalsStore } from '@/stores/goals.store'
import { useUserStore } from '@/stores/user.store'
+import { useOrganizationStore } from '@/stores/organization.store'
const { isSidebarOpen, isSidebarCollapsed } = useDashboard()
const { connect: connectCentrifugo } = useCentrifugo()
@@ -59,6 +60,7 @@ const { t } = useI18n()
const appStore = useAppStore()
const goalsStore = useGoalsStore()
const userStore = useUserStore()
+const orgStore = useOrganizationStore()
const route = useRoute()
const router = useRouter()
@@ -100,6 +102,9 @@ onMounted(async () => {
connectCentrifugo()
initPush()
+ await orgStore.fetchOrganizations()
+ orgStore.restoreCurrentOrg()
+
await CapacitorUpdater.notifyAppReady()
console.log('notifyAppReady', APP_VERSION)
diff --git a/web/src/locales/en.ts b/web/src/locales/en.ts
index 46bdcd2..38eb6e8 100644
--- a/web/src/locales/en.ts
+++ b/web/src/locales/en.ts
@@ -429,6 +429,8 @@ export default {
github: 'GitHub repository',
docker: 'Docker Images',
accountSettings: 'Account settings',
+ organizations: 'Organizations',
+ switchOrganization: 'Switch organization',
logout: 'Log out',
logoutFailed: 'Logout failed',
logoutFailedDescription: 'Try clearing browser cache to remove the authorization token',
@@ -445,6 +447,35 @@ export default {
deleted: 'Account deleted',
codeSendError: 'Unable to send the code. Please contact support to delete your account.',
},
+ organizations: {
+ title: 'Organizations',
+ create: 'Create organization',
+ name: 'Name',
+ namePlaceholder: 'e.g. My Team',
+ slug: 'Slug',
+ slugPlaceholder: 'my-team',
+ members: 'Members',
+ addMember: 'Add member',
+ email: 'Email',
+ role: 'Role',
+ owner: 'Owner',
+ admin: 'Admin',
+ member: 'Member',
+ remove: 'Remove',
+ delete: 'Delete organization',
+ deleteConfirm: 'Are you sure you want to delete this organization and all its projects?',
+ empty: 'No organizations yet',
+ settings: 'Settings',
+ general: 'General',
+ save: 'Save',
+ created: 'Organization created',
+ updated: 'Organization updated',
+ deleted: 'Organization deleted',
+ memberAdded: 'Member added',
+ memberRemoved: 'Member removed',
+ roleUpdated: 'Role updated',
+ slugTaken: 'This slug is already taken',
+ },
apiTokens: {
title: 'API Tokens',
description: 'Create tokens to access the API programmatically.',
diff --git a/web/src/locales/ru.ts b/web/src/locales/ru.ts
index b5d3a10..475ba66 100644
--- a/web/src/locales/ru.ts
+++ b/web/src/locales/ru.ts
@@ -401,6 +401,8 @@ export default {
github: 'GitHub репозиторий',
docker: 'Docker образы',
accountSettings: 'Настройки аккаунта',
+ organizations: 'Организации',
+ switchOrganization: 'Переключить организацию',
logout: 'Выйти',
logoutFailed: 'Не удалось выйти',
logoutFailedDescription: 'Попробуйте очистить кэш браузера, чтобы удалить токен авторизации',
@@ -417,6 +419,35 @@ export default {
deleted: 'Аккаунт удалён',
codeSendError: 'Не удалось отправить код. Обратитесь в поддержку для удаления аккаунта.',
},
+ organizations: {
+ title: 'Организации',
+ create: 'Создать организацию',
+ name: 'Название',
+ namePlaceholder: 'напр. Моя команда',
+ slug: 'Slug',
+ slugPlaceholder: 'my-team',
+ members: 'Участники',
+ addMember: 'Добавить участника',
+ email: 'Email',
+ role: 'Роль',
+ owner: 'Владелец',
+ admin: 'Админ',
+ member: 'Участник',
+ remove: 'Удалить',
+ delete: 'Удалить организацию',
+ deleteConfirm: 'Вы уверены что хотите удалить эту организацию и все её проекты?',
+ empty: 'Нет организаций',
+ settings: 'Настройки',
+ general: 'Основные',
+ save: 'Сохранить',
+ created: 'Организация создана',
+ updated: 'Организация обновлена',
+ deleted: 'Организация удалена',
+ memberAdded: 'Участник добавлен',
+ memberRemoved: 'Участник удалён',
+ roleUpdated: 'Роль обновлена',
+ slugTaken: 'Этот slug уже занят',
+ },
notifications: {
title: 'Уведомления',
empty: 'Нет уведомлений',
diff --git a/web/src/main.ts b/web/src/main.ts
index c71032f..38fa068 100644
--- a/web/src/main.ts
+++ b/web/src/main.ts
@@ -74,6 +74,11 @@ const router = createRouter({
name: 'account',
component: () => import('./pages/user/account.vue'),
},
+ {
+ path: 'organizations',
+ name: 'organizations',
+ component: () => import('./pages/user/organizations.vue'),
+ },
{
path: ':projectId?/:listId?/:taskId?',
name: 'user',
diff --git a/web/src/pages/user/organizations.vue b/web/src/pages/user/organizations.vue
new file mode 100644
index 0000000..a4d7297
--- /dev/null
+++ b/web/src/pages/user/organizations.vue
@@ -0,0 +1,21 @@
+<template>
+ <UDashboardPanel id="organizations">
+ <template #header>
+ <UDashboardNavbar :title="t('organizations.title')">
+ <template #leading>
+ <UDashboardSidebarCollapse />
+ </template>
+ </UDashboardNavbar>
+ </template>
+ <template #body>
+ <OrganizationsPanel />
+ </template>
+ </UDashboardPanel>
+</template>
+
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import OrganizationsPanel from '@/components/features/organizations/OrganizationsPanel.vue'
+
+const { t } = useI18n()
+</script>
diff --git a/web/src/stores/base-screen.store.ts b/web/src/stores/base-screen.store.ts
index 124e5b2..8860132 100644
--- a/web/src/stores/base-screen.store.ts
+++ b/web/src/stores/base-screen.store.ts
@@ -13,6 +13,7 @@ import {
} from '@/types/base-screen.types'
import type { AppResponse } from '@/types/global-app.types'
import type { TaskItem } from '@/types/tasks.types'
+import { useOrganizationStore } from '@/stores/organization.store'
export const useBaseScreenStore = defineStore('base-screen-store', {
getters: {
@@ -48,9 +49,14 @@ export const useBaseScreenStore = defineStore('base-screen-store', {
async fetchAllState() {
this.taskIdToUser = {}
this.loading = true
+ const orgStore = useOrganizationStore()
+ const params = new URLSearchParams({ tz: Intl.DateTimeFormat().resolvedOptions().timeZone })
+ if (orgStore.currentOrg) {
+ params.set('organizationId', String(orgStore.currentOrg.id))
+ }
const result = await $api
.get<AppResponse<MainScreenAllStateResponse>>(
- `/module/about/fetchallstate?tz=${encodeURIComponent(Intl.DateTimeFormat().resolvedOptions().timeZone)}`,
+ `/module/about/fetchallstate?${params.toString()}`,
)
.catch((err) => console.log(err))
@@ -80,8 +86,13 @@ export const useBaseScreenStore = defineStore('base-screen-store', {
},
async fetchAllAvailableLists() {
+ const orgStore = useOrganizationStore()
+ const params: Record<string, string> = {}
+ if (orgStore.currentOrg) {
+ params.organizationId = String(orgStore.currentOrg.id)
+ }
const result = await $api
- .get<AppResponse<GoalAndListsResp>>('/module/about/fetch/lists')
+ .get<AppResponse<GoalAndListsResp>>('/module/about/fetch/lists', { params })
.catch((err) => console.log(err))
if (result) {
this.lists = result.data.response
@@ -183,8 +194,13 @@ export const useBaseScreenStore = defineStore('base-screen-store', {
},
async searchTaskRequest(taskDescription: string): Promise<BaseScreenSearchResponse> {
+ const orgStore = useOrganizationStore()
+ const params = new URLSearchParams({ description: taskDescription })
+ if (orgStore.currentOrg) {
+ params.set('organizationId', String(orgStore.currentOrg.id))
+ }
const result = await $api
- .get<AppResponse<BaseScreenSearchResponse>>(`/module/about/search-task?description=${taskDescription}`)
+ .get<AppResponse<BaseScreenSearchResponse>>(`/module/about/search-task?${params.toString()}`)
.catch(logError)
if (!result) return []
return result.data.response
diff --git a/web/src/stores/collaboration.store.ts b/web/src/stores/collaboration.store.ts
index cf406d8..7c777ec 100644
--- a/web/src/stores/collaboration.store.ts
+++ b/web/src/stores/collaboration.store.ts
@@ -7,6 +7,7 @@ import type {
} from 'taskview-api'
import { $tvApi } from '@/plugins/axios'
import type { CollaborationStore } from '@/types/collaboration.types'
+import { useOrganizationStore } from './organization.store'
export const useCollaborationStore = defineStore('collaboration', {
state(): CollaborationStore {
@@ -29,7 +30,8 @@ export const useCollaborationStore = defineStore('collaboration', {
* in the assignees section for tasks
*/
async fetchAllCollaborationUsers(): Promise<void> {
- const users = await $tvApi.collaboration.fetchAllUsers()
+ const orgStore = useOrganizationStore()
+ const users = await $tvApi.collaboration.fetchAllUsers(orgStore.currentOrg?.id)
if (!users) return
this.allUsers = users
},
diff --git a/web/src/stores/goals.store.ts b/web/src/stores/goals.store.ts
index 8c85033..060cddd 100644
--- a/web/src/stores/goals.store.ts
+++ b/web/src/stores/goals.store.ts
@@ -3,6 +3,7 @@ import type { GoalArgItemAdd, GoalArgItemUpdate, GoalItem } from 'taskview-api'
import { $tvApi } from '@/plugins/axios'
import type { GoalsStoreState } from '@/types/goals.types'
import { useUserStore } from './user.store'
+import { useOrganizationStore } from './organization.store'
export const useGoalsStore = defineStore('goals', {
state: (): GoalsStoreState => ({
@@ -35,7 +36,8 @@ export const useGoalsStore = defineStore('goals', {
async fetchGoals(): Promise<void> {
if (this.loading) return
this.loading = true
- const result = await $tvApi.goals.fetchGoals()
+ const orgStore = useOrganizationStore()
+ const result = await $tvApi.goals.fetchGoals(orgStore.currentOrg?.id)
if (!result) {
this.loading = false
return
diff --git a/web/src/stores/notifications.store.ts b/web/src/stores/notifications.store.ts
index 9c6a8fe..050a6c6 100644
--- a/web/src/stores/notifications.store.ts
+++ b/web/src/stores/notifications.store.ts
@@ -1,6 +1,7 @@
import { defineStore } from 'pinia'
import type { Notification } from 'taskview-api'
import { $tvApi } from '@/plugins/axios'
+import { useOrganizationStore } from './organization.store'
interface NotificationsState {
notifications: Notification[]
@@ -26,8 +27,9 @@ export const useNotificationsStore = defineStore('notifications', {
this.loading = true
try {
+ const orgStore = useOrganizationStore()
const cursor = reset ? undefined : this.notifications.at(-1)?.id
- const result = await $tvApi.notifications.fetch(cursor)
+ const result = await $tvApi.notifications.fetch(cursor, orgStore.currentOrg?.id)
if (result) {
if (reset) {
this.notifications = result.notifications
@@ -52,7 +54,8 @@ export const useNotificationsStore = defineStore('notifications', {
},
async markAllRead() {
- const result = await $tvApi.notifications.markAllRead()
+ const orgStore = useOrganizationStore()
+ const result = await $tvApi.notifications.markAllRead(orgStore.currentOrg?.id)
if (result) {
this.notifications.forEach(n => { n.read = true })
}
diff --git a/web/src/stores/organization.store.ts b/web/src/stores/organization.store.ts
new file mode 100644
index 0000000..3b7c4bb
--- /dev/null
+++ b/web/src/stores/organization.store.ts
@@ -0,0 +1,146 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { Organization, OrgMember } from 'taskview-api'
+import { $tvApi } from '@/plugins/axios'
+
+export const useOrganizationStore = defineStore('organization', () => {
+ const organizations = ref<Organization[]>([])
+ const currentOrg = ref<Organization | null>(null)
+ const members = ref<OrgMember[]>([])
+ const loading = ref(false)
+
+ async function fetchOrganizations() {
+ loading.value = true
+ try {
+ const result = await $tvApi.organizations.fetch()
+ organizations.value = result ?? []
+ } catch {
+ organizations.value = []
+ } finally {
+ loading.value = false
+ }
+ }
+
+ async function createOrganization(name: string, slug?: string) {
+ try {
+ const org = await $tvApi.organizations.create({ name, slug })
+ if (org) {
+ organizations.value.push(org)
+ }
+ return org
+ } catch {
+ return null
+ }
+ }
+
+ async function updateOrganization(id: number, updates: { name?: string, slug?: string, logoUrl?: string | null }) {
+ try {
+ const org = await $tvApi.organizations.update({ organizationId: id, ...updates })
+ if (org) {
+ const idx = organizations.value.findIndex(o => o.id === id)
+ if (idx !== -1) organizations.value[idx] = org
+ if (currentOrg.value?.id === id) currentOrg.value = org
+ }
+ return org
+ } catch {
+ return null
+ }
+ }
+
+ async function deleteOrganization(id: number) {
+ try {
+ const result = await $tvApi.organizations.delete({ organizationId: id })
+ if (result) {
+ organizations.value = organizations.value.filter(o => o.id !== id)
+ if (currentOrg.value?.id === id) currentOrg.value = null
+ }
+ return result
+ } catch {
+ return false
+ }
+ }
+
+ async function fetchMembers(orgId: number) {
+ try {
+ const result = await $tvApi.organizations.fetchMembers(orgId)
+ members.value = result ?? []
+ return members.value
+ } catch {
+ members.value = []
+ return []
+ }
+ }
+
+ async function addMember(organizationId: number, email: string, role: 'admin' | 'member' = 'member') {
+ try {
+ const member = await $tvApi.organizations.addMember({ organizationId, email, role })
+ if (member) {
+ members.value.push(member)
+ }
+ return member
+ } catch {
+ return null
+ }
+ }
+
+ async function updateMemberRole(organizationId: number, email: string, role: 'admin' | 'member') {
+ try {
+ const updated = await $tvApi.organizations.updateMemberRole({ organizationId, email, role })
+ if (updated) {
+ const idx = members.value.findIndex(m => m.email === email && m.organizationId === organizationId)
+ if (idx !== -1) members.value[idx] = updated
+ }
+ return updated
+ } catch {
+ return null
+ }
+ }
+
+ async function removeMember(organizationId: number, email: string) {
+ try {
+ const result = await $tvApi.organizations.removeMember({ organizationId, email })
+ if (result) {
+ members.value = members.value.filter(m => !(m.email === email && m.organizationId === organizationId))
+ }
+ return result
+ } catch {
+ return false
+ }
+ }
+
+ function setCurrentOrg(org: Organization | null) {
+ currentOrg.value = org
+ if (org) {
+ localStorage.setItem('tv_current_org_id', String(org.id))
+ } else {
+ localStorage.removeItem('tv_current_org_id')
+ }
+ }
+
+ function restoreCurrentOrg() {
+ const savedId = localStorage.getItem('tv_current_org_id')
+ if (savedId && organizations.value.length) {
+ const found = organizations.value.find(o => o.id === Number(savedId))
+ currentOrg.value = found ?? organizations.value[0]
+ } else if (organizations.value.length) {
+ currentOrg.value = organizations.value[0]
+ }
+ }
+
+ return {
+ organizations,
+ currentOrg,
+ members,
+ loading,
+ fetchOrganizations,
+ createOrganization,
+ updateOrganization,
+ deleteOrganization,
+ fetchMembers,
+ addMember,
+ updateMemberRole,
+ removeMember,
+ setCurrentOrg,
+ restoreCurrentOrg,
+ }
+})
diff --git a/web/src/stores/tag.store.ts b/web/src/stores/tag.store.ts
index ecf40b6..7cebf33 100644
--- a/web/src/stores/tag.store.ts
+++ b/web/src/stores/tag.store.ts
@@ -3,6 +3,7 @@ import type { TagItemArgAdd, TagItemArgToggle, TagItemArgUpdate, TagItemResponse
import { $tvApi } from '@/plugins/axios'
import type { TagItem, TagsState } from '@/types/tags.types'
import { useGoalsStore } from './goals.store'
+import { useOrganizationStore } from './organization.store'
export const useTagsStore = defineStore('tags', {
state(): TagsState {
@@ -25,9 +26,10 @@ export const useTagsStore = defineStore('tags', {
actions: {
async fetchAllTags(): Promise<void> {
this.loading = true
+ const orgStore = useOrganizationStore()
const tags = await $tvApi.tags
- .fetchAllTagsForUser()
+ .fetchAllTagsForUser(orgStore.currentOrg?.id)
.catch((err) => console.log(err))
.finally(() => {
this.loading = false
diff --git a/web__old/package.json b/web__old/package.json
index 89b3a63..4dd6bca 100644
--- a/web__old/package.json
+++ b/web__old/package.json
@@ -72,7 +72,7 @@
"@vue/test-utils": "^2.2.6",
"@vue/tsconfig": "0.7.0",
"autoprefixer": "^10.4.20",
- "axios": "^1.2.3",
+ "axios": "1.13.5",
"check-password-strength": "^2.0.7",
"eslint": "9.20.1",
"eslint-plugin-vue": "^9.3.0",