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.
TypeScript graphviewkanban-boardnodejsproductivityproject-managementself-hostedtasktask-managementtask-managertodoapp
fix: recurring task
Nikolai Giman9beb2ff9e58d
diff --git a/api/src/core/GoalPermissionsRepository.ts b/api/src/core/GoalPermissionsRepository.tsindex 3f6e084..678de4d 100644--- a/api/src/core/GoalPermissionsRepository.ts+++ b/api/src/core/GoalPermissionsRepository.ts@@ -9,7 +9,7 @@ import {PermissionsSchema,} from 'taskview-db-schemas';import { Database } from '../modules/db';-import type { FetchGoalIdsWithAnyPermissionParams, GoalPermissionItemsFromDb } from '../types/auth.types';+import type { FetchGoalIdsWithAnyPermissionParams, FetchPermissionsForGoalByUserParams, GoalPermissionItemsFromDb } from '../types/auth.types';import type { GoalItemInDb } from '../types/goal.type';import type { ListItemInDb } from '../types/lists.types';import type { TaskItemInDb } from '../types/tasks.types';@@ -33,7 +33,18 @@ export class GoalPermissionsRepository {}async fetchPermissionsForGoal(goalId: number, user: AppUser): Promise<GoalPermissionItemsFromDb> {- const goalInfo = await this.db.query<GoalItemInDb>('select * from tasks.goals where id = $1', [goalId]);+ const userData = user.getUserData();+ if (!userData) return [];+ return this.fetchPermissionsForGoalByUser({ goalId, userId: userData.id, email: userData.email });+ }++ /**+ * Permission set of an arbitrary user for a goal, without an AppUser/request+ * context — used by background workers (e.g. deadline notifications) that+ * must gate content per recipient.+ */+ async fetchPermissionsForGoalByUser(params: FetchPermissionsForGoalByUserParams): Promise<GoalPermissionItemsFromDb> {+ const goalInfo = await this.db.query<GoalItemInDb>('select * from tasks.goals where id = $1', [params.goalId]);if (goalInfo.rows.length === 0) {return [];@@ -42,7 +53,7 @@ export class GoalPermissionsRepository {let query = '';let args: any = [];- if (goalInfo.rows[0].owner === user.getUserData()?.id) {+ if (goalInfo.rows[0].owner === params.userId) {query = `select name as "permissionName", id as "permissionId" from tv_auth.permissions;`;} else {query = `select p.name as "permissionName", p.id as "permissionId"@@ -54,7 +65,7 @@ export class GoalPermissionsRepository {left join collaboration.permissions_to_role ptr on rol.id = ptr.role_idleft join tv_auth.permissions p on ptr.permission_id = p.idwhere email = $1 and tg.id = $2 and p.name is not null and p.id is not null;`;- args = [user.getUserData()?.email, goalId];+ args = [params.email, params.goalId];}const result = await this.db.query<GoalPermissionItemsFromDb[number]>(query, args);diff --git a/api/src/migrations/taskview/migrate.json b/api/src/migrations/taskview/migrate.jsonindex 26cb972..b92cefc 100644--- a/api/src/migrations/taskview/migrate.json+++ b/api/src/migrations/taskview/migrate.json@@ -618,5 +618,27 @@"Extended tasks.tasks with recurrence_rule_id (FK SET NULL — instances survive rule deletion) and recurrence_instance_date. Partial unique index on (recurrence_rule_id, recurrence_instance_date) makes instance materialization idempotent under concurrent triggers/reconciliation.","Exactly one open instance per series exists at any time: completing it materializes the next occurrence (event-driven, O(1)); a nightly pg-boss reconcile job re-creates the open instance only for series stalled by a crash. No new permissions — recurrence editing is gated by existing task_can_edit_deadline."]+ },+ "48": {+ "version": "1.54.1",+ "name": "Release 1.54.1",+ "releaseDate": "20260613",+ "scripts": [+ "/1.54.1/0.add-recurrence-template-task-unique.sql"+ ],+ "description": [+ "Partial unique index on tasks.recurrence_rules(template_task_id) WHERE state != 'ended' — one live series per origin task. DB-level backstop for the createRule race where two concurrent POSTs both pass the recurrenceRuleId == null check and create two rules for the same task (the orphaned rule would materialize a duplicate card via the nightly reconcile job)."+ ]+ },+ "49": {+ "version": "1.54.2",+ "name": "Release 1.54.2",+ "releaseDate": "20260613",+ "scripts": [+ "/1.54.2/0.add-recurrence-has-time.sql"+ ],+ "description": [+ "Added tasks.recurrence_rules.has_time — explicit flag for whether a series is anchored to a wall-clock time or is date-only. Previously the code inferred 'no time' from a midnight dtstart, which silently collapsed an explicit 00:00 series into date-only. Backfill (has_time = dtstart::time <> '00:00:00') reproduces the old inference so existing series keep their behavior; new series carry the flag through from the origin task's start_time (null = date-only, set = timed, including midnight)."+ ]}}\ No newline at end of filediff --git a/api/src/migrations/taskview/sql/1.54.1/0.add-recurrence-template-task-unique.sql b/api/src/migrations/taskview/sql/1.54.1/0.add-recurrence-template-task-unique.sqlnew file mode 100644index 0000000..4adc6c6--- /dev/null+++ b/api/src/migrations/taskview/sql/1.54.1/0.add-recurrence-template-task-unique.sql@@ -0,0 +1,7 @@+-- One live series per origin task: DB-level backstop for the createRule race+-- where two concurrent POSTs both pass the recurrenceRuleId == null check and+-- insert two rules for the same task. Ended series keep their row but release+-- the slot (the origin task itself stays attached to the ended rule anyway).+CREATE UNIQUE INDEX IF NOT EXISTS uniq_recurrence_rules_template_task+ ON tasks.recurrence_rules(template_task_id)+ WHERE state != 'ended';diff --git a/api/src/migrations/taskview/sql/1.54.2/0.add-recurrence-has-time.sql b/api/src/migrations/taskview/sql/1.54.2/0.add-recurrence-has-time.sqlnew file mode 100644index 0000000..5dbe2fc--- /dev/null+++ b/api/src/migrations/taskview/sql/1.54.2/0.add-recurrence-has-time.sql@@ -0,0 +1,13 @@+-- A series anchored to a wall-clock time (incl. exactly 00:00) vs a date-only+-- series ("every day", no time) used to be told apart by inspecting dtstart:+-- midnight meant "no time". That collapses an explicit midnight into date-only.+-- Store the distinction explicitly instead.+ALTER TABLE tasks.recurrence_rules+ ADD COLUMN IF NOT EXISTS has_time BOOLEAN NOT NULL DEFAULT FALSE;++-- Backfill reproduces the old inference exactly: any series whose dtstart+-- carries a non-midnight wall-clock time was a timed series. Existing+-- midnight/date-only series keep has_time = FALSE — no behavior change.+UPDATE tasks.recurrence_rules+ SET has_time = TRUE+ WHERE dtstart::time <> '00:00:00';diff --git a/api/src/tv-modules/kanban/KanbanRepository.ts b/api/src/tv-modules/kanban/KanbanRepository.tsindex 86e1848..839bf33 100644--- a/api/src/tv-modules/kanban/KanbanRepository.ts+++ b/api/src/tv-modules/kanban/KanbanRepository.ts@@ -3,7 +3,7 @@ import { Database } from '../../modules/db';import type { GoalItemInDb } from '../../types/goal.type';import { logError } from '../../utils/api';import { updateQuery } from '../../utils/db-helper';-import type { KanbanStatusItemInDb } from './types';+import type { KanbanStatusItemInDb, StatusBelongsToGoalArgs } from './types';import { callWithCatch } from '../../utils/helpers';import { and, asc, eq, gt, gte, isNull, lt, lte, sql } from 'drizzle-orm';import type { TaskItemInDb } from '../../types/tasks.types';@@ -218,4 +218,14 @@ export class KanbanRepository {return result?.[0]?.columnVersion ?? null;}++ /** Validates payload references to a kanban column from other modules (recurrence templates, etc.). */+ async statusBelongsToGoal(args: StatusBelongsToGoalArgs): Promise<boolean> {+ const result = await callWithCatch(() => this.db.dbDrizzle+ .select({ id: TasksStatusesSchema.id })+ .from(TasksStatusesSchema)+ .where(and(eq(TasksStatusesSchema.id, args.statusId), eq(TasksStatusesSchema.goalId, args.goalId)))+ .limit(1));+ return !!result?.[0];+ }}diff --git a/api/src/tv-modules/kanban/types.ts b/api/src/tv-modules/kanban/types.tsindex 45058df..e169f6a 100644--- a/api/src/tv-modules/kanban/types.ts+++ b/api/src/tv-modules/kanban/types.ts@@ -33,6 +33,8 @@ export type KanbanArgUpdateStatus = typeof KanbanArkTypeStatusUpdate.infer;export type KanbanArgFetchAllStatuses = typeof KanbanArkTypeFetchAllStatuses.infer;+export type StatusBelongsToGoalArgs = { statusId: number; goalId: number };+export type KanbanStatusInDb = {id: number;goal_id: number;diff --git a/api/src/tv-modules/lists/GoalListsRepository.ts b/api/src/tv-modules/lists/GoalListsRepository.tsindex 7938d50..8bd0c08 100644--- a/api/src/tv-modules/lists/GoalListsRepository.ts+++ b/api/src/tv-modules/lists/GoalListsRepository.ts@@ -1,4 +1,4 @@-import { desc, eq } from 'drizzle-orm';+import { and, desc, eq } from 'drizzle-orm';import type { GoalsListSchemaTypeForSelect } from 'taskview-db-schemas';import { GoalsListSchema } from 'taskview-db-schemas';import type { AppUser } from '../../core/AppUser';@@ -7,7 +7,7 @@ import type { GoalListInDb } from '../../types/goal-list.types';import { logError } from '../../utils/api';import { updateQuery } from '../../utils/db-helper';import { callWithCatch } from '../../utils/helpers';-import type { GoalListArgAdd, GoalListArgDelete, GoalListArgFetch, GoalListArgUpdate } from './list.types';+import type { GoalListArgAdd, GoalListArgDelete, GoalListArgFetch, GoalListArgUpdate, ListBelongsToGoalArgs } from './list.types';export class GoalListsRepository {private readonly db: Database;@@ -145,4 +145,16 @@ export class GoalListsRepository {return !!(result.rowCount && result.rowCount > 0);}++ /** Validates payload references to a list from other modules (recurrence templates, etc.). */+ async listBelongsToGoal(args: ListBelongsToGoalArgs): Promise<boolean> {+ const result = await callWithCatch(() =>+ this.db.dbDrizzle+ .select({ id: GoalsListSchema.id })+ .from(GoalsListSchema)+ .where(and(eq(GoalsListSchema.id, args.listId), eq(GoalsListSchema.goalId, args.goalId)))+ .limit(1)+ );+ return !!result?.[0];+ }}diff --git a/api/src/tv-modules/lists/list.types.ts b/api/src/tv-modules/lists/list.types.tsindex 4f69c6d..f5fe63c 100644--- a/api/src/tv-modules/lists/list.types.ts+++ b/api/src/tv-modules/lists/list.types.ts@@ -27,3 +27,5 @@ export const GoalListArkTypeFetch = type({});export type GoalListArgFetch = typeof GoalListArkTypeFetch.infer;++export type ListBelongsToGoalArgs = { listId: number; goalId: number };diff --git a/api/src/tv-modules/notifications/NotificationMessages.ts b/api/src/tv-modules/notifications/NotificationMessages.tsindex 359921c..219bd5b 100644--- a/api/src/tv-modules/notifications/NotificationMessages.ts+++ b/api/src/tv-modules/notifications/NotificationMessages.ts@@ -3,7 +3,8 @@ import { parseUtcTime } from './utils';export class NotificationMessages {static deadline(description: string | null, endDate: string, endTime: string | null, timezone: string): NotificationMessage {- const title = `Task: ${description || 'Task'}`;+ // description is null for recipients without COMPONENT_CAN_WATCH_CONTENT+ const title = description ? `Task: ${description}` : 'Task deadline';if (endTime) {const deadline = parseUtcTime(endDate, endTime);diff --git a/api/src/tv-modules/notifications/schedulers/DeadlineScheduler.ts b/api/src/tv-modules/notifications/schedulers/DeadlineScheduler.tsindex 2d37b1a..fee0519 100644--- a/api/src/tv-modules/notifications/schedulers/DeadlineScheduler.ts+++ b/api/src/tv-modules/notifications/schedulers/DeadlineScheduler.ts@@ -1,13 +1,16 @@-import { eq, and, or, isNull } from 'drizzle-orm';+import { eq, and, or, isNull, inArray } from 'drizzle-orm';import { alias } from 'drizzle-orm/pg-core';import { TasksSchema, TasksAssigneeSchema, GoalsSchema, CollaborationUsersSchema, UsersSchema } from 'taskview-db-schemas';import { getJobQueue, cancelJobBySingletonKey } from '../../../core/JobQueue';+import { GoalPermissionsChecker } from '../../../core/GoalPermissionsChecker';+import { GoalPermissionsRepository } from '../../../core/GoalPermissionsRepository';import { Database } from '../../../modules/db';import { $logger } from '../../../modules/logget';+import { GoalPermissions } from '../../../types/auth.types';import { getNotificationService } from '../NotificationService';import { NotificationMessages } from '../NotificationMessages';import { DeviceTokensRepository } from '../repositories/DeviceTokensRepository';-import { NotificationType, type DeadlineJobData, type TaskWithDeadline } from '../types';+import { NotificationType, type DeadlineJobData, type DeadlineRecipient, type TaskWithDeadline } from '../types';import { parseUtcTime, localHourToUtc } from '../utils';const DEADLINE_JOB = 'deadline-notification';@@ -86,31 +89,36 @@ export class DeadlineScheduler {return;}- const recipientIds = await this.resolveRecipients(db, taskId, goalId, task[0].owner);- if (!recipientIds || recipientIds.length === 0) {+ let recipients = await this.resolveRecipients(db, taskId, goalId, task[0].owner);+ if (!recipients || recipients.length === 0) {$logger.info(`[DeadlineScheduler] Task ${taskId}: no recipients`);return;}if (immediate && initiatorId) {- const idx = recipientIds.indexOf(initiatorId);- if (idx !== -1) recipientIds.splice(idx, 1);+ recipients = recipients.filter((r) => r.userId !== initiatorId);}- if (recipientIds.length === 0) return;+ if (recipients.length === 0) return;- $logger.info(`[DeadlineScheduler] Task ${taskId}: sending to [${recipientIds.join(',')}]`);+ // Description rides in the notification title, but it is gated by+ // COMPONENT_CAN_WATCH_CONTENT — split recipients so those without+ // the permission get a generic title (no leak over push).+ const { canWatch, cannotWatch } = await this.splitByContentPermission(goalId, recipients);++ $logger.info(`[DeadlineScheduler] Task ${taskId}: sending to content=[${canWatch.join(',')}] generic=[${cannotWatch.join(',')}]`);const tz = task[0].owner ? await this.deviceTokensRepo.getTimezoneByUserId(task[0].owner) : 'UTC';- const message = NotificationMessages.deadline(description, endDate, endTime, tz);-- await getNotificationService().notifyMany(- recipientIds,- NotificationType.DEADLINE,- message,- { goalId, goalListId, organizationId: organizationId ?? null },- taskId,- );+ const meta = { goalId, goalListId, organizationId: organizationId ?? null };++ if (canWatch.length > 0) {+ const message = NotificationMessages.deadline(description, endDate, endTime, tz);+ await getNotificationService().notifyMany(canWatch, NotificationType.DEADLINE, message, meta, taskId);+ }+ if (cannotWatch.length > 0) {+ const message = NotificationMessages.deadline(null, endDate, endTime, tz);+ await getNotificationService().notifyMany(cannotWatch, NotificationType.DEADLINE, message, meta, taskId);+ }});}@@ -127,7 +135,7 @@ export class DeadlineScheduler {return result[0]?.organizationId ?? null;}- private async resolveRecipients(db: Database, taskId: number, goalId: number, taskOwner: number | null): Promise<number[] | null> {+ private async resolveRecipients(db: Database, taskId: number, goalId: number, taskOwner: number | null): Promise<DeadlineRecipient[] | null> {const authUsers = alias(UsersSchema, 'auth_users');try {@@ -146,13 +154,46 @@ export class DeadlineScheduler {const ids = new Set<number>();if (taskOwner) ids.add(taskOwner);- assignees.forEach((r) => ids.add(r.userId));+ for (const r of assignees) ids.add(r.userId);if (goal[0]) ids.add(goal[0].owner);+ if (ids.size === 0) return [];- return [...ids];+ // Emails are needed to resolve per-recipient goal permissions (role join keys on email).+ return await db.dbDrizzle+ .select({ userId: UsersSchema.id, email: UsersSchema.email })+ .from(UsersSchema)+ .where(inArray(UsersSchema.id, [...ids]));} catch (err) {$logger.error(err, '[DeadlineScheduler] Failed to resolve recipients');return null;}}++ /** Partition recipients into those allowed to see task content and those who are not. */+ private async splitByContentPermission(goalId: number,recipients: DeadlineRecipient[]): Promise<{ canWatch: number[]; cannotWatch: number[] }> {+ const permissionsRepo = new GoalPermissionsRepository();+ const canWatch: number[] = [];+ const cannotWatch: number[] = [];++ await Promise.all(+ recipients.map(async (recipient) => {+ // Fail closed per-recipient: a permission-fetch error drops this+ // recipient to the generic message, never aborts the whole job.+ const permissions = await permissionsRepo+ .fetchPermissionsForGoalByUser({ goalId, userId: recipient.userId, email: recipient.email })+ .catch((err) => {+ $logger.error(err, `[DeadlineScheduler] permission check failed for user=${recipient.userId}`);+ return [];+ });+ const checker = new GoalPermissionsChecker(permissions);+ if (checker.hasPermissions(GoalPermissions.COMPONENT_CAN_WATCH_CONTENT)) {+ canWatch.push(recipient.userId);+ } else {+ cannotWatch.push(recipient.userId);+ }+ }),+ );++ return { canWatch, cannotWatch };+ }}diff --git a/api/src/tv-modules/notifications/types.ts b/api/src/tv-modules/notifications/types.tsindex 54cede3..8115a03 100644--- a/api/src/tv-modules/notifications/types.ts+++ b/api/src/tv-modules/notifications/types.ts@@ -121,4 +121,9 @@ export interface TaskWithDeadline {owner: number | null;endDate: string | null;endTime: string | null;+}++export interface DeadlineRecipient {+ userId: number;+ email: string;}\ No newline at end of filediff --git a/api/src/tv-modules/recurrence/RecurrenceDispatcher.ts b/api/src/tv-modules/recurrence/RecurrenceDispatcher.tsindex 8eda1f0..71e31a8 100644--- a/api/src/tv-modules/recurrence/RecurrenceDispatcher.ts+++ b/api/src/tv-modules/recurrence/RecurrenceDispatcher.ts@@ -90,16 +90,17 @@ export class RecurrenceDispatcher implements Dispatcher {const memberIds = await this.resolveGoalMemberIds(data.task.goalId);if (memberIds.length === 0) return;const centrifugo = getCentrifugoClient();- // The broadcast goes to every goal member, while notes are gated by a- // separate per-role permission — never put them on the wire here.- // Clients with note access get it when they open the task.- const task = { ...data.task, note: null };+ // Task fields are gated per role (TaskFieldPermissionsForWatching),+ // and recipients have different roles — so the broadcast carries ids+ // only, never content (same thin-event convention as goals.changed).+ // Each client fetches the task through REST, where fields are+ // cleaned for that user (fail closed).await Promise.all(memberIds.map((userId) =>centrifugo.publishToUser(userId, RECURRENCE_RT_EVENT, {goalId: data.task.goalId,ruleId: data.task.recurrenceRuleId,- task,+ taskId: data.task.id,})));diff --git a/api/src/tv-modules/recurrence/RecurrenceGenerator.ts b/api/src/tv-modules/recurrence/RecurrenceGenerator.tsindex 0925c3f..50aea2b 100644--- a/api/src/tv-modules/recurrence/RecurrenceGenerator.ts+++ b/api/src/tv-modules/recurrence/RecurrenceGenerator.ts@@ -178,6 +178,7 @@ export class RecurrenceGenerator {const window = RecurrenceParser.instanceWindowUtc({occurrenceDate: instanceDate,dtstart: rule.dtstart,+ hasTime: rule.hasTime,timezone: rule.timezone,durationMinutes: rule.templateDurationMinutes,});diff --git a/api/src/tv-modules/recurrence/RecurrenceManager.ts b/api/src/tv-modules/recurrence/RecurrenceManager.tsindex a330cc6..064e4ac 100644--- a/api/src/tv-modules/recurrence/RecurrenceManager.ts+++ b/api/src/tv-modules/recurrence/RecurrenceManager.ts@@ -1,7 +1,9 @@import type { RecurrenceRulesSchemaTypeForSelect } from 'taskview-db-schemas';import type { AppUser } from '../../core/AppUser';import { eventBus } from '../../core/EventBus';-import { GoalPermissions } from '../../types/auth.types';+import { KanbanRepository } from '../kanban/KanbanRepository';+import { GoalListsRepository } from '../lists/GoalListsRepository';+import { TaskFieldPermissionsForWatching } from '../tasks/tasks.server.types';import { TasksRepository } from '../tasks/TasksRepository';import { RecurrenceGenerator } from './RecurrenceGenerator';import { RecurrenceParser } from './RecurrenceParser';@@ -17,17 +19,31 @@ import type {const ok = <T>(data: T): RecurrenceResult<T> => ({ ok: true, data });const fail = (code: RecurrenceErrorCode, message?: string): RecurrenceResult<never> => ({ ok: false, code, message });+// Template fields mirror task fields, so the task-field permission map stays+// the single source of truth for which permission gates which field.+const RuleTemplateFieldPermissionsForWatching = {+ templateDescription: TaskFieldPermissionsForWatching.description,+ templateNote: TaskFieldPermissionsForWatching.note,+ templatePriorityId: TaskFieldPermissionsForWatching.priorityId,+ templateStatusId: TaskFieldPermissionsForWatching.statusId,+ templateGoalListId: TaskFieldPermissionsForWatching.goalListId,+} as const;+export class RecurrenceManager {private readonly user: AppUser;public readonly repository: RecurrenceRepository;private readonly generator: RecurrenceGenerator;private readonly tasksRepository: TasksRepository;+ private readonly kanbanRepository: KanbanRepository;+ private readonly goalListsRepository: GoalListsRepository;constructor(user: AppUser) {this.user = user;this.repository = new RecurrenceRepository();this.generator = new RecurrenceGenerator();this.tasksRepository = new TasksRepository();+ this.kanbanRepository = new KanbanRepository();+ this.goalListsRepository = new GoalListsRepository();}private get initiatorId(): number {@@ -46,9 +62,10 @@ export class RecurrenceManager {}let dtstart: Date;+ let hasTime: boolean;try {RecurrenceParser.validateRuleString(args.rrule);- dtstart = RecurrenceParser.parseDtstart(args.dtstart);+ ({ date: dtstart, hasTime } = RecurrenceParser.parseDtstart(args.dtstart));} catch (err) {return fail('invalid_rule', (err as Error).message);}@@ -56,55 +73,71 @@ export class RecurrenceManager {const originInstanceDate = RecurrenceParser.firstOccurrenceDate({ rrule: args.rrule, dtstart });if (!originInstanceDate) return fail('invalid_rule', 'rule produces no occurrences');- const rule = await this.repository.create({- goalId: task.goalId,- templateTaskId: task.id,- templateDescription: task.description ?? '',- templateNote: task.note,- templatePriorityId: task.priorityId,- templateStatusId: task.statusId,- templateGoalListId: task.goalListId,- templateDurationMinutes: this.durationFromTask({- startDate: task.startDate ?? originInstanceDate,- startTime: task.startTime,- endDate: task.endDate,- endTime: task.endTime,- }),- rrule: args.rrule,- dtstart,- timezone: args.timezone,- lastInstanceDate: originInstanceDate,- notifyOnOccurrence: args.notifyOnOccurrence ?? false,- creatorId: this.initiatorId,+ const templateDurationMinutes = this.durationFromTask({+ startDate: task.startDate ?? originInstanceDate,+ startTime: task.startTime,+ endDate: task.endDate,+ endTime: task.endTime,});- if (!rule) return fail('invalid_state', 'could not create rule');- // The origin task becomes the first (and only open) instance of the series.- await this.repository.attachTaskToRule({ taskId: task.id, ruleId: rule.id, instanceDate: originInstanceDate });- // Normalize its window into the same UTC frame future instances will use —+ // One transaction: rule + origin attachment + snapshot. The origin task+ // becomes the first (and only open) instance of the series, its window+ // normalized into the same UTC frame future instances will use —// otherwise a series created through a non-browser client (MCP, raw API)// could leave the origin and its successors in different time frames.- await this.repository.applyInstanceWindow({- taskId: task.id,+ const outcome = await this.repository.createWithOriginTask({+ rule: {+ goalId: task.goalId,+ templateTaskId: task.id,+ templateDescription: task.description ?? '',+ templateNote: task.note,+ templatePriorityId: task.priorityId,+ templateStatusId: task.statusId,+ templateGoalListId: task.goalListId,+ templateDurationMinutes,+ rrule: args.rrule,+ dtstart,+ hasTime,+ timezone: args.timezone,+ lastInstanceDate: originInstanceDate,+ notifyOnOccurrence: args.notifyOnOccurrence ?? false,+ creatorId: this.initiatorId,+ },+ originTaskId: task.id,+ originInstanceDate,window: RecurrenceParser.instanceWindowUtc({occurrenceDate: originInstanceDate,dtstart,+ hasTime,timezone: args.timezone,- durationMinutes: rule.templateDurationMinutes,+ durationMinutes: templateDurationMinutes,}),});+ if ('error' in outcome) {+ if (outcome.error === 'not_found') return fail('not_found', 'task not found');+ if (outcome.error === 'conflict') return fail('conflict', 'task is already part of a series');+ return fail('invalid_state', 'could not create rule');+ }- const [assignees, tags] = await Promise.all([- this.repository.getTaskAssignees(task.id),- this.repository.getTaskTags(task.id),- ]);- await Promise.all([- this.repository.setTemplateAssignees({ ruleId: rule.id, collabUserIds: assignees }),- this.repository.setTemplateTags({ ruleId: rule.id, tagIds: tags }),- ]);+ eventBus.emit('recurrence.created', { rule: outcome.rule, initiatorId: this.initiatorId });+ return ok(await this.cleanRuleFieldsRegardPermissions(outcome.rule));+ }- eventBus.emit('recurrence.created', { rule, initiatorId: this.initiatorId });- return ok(rule);+ /**+ * Task fields are permission-gated for reading (TaskFieldPermissionsForWatching,+ * applied by cleanTaskFieldsRegardPermissions in the task API) — no series+ * endpoint may become a side door to them, so every response carrying a rule+ * strips the template fields the caller is not allowed to watch.+ */+ private async cleanRuleFieldsRegardPermissions(rule: RecurrenceRulesSchemaTypeForSelect): Promise<RecurrenceRulesSchemaTypeForSelect> {+ const checker = await this.user.permissionsFetcher.getCheckerForGoal(rule.goalId).catch(() => null);+ const cleaned = { ...rule };+ (Object.keys(RuleTemplateFieldPermissionsForWatching) as (keyof typeof RuleTemplateFieldPermissionsForWatching)[]).forEach((field) => {+ if (!checker?.hasPermissions(RuleTemplateFieldPermissionsForWatching[field])) {+ cleaned[field] = null;+ }+ });+ return cleaned;}async getDetails(ruleId: number): Promise<RecurrenceResult<RecurrenceRuleDetails>> {@@ -115,16 +148,17 @@ export class RecurrenceManager {this.repository.findOpenInstance(ruleId),]);- // Notes are gated by a separate permission in the task API- // (cleanTaskFieldsRegardPermissions) — the series endpoints must not- // become a side door to them.- const checker = await this.user.permissionsFetcher.getCheckerForGoal(rule.goalId).catch(() => null);- if (!checker?.hasPermissions(GoalPermissions.TASK_CAN_WATCH_NOTE)) {- rule.templateNote = null;- if (openInstance) openInstance.note = null;- }+ // The open instance is an ordinary task — gate its fields exactly like+ // the task API does. Fail closed: better no instance than a leak.+ const cleanedInstance = openInstance+ ? await this.user.tasksManager.cleanTaskFieldsRegardPermissions(openInstance).catch(() => null)+ : null;- return ok({ rule, skipDates, openInstance });+ return ok({+ rule: await this.cleanRuleFieldsRegardPermissions(rule),+ skipDates,+ openInstance: cleanedInstance,+ });}async getDetailsForTask(taskId: number): Promise<RecurrenceResult<RecurrenceRuleDetails>> {@@ -149,7 +183,9 @@ export class RecurrenceManager {}if (args.dtstart !== undefined) {try {- patch.dtstart = RecurrenceParser.parseDtstart(args.dtstart);+ const parsed = RecurrenceParser.parseDtstart(args.dtstart);+ patch.dtstart = parsed.date;+ patch.hasTime = parsed.hasTime;} catch (err) {return fail('invalid_rule', (err as Error).message);}@@ -160,9 +196,28 @@ export class RecurrenceManager {}patch.timezone = args.timezone;}+ if (patch.rrule !== undefined || patch.dtstart !== undefined) {+ const nextDate = RecurrenceParser.nextOccurrenceDate({+ rrule: patch.rrule ?? rule.rrule,+ dtstart: patch.dtstart ?? rule.dtstart,+ afterDate: RecurrenceParser.todayInTimezone(patch.timezone ?? rule.timezone),+ skipDates: new Set<string>(),+ });+ if (!nextDate) return fail('invalid_rule', 'rule produces no occurrences');+ }if (args.notifyOnOccurrence !== undefined) patch.notifyOnOccurrence = args.notifyOnOccurrence;if (args.templateOverrides) {const o = args.templateOverrides;+ // Foreign/dead ids must fail here, not get stored and silently+ // fall back at materialization time (null clears the override).+ if (o.statusId !== undefined && o.statusId !== null) {+ const belongs = await this.kanbanRepository.statusBelongsToGoal({ statusId: o.statusId, goalId: rule.goalId });+ if (!belongs) return fail('invalid_rule', 'status does not belong to the goal');+ }+ if (o.goalListId !== undefined && o.goalListId !== null) {+ const belongs = await this.goalListsRepository.listBelongsToGoal({ listId: o.goalListId, goalId: rule.goalId });+ if (!belongs) return fail('invalid_rule', 'list does not belong to the goal');+ }if (o.description !== undefined) patch.templateDescription = o.description;if (o.note !== undefined) patch.templateNote = o.note;if (o.priorityId !== undefined) patch.templatePriorityId = o.priorityId;@@ -170,13 +225,13 @@ export class RecurrenceManager {if (o.goalListId !== undefined) patch.templateGoalListId = o.goalListId;if (o.durationMinutes !== undefined) patch.templateDurationMinutes = o.durationMinutes;}- if (Object.keys(patch).length === 0) return ok(rule);+ if (Object.keys(patch).length === 0) return ok(await this.cleanRuleFieldsRegardPermissions(rule));const updated = await this.repository.patch({ ruleId: args.ruleId, patch });if (!updated) return fail('invalid_state');eventBus.emit('recurrence.updated', { rule: updated, changes: patch, initiatorId: this.initiatorId });- return ok(updated);+ return ok(await this.cleanRuleFieldsRegardPermissions(updated));}async pauseRule(ruleId: number): Promise<RecurrenceResult<RecurrenceRulesSchemaTypeForSelect>> {@@ -187,7 +242,7 @@ export class RecurrenceManager {const updated = await this.repository.patch({ ruleId, patch: { state: 'paused' } });if (!updated) return fail('invalid_state');eventBus.emit('recurrence.paused', { ruleId, goalId: rule.goalId, initiatorId: this.initiatorId });- return ok(updated);+ return ok(await this.cleanRuleFieldsRegardPermissions(updated));}async resumeRule(ruleId: number): Promise<RecurrenceResult<RecurrenceRulesSchemaTypeForSelect>> {@@ -206,7 +261,7 @@ export class RecurrenceManager {}eventBus.emit('recurrence.resumed', { ruleId, goalId: rule.goalId, initiatorId: this.initiatorId });- return ok(updated);+ return ok(await this.cleanRuleFieldsRegardPermissions(updated));}/** Skip the current occurrence: the open instance is removed and the card "jumps" to the next date. */diff --git a/api/src/tv-modules/recurrence/RecurrenceParser.ts b/api/src/tv-modules/recurrence/RecurrenceParser.tsindex 923dc48..23501d2 100644--- a/api/src/tv-modules/recurrence/RecurrenceParser.ts+++ b/api/src/tv-modules/recurrence/RecurrenceParser.ts@@ -81,13 +81,16 @@ export class RecurrenceParser {return today.isValid ? (today.toISODate() as string) : (DateTime.utc().toISODate() as string);}- /** 'HH:mm:ss' wall-clock time of day of the series, or null when the series carries no time (midnight dtstart). */- static timeOfDay(dtstart: Date): string | null {- const hours = dtstart.getUTCHours();- const minutes = dtstart.getUTCMinutes();- if (hours === 0 && minutes === 0) return null;+ /**+ * 'HH:mm:ss' wall-clock time of day of the series, or null for a date-only+ * series. The distinction is carried explicitly by `hasTime` (rule column)+ * — never inferred from a midnight dtstart, otherwise an explicit 00:00+ * series would be indistinguishable from "no time".+ */+ static timeOfDay(args: { dtstart: Date; hasTime: boolean }): string | null {+ if (!args.hasTime) return null;const pad = (n: number) => String(n).padStart(2, '0');- return `${pad(hours)}:${pad(minutes)}:00`;+ return `${pad(args.dtstart.getUTCHours())}:${pad(args.dtstart.getUTCMinutes())}:00`;}static isValidTimezone(timezone: string): boolean {@@ -104,7 +107,7 @@ export class RecurrenceParser {* days are pushed forward by luxon to the nearest valid time.*/static instanceWindowUtc(args: InstanceWindowArgs): InstanceWindow {- const wallTime = RecurrenceParser.timeOfDay(args.dtstart);+ const wallTime = RecurrenceParser.timeOfDay({ dtstart: args.dtstart, hasTime: args.hasTime });// Date-only series: calendar dates pass through untouched (no instant semantics).if (!wallTime) {@@ -142,11 +145,17 @@ export class RecurrenceParser {return window;}- /** Floating wall-clock 'YYYY-MM-DDTHH:mm:ss' string → Date with the same UTC components. */- static parseDtstart(dtstart: string): Date {- const date = new Date(`${dtstart}Z`);+ /**+ * dtstart in RFC 5545 DATE or DATE-TIME shape → Date (+ whether a time was+ * given). `YYYY-MM-DD` is date-only (`hasTime: false`); `YYYY-MM-DDTHH:mm:ss`+ * carries a wall-clock time (`hasTime: true`), including an explicit+ * `T00:00:00`. Either way the Date holds floating wall-clock UTC components.+ */+ static parseDtstart(dtstart: string): { date: Date; hasTime: boolean } {+ const hasTime = dtstart.includes('T');+ const date = new Date(`${hasTime ? dtstart : `${dtstart}T00:00:00`}Z`);if (Number.isNaN(date.getTime())) throw new Error('Invalid dtstart');- return date;+ return { date, hasTime };}static toIsoDate(date: Date): string {diff --git a/api/src/tv-modules/recurrence/RecurrenceRepository.ts b/api/src/tv-modules/recurrence/RecurrenceRepository.tsindex dcff68a..7c1572c 100644--- a/api/src/tv-modules/recurrence/RecurrenceRepository.ts+++ b/api/src/tv-modules/recurrence/RecurrenceRepository.ts@@ -1,7 +1,6 @@import { and, eq, inArray, isNotNull, ne, notExists, sql } from 'drizzle-orm';import {RecurrenceRulesSchema,- type RecurrenceRulesSchemaTypeForInsert,type RecurrenceRulesSchemaTypeForSelect,RecurrenceSkipDatesSchema,RecurrenceTemplateAssigneesSchema,@@ -12,17 +11,18 @@ import {TasksToTagsSchema,} from 'taskview-db-schemas';import { Database } from '../../modules/db';+import { $logger } from '../../modules/logget';import { callWithCatch } from '../../utils/helpers';import type {AddSkipDateArgs,- ApplyInstanceWindowArgs,- AttachTaskToRuleArgs,+ CreateRuleWithOriginArgs,+ CreateRuleWithOriginResult,RecurrenceRulePatchArgs,RemoveTemplateAssigneeFromGoalArgs,- SetTemplateAssigneesArgs,- SetTemplateTagsArgs,} from './types';+const PG_UNIQUE_VIOLATION = '23505';+export class RecurrenceRepository {private readonly db: Database;@@ -30,11 +30,6 @@ export class RecurrenceRepository {this.db = Database.getInstance();}- async create(data: RecurrenceRulesSchemaTypeForInsert): Promise<RecurrenceRulesSchemaTypeForSelect | null> {- const result = await callWithCatch(() => this.db.dbDrizzle.insert(RecurrenceRulesSchema).values(data).returning());- return result?.[0] ?? null;- }-async getById(ruleId: number): Promise<RecurrenceRulesSchemaTypeForSelect | null> {const result = await callWithCatch(() =>this.db.dbDrizzle.select().from(RecurrenceRulesSchema).where(eq(RecurrenceRulesSchema.id, ruleId)).limit(1)@@ -91,54 +86,6 @@ export class RecurrenceRepository {);}- async getTemplateAssignees(ruleId: number): Promise<number[]> {- const result = await callWithCatch(() =>- this.db.dbDrizzle- .select({ collabUserId: RecurrenceTemplateAssigneesSchema.collabUserId })- .from(RecurrenceTemplateAssigneesSchema)- .where(eq(RecurrenceTemplateAssigneesSchema.ruleId, ruleId))- );- return result?.map((r) => r.collabUserId) ?? [];- }-- async getTemplateTags(ruleId: number): Promise<number[]> {- const result = await callWithCatch(() =>- this.db.dbDrizzle- .select({ tagId: RecurrenceTemplateTagsSchema.tagId })- .from(RecurrenceTemplateTagsSchema)- .where(eq(RecurrenceTemplateTagsSchema.ruleId, ruleId))- );- return result?.map((r) => r.tagId) ?? [];- }-- async setTemplateAssignees(args: SetTemplateAssigneesArgs): Promise<void> {- await callWithCatch(() =>- this.db.dbDrizzle.transaction(async (tx) => {- await tx.delete(RecurrenceTemplateAssigneesSchema).where(eq(RecurrenceTemplateAssigneesSchema.ruleId, args.ruleId));- if (args.collabUserIds.length > 0) {- await tx- .insert(RecurrenceTemplateAssigneesSchema)- .values(args.collabUserIds.map((collabUserId) => ({ ruleId: args.ruleId, collabUserId })))- .onConflictDoNothing();- }- })- );- }-- async setTemplateTags(args: SetTemplateTagsArgs): Promise<void> {- await callWithCatch(() =>- this.db.dbDrizzle.transaction(async (tx) => {- await tx.delete(RecurrenceTemplateTagsSchema).where(eq(RecurrenceTemplateTagsSchema.ruleId, args.ruleId));- if (args.tagIds.length > 0) {- await tx- .insert(RecurrenceTemplateTagsSchema)- .values(args.tagIds.map((tagId) => ({ ruleId: args.ruleId, tagId })))- .onConflictDoNothing();- }- })- );- }-/** Drops an ex-collaborator from the assignee snapshot of every rule in the goal. */async removeTemplateAssigneeFromGoal(args: RemoveTemplateAssigneeFromGoalArgs): Promise<void> {const goalRules = this.db.dbDrizzle@@ -157,26 +104,6 @@ export class RecurrenceRepository {);}- async getTaskAssignees(taskId: number): Promise<number[]> {- const result = await callWithCatch(() =>- this.db.dbDrizzle- .select({ collabUserId: TasksAssigneeSchema.collabUserId })- .from(TasksAssigneeSchema)- .where(eq(TasksAssigneeSchema.taskId, taskId))- );- return result?.map((r) => r.collabUserId) ?? [];- }-- async getTaskTags(taskId: number): Promise<number[]> {- const result = await callWithCatch(() =>- this.db.dbDrizzle- .select({ tagId: TasksToTagsSchema.tagId })- .from(TasksToTagsSchema)- .where(eq(TasksToTagsSchema.taskId, taskId))- );- return result?.map((r) => r.tagId) ?? [];- }-async getTaskById(taskId: number): Promise<TasksSchemaTypeForSelect | null> {const result = await callWithCatch(() =>this.db.dbDrizzle.select().from(TasksSchema).where(eq(TasksSchema.id, taskId)).limit(1)@@ -184,29 +111,75 @@ export class RecurrenceRepository {return result?.[0] ?? null;}- async attachTaskToRule(args: AttachTaskToRuleArgs): Promise<boolean> {- const result = await callWithCatch(() =>- this.db.dbDrizzle- .update(TasksSchema)- .set({ recurrenceRuleId: args.ruleId, recurrenceInstanceDate: args.instanceDate })- .where(eq(TasksSchema.id, args.taskId))- );- return !!result?.rowCount;- }+ /**+ * Atomic series creation. The origin task row is locked FOR UPDATE, so+ * concurrent creates on the same task serialize: the loser waits on the+ * lock, then sees recurrenceRuleId already set and reports a conflict.+ * The partial unique index uniq_recurrence_rules_template_task backs this+ * up on the DB level. Everything — rule insert, origin attachment (with+ * the window normalized to the series frame) and the assignee/tag+ * snapshot — commits or rolls back together.+ */+ async createWithOriginTask(args: CreateRuleWithOriginArgs): Promise<CreateRuleWithOriginResult> {+ try {+ return await this.db.dbDrizzle.transaction(async (tx) => {+ const taskRows = await tx+ .select({ recurrenceRuleId: TasksSchema.recurrenceRuleId })+ .from(TasksSchema)+ .where(eq(TasksSchema.id, args.originTaskId))+ .for('update')+ .limit(1);+ const task = taskRows[0];+ if (!task) return { error: 'not_found' as const };+ if (task.recurrenceRuleId) return { error: 'conflict' as const };++ const ruleRows = await tx.insert(RecurrenceRulesSchema).values(args.rule).returning();+ const rule = ruleRows[0];++ await tx+ .update(TasksSchema)+ .set({+ recurrenceRuleId: rule.id,+ recurrenceInstanceDate: args.originInstanceDate,+ startDate: args.window.startDate,+ startTime: args.window.startTime,+ endDate: args.window.endDate,+ endTime: args.window.endTime,+ })+ .where(eq(TasksSchema.id, args.originTaskId));++ const [assignees, tags] = await Promise.all([+ tx+ .select({ collabUserId: TasksAssigneeSchema.collabUserId })+ .from(TasksAssigneeSchema)+ .where(eq(TasksAssigneeSchema.taskId, args.originTaskId)),+ tx+ .select({ tagId: TasksToTagsSchema.tagId })+ .from(TasksToTagsSchema)+ .where(eq(TasksToTagsSchema.taskId, args.originTaskId)),+ ]);+ if (assignees.length > 0) {+ await tx+ .insert(RecurrenceTemplateAssigneesSchema)+ .values(assignees.map((a) => ({ ruleId: rule.id, collabUserId: a.collabUserId })))+ .onConflictDoNothing();+ }+ if (tags.length > 0) {+ await tx+ .insert(RecurrenceTemplateTagsSchema)+ .values(tags.map((t) => ({ ruleId: rule.id, tagId: t.tagId })))+ .onConflictDoNothing();+ }- /** Aligns a task's start/end window with the series frame (used to normalize the origin instance). */- async applyInstanceWindow(args: ApplyInstanceWindowArgs): Promise<void> {- await callWithCatch(() =>- this.db.dbDrizzle- .update(TasksSchema)- .set({- startDate: args.window.startDate,- startTime: args.window.startTime,- endDate: args.window.endDate,- endTime: args.window.endTime,- })- .where(eq(TasksSchema.id, args.taskId))- );+ return { rule };+ });+ } catch (error) {+ if ((error as { code?: string } | null)?.code === PG_UNIQUE_VIOLATION) {+ return { error: 'conflict' };+ }+ $logger.error(error, '[RecurrenceRepository] createWithOriginTask failed');+ return { error: 'failed' };+ }}/** The single not-completed instance of the rule (the lazy model keeps at most one). */diff --git a/api/src/tv-modules/recurrence/RecurrenceRoutes.ts b/api/src/tv-modules/recurrence/RecurrenceRoutes.tsindex 0b4792d..3063747 100644--- a/api/src/tv-modules/recurrence/RecurrenceRoutes.ts+++ b/api/src/tv-modules/recurrence/RecurrenceRoutes.ts@@ -35,7 +35,10 @@ export default class RecurrenceRoutes implements Routable {this.router.patch('/:ruleId', [IsLoggedIn, requireRecurrencePermission(GoalPermissions.TASKS_CAN_EDIT_DEADLINE, goalIdFromRuleParam)], this.controller.update);this.router.post('/:ruleId/pause', [IsLoggedIn, requireRecurrencePermission(GoalPermissions.TASKS_CAN_EDIT_DEADLINE, goalIdFromRuleParam)], this.controller.pause);this.router.post('/:ruleId/resume', [IsLoggedIn, requireRecurrencePermission(GoalPermissions.TASKS_CAN_EDIT_DEADLINE, goalIdFromRuleParam)], this.controller.resume);- this.router.post('/:ruleId/skip', [IsLoggedIn, requireRecurrencePermission(GoalPermissions.TASKS_CAN_EDIT_DEADLINE, goalIdFromRuleParam)], this.controller.skip);+ // Skip is the one schedule operation that physically deletes the open+ // instance (with its subtasks and tracked time) — so on top of the+ // schedule permission it requires the same right as DELETE /tasks.+ this.router.post('/:ruleId/skip', [IsLoggedIn, requireRecurrencePermission([GoalPermissions.TASKS_CAN_EDIT_DEADLINE, GoalPermissions.TASKS_CAN_DELETE], goalIdFromRuleParam)], this.controller.skip);this.router.delete('/:ruleId', [IsLoggedIn, requireRecurrencePermission(GoalPermissions.TASKS_CAN_EDIT_DEADLINE, goalIdFromRuleParam)], this.controller.remove);}}diff --git a/api/src/tv-modules/recurrence/middlewares/require-recurrence-permission.ts b/api/src/tv-modules/recurrence/middlewares/require-recurrence-permission.tsindex 62b9fe4..2299f0c 100644--- a/api/src/tv-modules/recurrence/middlewares/require-recurrence-permission.ts+++ b/api/src/tv-modules/recurrence/middlewares/require-recurrence-permission.ts@@ -31,7 +31,9 @@ export const goalIdFromTaskParam: GoalIdResolver = async (req) => {return task?.goalId ?? null;};-export function requireRecurrencePermission(permission: GoalPermissionType, resolveGoalId: GoalIdResolver) {+/** A single permission or a list — the caller must hold ALL of them. */+export function requireRecurrencePermission(permission: GoalPermissionType | GoalPermissionType[], resolveGoalId: GoalIdResolver) {+ const required = Array.isArray(permission) ? permission : [permission];return async (req: Request, res: Response, next: NextFunction) => {const goalId = await resolveGoalId(req);if (!goalId) return res.status(404).end();@@ -45,7 +47,7 @@ export function requireRecurrencePermission(permission: GoalPermissionType, resoreturn res.status(500).end();}- if (permissions.hasPermissions(permission)) return next();+ if (required.every((p) => permissions.hasPermissions(p))) return next();return res.status(403).end();};}diff --git a/api/src/tv-modules/recurrence/types.ts b/api/src/tv-modules/recurrence/types.tsindex a6e2a5d..3c95b30 100644--- a/api/src/tv-modules/recurrence/types.ts+++ b/api/src/tv-modules/recurrence/types.ts@@ -1,5 +1,9 @@import { type } from 'arktype';-import type { RecurrenceRulesSchemaTypeForSelect, TasksSchemaTypeForSelect } from 'taskview-db-schemas';+import type {+ RecurrenceRulesSchemaTypeForInsert,+ RecurrenceRulesSchemaTypeForSelect,+ TasksSchemaTypeForSelect,+} from 'taskview-db-schemas';/** Request validators (ArkType) */@@ -63,6 +67,8 @@ export type InstanceWindowArgs = {/** 'YYYY-MM-DD' wall-clock occurrence date in the rule's timezone. */occurrenceDate: string;dtstart: Date;+ /** False → date-only occurrence (no start/end time). */+ hasTime: boolean;timezone: string;durationMinutes: number | null;};@@ -80,6 +86,7 @@ export type RecurrenceRulePatchArgs = {patch: Partial<{rrule: string;dtstart: Date;+ hasTime: boolean;timezone: string;state: 'active' | 'paused' | 'ended';lastInstanceDate: string;@@ -95,12 +102,24 @@ export type RecurrenceRulePatchArgs = {}>;};-export type AttachTaskToRuleArgs = { taskId: number; ruleId: number; instanceDate: string };export type AddSkipDateArgs = { ruleId: number; skipDate: string };-export type SetTemplateAssigneesArgs = { ruleId: number; collabUserIds: number[] };-export type SetTemplateTagsArgs = { ruleId: number; tagIds: number[] };export type RemoveTemplateAssigneeFromGoalArgs = { goalId: number; collabUserId: number };-export type ApplyInstanceWindowArgs = { taskId: number; window: InstanceWindow };++/**+ * Atomic series creation: rule insert + origin task attachment (with its+ * window normalized to the series frame) + assignee/tag snapshot — one+ * transaction with the origin task row locked FOR UPDATE, so concurrent+ * creates on the same task serialize instead of producing two rules.+ */+export type CreateRuleWithOriginArgs = {+ rule: RecurrenceRulesSchemaTypeForInsert;+ originTaskId: number;+ originInstanceDate: string;+ window: InstanceWindow;+};+export type CreateRuleWithOriginResult =+ | { rule: RecurrenceRulesSchemaTypeForSelect }+ | { error: 'not_found' | 'conflict' | 'failed' };/** Detail shape returned by GET endpoints */diff --git a/api/src/tv-modules/tasks/TasksManager.ts b/api/src/tv-modules/tasks/TasksManager.tsindex 4ef7beb..2506d4e 100644--- a/api/src/tv-modules/tasks/TasksManager.ts+++ b/api/src/tv-modules/tasks/TasksManager.ts@@ -307,7 +307,8 @@ export class TasksManager {return extendedTask[0] ?? null;}- private async cleanTaskFieldsRegardPermissions(task: TasksSchemaTypeForSelect): Promise<TasksSchemaTypeForSelect> {+ /** Public: other modules returning task rows (e.g. recurrence) gate fields through the same cleaner. */+ async cleanTaskFieldsRegardPermissions(task: TasksSchemaTypeForSelect): Promise<TasksSchemaTypeForSelect> {const permissions = await this.user.permissionsFetcher.getCheckerForGoal(task.goalId);(Object.keys(TaskFieldPermissionsForWatching) as TaskFieldPermissionKey[]).forEach((key) => {if (!permissions.hasPermissions(TaskFieldPermissionsForWatching[key])) {diff --git a/api/src/types/auth.types.ts b/api/src/types/auth.types.tsindex e1a65ed..79ac09b 100644--- a/api/src/types/auth.types.ts+++ b/api/src/types/auth.types.ts@@ -150,3 +150,9 @@ export type FetchGoalIdsWithAnyPermissionParams = {organizationId: number;permissionNames: string[];};++export type FetchPermissionsForGoalByUserParams = {+ goalId: number;+ userId: number;+ email: string;+};diff --git a/taskview-packages/taskview-api/src/api/__tests__/recurrence.test.ts b/taskview-packages/taskview-api/src/api/__tests__/recurrence.test.tsindex a3fdb0d..2743e69 100644--- a/taskview-packages/taskview-api/src/api/__tests__/recurrence.test.ts+++ b/taskview-packages/taskview-api/src/api/__tests__/recurrence.test.ts@@ -9,6 +9,7 @@ import {import axios, { type AxiosInstance } from 'axios'import { initApi, API_URL, DEFAULT_USER, DEFAULT_USER_2, DEFAULT_PASSWORD } from './init-api'import { ymd } from './test-helpers'+import { TvPermissions } from '@/api/permissions'import type { RecurrenceRuleDetails } from '@/api/recurrence.types'/**@@ -23,15 +24,18 @@ import type { RecurrenceRuleDetails } from '@/api/recurrence.types'*/describe('Recurrence', () => {let $api: TvApi+ let $apiUser2: TvApilet raw: AxiosInstancelet goalId: numberconst MSK_TIME = 'T10:45:00'const UTC_TIME = '07:45:00'+ const USER2_EMAIL = '[email protected]'beforeAll(async () => {- const { $tvApi } = await initApi()+ const { $tvApi, $tvApiForSecondUser } = await initApi()$api = $tvApi+ $apiUser2 = $tvApiForSecondUser// Raw axios with validateStatus:true to assert error statuses directly.const auth = await axios.post(`${API_URL}/module/auth/login`, {@@ -375,14 +379,15 @@ describe('Recurrence', () => {expect(next.openInstance?.recurrenceInstanceDate).toBe(secondEnd)})- it('a date-only series gets deadline = occurrence date (shows up in Today/Upcoming)', async () => {+ it('a date-only series (date-only dtstart) gets deadline = occurrence date (shows up in Today/Upcoming)', async () => {const task = await $api.tasks.createTask({ goalId, description: 'No-end daily', startDate: ymd(3) })const rule = await $api.recurrence.create({taskId: task!.id,rrule: 'FREQ=DAILY',- dtstart: `${ymd(3)}T00:00:00`,+ dtstart: ymd(3), // date-only: no wall-clock timetimezone: 'Europe/Moscow',})+ expect(rule!.hasTime).toBe(false)// the origin window is normalized the same wayconst origin = await $api.tasks.fetchTaskById(task!.id)@@ -397,6 +402,23 @@ describe('Recurrence', () => {expect(details.openInstance?.endTime).toBeNull()})+ it('an explicit midnight series (T00:00:00 dtstart) is timed, not date-only', async () => {+ const task = await $api.tasks.createTask({ goalId, description: 'Midnight daily', startDate: ymd(3) })+ const rule = await $api.recurrence.create({+ taskId: task!.id,+ rrule: 'FREQ=DAILY',+ dtstart: `${ymd(3)}T00:00:00`, // explicit midnight wall-clock in MSK+ timezone: 'Europe/Moscow',+ })+ expect(rule!.hasTime).toBe(true)++ await $api.tasks.updateTask({ id: task!.id, complete: true })+ const details = await waitFor(rule.id, (d) => !!d.openInstance && d.openInstance.id !== task!.id)+ // 00:00 MSK = 21:00 UTC the previous calendar day — a real time, not null.+ expect(details.openInstance?.startTime).toBe('21:00:00')+ expect(details.openInstance?.startDate).toBe(ymd(3))+ })+it('a timed series without duration is due at the occurrence moment', async () => {const task = await $api.tasks.createTask({goalId,@@ -524,4 +546,148 @@ describe('Recurrence', () => {expect(intact?.rule.state).toBe('active')})})++ describe('has_time flag', () => {+ it('a rule created from a timed dtstart carries has_time=true', async () => {+ const task = await createTask('Timed origin')+ const rule = await createRule(task.id, 'FREQ=DAILY') // dtstart includes MSK_TIME+ expect(rule.hasTime).toBe(true)+ })++ it('updating dtstart toggles has_time both ways', async () => {+ const task = await $api.tasks.createTask({ goalId, description: 'Toggle time', startDate: ymd(3) })+ const rule = await $api.recurrence.create({+ taskId: task!.id, rrule: 'FREQ=DAILY', dtstart: ymd(3), timezone: 'Europe/Moscow',+ })+ expect(rule.hasTime).toBe(false)++ const timed = await $api.recurrence.update({ ruleId: rule.id, dtstart: `${ymd(3)}T09:00:00` })+ expect(timed.hasTime).toBe(true)++ const back = await $api.recurrence.update({ ruleId: rule.id, dtstart: ymd(3) })+ expect(back.hasTime).toBe(false)+ })+ })++ describe('rule edit validation', () => {+ let ruleId: number+ beforeAll(async () => {+ const task = await createTask('Edit validation target')+ ruleId = (await createRule(task.id, 'FREQ=DAILY')).id+ })++ it('rejects a templateOverrides.statusId not belonging to the goal', async () => {+ const res = await raw.patch(`/module/recurrence/${ruleId}`, { templateOverrides: { statusId: 99999999 } })+ expect(res.status).toBe(422)+ })++ it('rejects a templateOverrides.goalListId not belonging to the goal', async () => {+ const res = await raw.patch(`/module/recurrence/${ruleId}`, { templateOverrides: { goalListId: 99999999 } })+ expect(res.status).toBe(422)+ })++ it('allows clearing overrides with null', async () => {+ const res = await raw.patch(`/module/recurrence/${ruleId}`, { templateOverrides: { statusId: null, goalListId: null } })+ expect(res.status).toBe(200)+ })++ it('rejects an impossible rule on update (no occurrences — UNTIL in the past)', async () => {+ const res = await raw.patch(`/module/recurrence/${ruleId}`, { rrule: 'FREQ=DAILY;UNTIL=20000101T000000Z' })+ expect(res.status).toBe(422)+ })+ })++ describe('concurrent creation (race)', () => {+ it('two parallel creates on the same task yield exactly one rule', async () => {+ const task = await createTask('Race target')+ const body = { taskId: task.id, rrule: 'FREQ=DAILY', dtstart: `${ymd(3)}${MSK_TIME}`, timezone: 'Europe/Moscow' }+ const [a, b] = await Promise.all([+ raw.post('/module/recurrence', body),+ raw.post('/module/recurrence', body),+ ])+ // exactly one wins (200), the other is rejected as a conflict (409) —+ // guaranteed by the FOR UPDATE transaction + partial unique index.+ expect([a.status, b.status].sort()).toEqual([200, 409])+ })+ })++ describe('permission gating', () => {+ let gateGoalId: number+ let user2Raw: AxiosInstance+ let collabId: number+ let roleSeq = 0++ beforeAll(async () => {+ const goal = await $api.goals.createGoal({ name: `Gating project-${Date.now()}` })+ gateGoalId = goal!.id!+ await $api.collaboration.inviteUserToGoal({ goalId: gateGoalId, email: USER2_EMAIL })+ const users = await $api.collaboration.fetchUsersForGoal(gateGoalId)+ collabId = users!.find((u) => u.email === USER2_EMAIL)!.id++ const auth = await axios.post(`${API_URL}/module/auth/login`, { login: DEFAULT_USER_2, password: DEFAULT_PASSWORD })+ user2Raw = axios.create({+ baseURL: API_URL,+ headers: { Authorization: `Bearer ${auth.data.access}` },+ validateStatus: () => true,+ })+ })++ afterAll(async () => {+ await $api.goals.deleteGoal(gateGoalId).catch(() => {})+ })++ /** Replace user2's role set with a single fresh role holding exactly `permissionNames`. */+ async function grantUser2(permissionNames: string[]) {+ const role = await $api.collaboration.createRoleForGoal({ goalId: gateGoalId, roleName: `r-${Date.now()}-${roleSeq++}` })+ const allPerms = await $api.collaboration.fetchAllPermissions()+ for (const name of permissionNames) {+ const perm = allPerms!.find((p) => p.name === name)!+ await $api.collaboration.toggleRolePermission({ roleId: role!.id, permissionId: perm.id })+ }+ await $api.collaboration.toggleUserRoles({ userId: collabId, goalId: gateGoalId, roles: [role!.id] })+ }++ async function createGateRule(description: string, note: string) {+ const task = await $api.tasks.createTask({ goalId: gateGoalId, description, note, startDate: ymd(3), startTime: UTC_TIME })+ const rule = await $api.recurrence.create({ taskId: task!.id, rrule: 'FREQ=DAILY', dtstart: `${ymd(3)}${MSK_TIME}`, timezone: 'Europe/Moscow' })+ return { taskId: task!.id, rule }+ }++ it('owner sees templateNote; a member without note permission gets it stripped', async () => {+ const { rule } = await createGateRule('Secret standup', 'confidential note')++ const ownerView = await $api.recurrence.getById(rule.id)+ expect(ownerView?.rule.templateNote).toBe('confidential note')++ // content-watch + deadline-edit, but NOT note-watch+ await grantUser2([TvPermissions.COMPONENT_CAN_WATCH_CONTENT, TvPermissions.TASK_CAN_EDIT_DEADLINE])+ const memberView = await $apiUser2.recurrence.getById(rule.id)+ expect(memberView?.rule.templateNote).toBeNull()+ if (memberView?.openInstance) expect(memberView.openInstance.note).toBeNull()+ })++ it('the note is stripped from mutation responses too (pause)', async () => {+ const { rule } = await createGateRule('Secret pausable', 'hidden note')+ await grantUser2([TvPermissions.COMPONENT_CAN_WATCH_CONTENT, TvPermissions.TASK_CAN_EDIT_DEADLINE])+ const paused = await $apiUser2.recurrence.pause(rule.id)+ expect(paused.templateNote).toBeNull()+ })++ it('skip requires task-delete permission on top of deadline-edit', async () => {+ const { rule } = await createGateRule('Skippable gated', 'note')++ // deadline-edit only: pause is allowed, but skip (which deletes the instance) is forbidden+ await grantUser2([TvPermissions.COMPONENT_CAN_WATCH_CONTENT, TvPermissions.TASK_CAN_EDIT_DEADLINE])+ const skipForbidden = await user2Raw.post(`/module/recurrence/${rule.id}/skip`, {})+ expect(skipForbidden.status).toBe(403)+ const pauseOk = await user2Raw.post(`/module/recurrence/${rule.id}/pause`, {})+ expect(pauseOk.status).toBe(200)+ await user2Raw.post(`/module/recurrence/${rule.id}/resume`, {}) // restore active state++ // grant delete: skip now allowed+ await grantUser2([TvPermissions.COMPONENT_CAN_WATCH_CONTENT, TvPermissions.TASK_CAN_EDIT_DEADLINE, TvPermissions.TASK_CAN_DELETE])+ const skipOk = await user2Raw.post(`/module/recurrence/${rule.id}/skip`, {})+ expect(skipOk.status).toBe(200)+ })+ })})diff --git a/taskview-packages/taskview-api/src/api/recurrence.types.ts b/taskview-packages/taskview-api/src/api/recurrence.types.tsindex 10f8cd4..e43614b 100644--- a/taskview-packages/taskview-api/src/api/recurrence.types.ts+++ b/taskview-packages/taskview-api/src/api/recurrence.types.ts@@ -16,6 +16,8 @@ export type RecurrenceRule = {rrule: string;/** Floating wall-clock 'YYYY-MM-DDTHH:mm:ss' anchor of the series. */dtstart: string;+ /** Whether the series is anchored to a wall-clock time (incl. 00:00) or is date-only. */+ hasTime: boolean;/** IANA timezone name, e.g. 'Europe/Moscow'. */timezone: string;state: RecurrenceState;@@ -36,6 +38,7 @@ export type RecurrenceRuleDetails = {export type RecurrenceCreateArgs = {taskId: number;rrule: string;+ /** 'YYYY-MM-DD' for a date-only series, 'YYYY-MM-DDTHH:mm:ss' for a timed one (incl. 00:00). */dtstart: string;timezone: string;notifyOnOccurrence?: boolean;diff --git a/taskview-packages/taskview-db-schemas/src/schemas/recurrence-rules.schema.ts b/taskview-packages/taskview-db-schemas/src/schemas/recurrence-rules.schema.tsindex da22f6a..27382a8 100644--- a/taskview-packages/taskview-db-schemas/src/schemas/recurrence-rules.schema.ts+++ b/taskview-packages/taskview-db-schemas/src/schemas/recurrence-rules.schema.ts@@ -17,6 +17,7 @@ export const RecurrenceRulesSchema = pgSchema('tasks').table('recurrence_rules',templateDurationMinutes: integer('template_duration_minutes'),rrule: text().notNull(),dtstart: timestamp().notNull(),+ hasTime: boolean('has_time').notNull().default(false),timezone: varchar({ length: 50 }).notNull(),state: varchar({ length: 20 }).$type<RecurrenceState>().notNull().default('active'),lastInstanceDate: date('last_instance_date').notNull(),diff --git a/web/src/components/features/tasks/parts/TaskRecurrence.vue b/web/src/components/features/tasks/parts/TaskRecurrence.vueindex a7b9cd6..0abd24f 100644--- a/web/src/components/features/tasks/parts/TaskRecurrence.vue+++ b/web/src/components/features/tasks/parts/TaskRecurrence.vue@@ -76,6 +76,7 @@ const summary = computed(() => {rrule: rule.rrule,dtstart: new Date(`${rule.dtstart.replace(' ', 'T')}Z`),notifyOnOccurrence: rule.notifyOnOccurrence,+ hasTime: rule.hasTime,})const unit = t(`recurrence.units.${form.frequency}`)diff --git a/web/src/components/features/tasks/parts/TaskRecurrenceDialog.vue b/web/src/components/features/tasks/parts/TaskRecurrenceDialog.vueindex 1159b35..29339cb 100644--- a/web/src/components/features/tasks/parts/TaskRecurrenceDialog.vue+++ b/web/src/components/features/tasks/parts/TaskRecurrenceDialog.vue@@ -28,6 +28,7 @@<div class="flex flex-wrap items-center gap-2"><template v-if="rule"><UButton+ v-if="canDeleteTask":label="t('recurrence.skip')"icon="i-lucide-skip-forward"color="neutral"@@ -71,8 +72,9 @@ import { computed, ref, watch } from 'vue'import { useI18n } from 'vue-i18n'import type { RecurrenceRule, Task } from 'taskview-api'import TaskRecurrenceForm from './TaskRecurrenceForm.vue'-import { buildRruleString, defaultRecurrenceForm, dtstartForTask, parseRruleToForm } from '@/helpers/recurrence'+import { buildDtstartIso, buildRruleString, defaultRecurrenceForm, dtstartForTask, parseRruleToForm } from '@/helpers/recurrence'import { useTaskView } from '@/composables/useTaskView'+import { useGoalPermissions } from '@/composables/useGoalPermissions'import { useTasksStore } from '@/stores/tasks.store'import type { RecurrenceFormValue } from '@/types/recurrence.types'@@ -92,6 +94,8 @@ const emit = defineEmits<{const { t } = useI18n()const toast = useToast()const { isMobile } = useTaskView()+// Skip deletes the open instance, so the server requires TASK_CAN_DELETE for it.+const { canDeleteTask } = useGoalPermissions()const tasksStore = useTasksStore()const actionLoading = ref<DialogAction>(null)@@ -109,9 +113,10 @@ function initialForm(): RecurrenceFormValue {rrule: props.rule.rrule,dtstart: dtstart.value.date,notifyOnOccurrence: props.rule.notifyOnOccurrence,+ hasTime: props.rule.hasTime,})}- return defaultRecurrenceForm(dtstart.value.date)+ return defaultRecurrenceForm(dtstart.value.date, !!props.task.startTime)}const form = ref<RecurrenceFormValue>(initialForm())@@ -128,17 +133,21 @@ async function save() {// user's wall clock, so editing a rule after relocation re-anchors it// ("9:00" stays 9:00 wherever the user lives now).const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'+ // The form's time (incl. 00:00, or none) drives the dtstart anchor; the+ // start day stays whatever the series was anchored to.+ const dtstartIso = buildDtstartIso({ dateStr: dtstart.value.iso.slice(0, 10), time: form.value.time })const result = props.rule? await tasksStore.updateRecurrence({ruleId: props.rule.id,rrule,+ dtstart: dtstartIso,timezone,notifyOnOccurrence: form.value.notifyOnOccurrence,}): await tasksStore.createRecurrence({taskId: props.task.id,rrule,- dtstart: dtstart.value.iso,+ dtstart: dtstartIso,timezone,notifyOnOccurrence: form.value.notifyOnOccurrence,})diff --git a/web/src/components/features/tasks/parts/TaskRecurrenceForm.vue b/web/src/components/features/tasks/parts/TaskRecurrenceForm.vueindex 7d8e196..46a835a 100644--- a/web/src/components/features/tasks/parts/TaskRecurrenceForm.vue+++ b/web/src/components/features/tasks/parts/TaskRecurrenceForm.vue@@ -71,6 +71,20 @@</UPopover></div>+ <div class="flex flex-col gap-2">+ <UCheckbox+ v-model="showTime"+ :label="t('recurrence.selectTime')"+ :ui="{ root: 'items-center' }"+ />+ <UInputTime+ v-if="showTime"+ v-model="timeModel"+ :hour-cycle="24"+ class="self-start"+ />+ </div>+<UCheckboxv-model="form.notifyOnOccurrence":label="t('recurrence.notifyOnOccurrence')"@@ -94,10 +108,10 @@</template><script setup lang="ts">-import { computed, shallowRef, watch } from 'vue'+import { computed, ref, shallowRef, watch } from 'vue'import { useI18n } from 'vue-i18n'import { useDateFormat } from '@vueuse/core'-import { CalendarDate } from '@internationalized/date'+import { CalendarDate, Time } from '@internationalized/date'import { buildRruleString, previewOccurrences } from '@/helpers/recurrence'import { useWeekStart } from '@/composables/useWeekStart'import type { RecurrenceFormValue } from '@/types/recurrence.types'@@ -162,6 +176,41 @@ function parseCalendarDate(date: string): CalendarDate {return new CalendarDate(year, month, day)}+const pad = (n: number) => String(n).padStart(2, '0')+const timeToString = (time: Time | undefined): string | null => (time ? `${pad(time.hour)}:${pad(time.minute)}` : null)+const timeFromString = (value: string | null): Time | undefined => {+ if (!value) return undefined+ const [hour, minute] = value.split(':').map(Number)+ return new Time(hour, minute)+}++const showTime = ref(form.value.time !== null)+const timeModel = shallowRef<Time | undefined>(timeFromString(form.value.time))++// External resets (dialog re-inits the form on open) → local state.+watch(() => form.value.time, (value) => {+ if (timeToString(timeModel.value) === value && showTime.value === (value !== null)) return+ showTime.value = value !== null+ timeModel.value = timeFromString(value)+})++watch(showTime, (on) => {+ if (!on) {+ timeModel.value = undefined+ if (form.value.time !== null) form.value.time = null+ return+ }+ if (!timeModel.value) timeModel.value = new Time(9, 0)+ const next = timeToString(timeModel.value)+ if (form.value.time !== next) form.value.time = next+})++watch(timeModel, (time) => {+ if (!showTime.value) return+ const next = timeToString(time)+ if (form.value.time !== next) form.value.time = next+})+const preview = computed(() => {const rrule = buildRruleString({ form: form.value, dtstart: props.dtstart })return previewOccurrences({ rrule, dtstart: props.dtstart, limit: PREVIEW_LIMIT })diff --git a/web/src/composables/useCentrifugo/handlers/recurrence.ts b/web/src/composables/useCentrifugo/handlers/recurrence.tsindex 38fb2f1..9caae17 100644--- a/web/src/composables/useCentrifugo/handlers/recurrence.ts+++ b/web/src/composables/useCentrifugo/handlers/recurrence.ts@@ -2,5 +2,5 @@ import { useTasksStore } from '@/stores/tasks.store'import type { RealtimeEventMap } from '../types'export function handleRecurrenceInstanceCreated(data: RealtimeEventMap['recurrence.instanceCreated']) {- useTasksStore().handleRecurrenceInstanceCreated(data.task)+ useTasksStore().handleRecurrenceInstanceCreated({ goalId: data.goalId, taskId: data.taskId })}diff --git a/web/src/composables/useCentrifugo/types.ts b/web/src/composables/useCentrifugo/types.tsindex e26fc19..4c23ac3 100644--- a/web/src/composables/useCentrifugo/types.ts+++ b/web/src/composables/useCentrifugo/types.ts@@ -1,4 +1,4 @@-import type { Notification, Task, TimeEntryItem } from 'taskview-api'+import type { Notification, TimeEntryItem } from 'taskview-api'export type RealtimeEventMap = {'notification': {@@ -34,11 +34,13 @@ export type RealtimeEventMap = {entryId: numbertaskId: number}+ // Ids only: task fields are permission-gated per role, so the payload never+ // carries content — the client fetches the task through REST.'recurrence.instanceCreated': {event: 'recurrence.instanceCreated'goalId: numberruleId: number- task: Task+ taskId: number}}diff --git a/web/src/helpers/recurrence.ts b/web/src/helpers/recurrence.tsindex dfe8c13..5ad7642 100644--- a/web/src/helpers/recurrence.ts+++ b/web/src/helpers/recurrence.ts@@ -20,7 +20,13 @@ export function jsDayToRruleWeekday(jsDay: number): number {return (jsDay + 6) % 7}-export function defaultRecurrenceForm(dtstart: Date): RecurrenceFormValue {+/** 'HH:mm' wall-clock time from a floating dtstart Date (UTC components = wall clock). */+function timeFromDtstart(dtstart: Date): string {+ const pad = (n: number) => String(n).padStart(2, '0')+ return `${pad(dtstart.getUTCHours())}:${pad(dtstart.getUTCMinutes())}`+}++export function defaultRecurrenceForm(dtstart: Date, hasTime: boolean): RecurrenceFormValue {return {frequency: 'weekly',interval: 1,@@ -29,6 +35,7 @@ export function defaultRecurrenceForm(dtstart: Date): RecurrenceFormValue {ends: 'never',count: 10,untilDate: null,+ time: hasTime ? timeFromDtstart(dtstart) : null,notifyOnOccurrence: false,}}@@ -54,8 +61,8 @@ export function buildRruleString(args: { form: RecurrenceFormValue; dtstart: Datreturn RRule.optionsToString({ ...new RRule(options).origOptions }).replace(/^RRULE:/, '')}-export function parseRruleToForm(args: { rrule: string; dtstart: Date; notifyOnOccurrence: boolean }): RecurrenceFormValue {- const form = defaultRecurrenceForm(args.dtstart)+export function parseRruleToForm(args: { rrule: string; dtstart: Date; notifyOnOccurrence: boolean; hasTime: boolean }): RecurrenceFormValue {+ const form = defaultRecurrenceForm(args.dtstart, args.hasTime)form.notifyOnOccurrence = args.notifyOnOccurrenceconst options = RRule.parseString(args.rrule)if (options.freq !== undefined && RRULE_TO_FREQ[options.freq]) {@@ -99,18 +106,28 @@ export function previewOccurrences(args: { rrule: string; dtstart: Date; limit:* Timed values are stored in UTC, while the series is anchored to the user's* wall clock (the browser timezone is what gets sent as the rule timezone) —* so the stored instant is converted to local components first.+ *+ * The series inherits "has time" from the task: a task with a start time+ * (incl. midnight) yields a 'YYYY-MM-DDTHH:mm:ss' iso (timed series); a task+ * without one yields a date-only 'YYYY-MM-DD' iso so the backend keeps it+ * date-only instead of treating a midnight anchor as a real 00:00 deadline.*/export function dtstartForTask(args: { startDate: string | null; startTime: string | null }): { date: Date; iso: string } {- let iso: stringif (args.startDate && args.startTime?.match(/^\d{2}:\d{2}/)) {const instant = new Date(`${args.startDate}T${args.startTime.slice(0, 5)}:00Z`)- iso = `${formatLocalDate(instant)}T${formatLocalTime(instant)}`- } else if (args.startDate) {- iso = `${args.startDate}T00:00:00`- } else {- iso = `${formatLocalDate(new Date())}T00:00:00`+ const iso = `${formatLocalDate(instant)}T${formatLocalTime(instant)}`+ return { date: new Date(`${iso}Z`), iso }}- return { date: new Date(`${iso}Z`), iso }+ const dateOnly = args.startDate ?? formatLocalDate(new Date())+ return { date: new Date(`${dateOnly}T00:00:00Z`), iso: dateOnly }+}++/**+ * dtstart string to send: 'YYYY-MM-DDTHH:mm:ss' when a wall-clock time is set+ * (incl. 00:00), or date-only 'YYYY-MM-DD' otherwise. `time` is 'HH:mm'.+ */+export function buildDtstartIso(args: { dateStr: string; time: string | null }): string {+ return args.time ? `${args.dateStr}T${args.time}:00` : args.dateStr}function formatLocalDate(date: Date): string {diff --git a/web/src/locales/en.ts b/web/src/locales/en.tsindex 2e5b0d8..7741b36 100644--- a/web/src/locales/en.ts+++ b/web/src/locales/en.ts@@ -213,6 +213,7 @@ export default {pause: 'Pause',resume: 'Resume',deleteSeries: 'Delete series',+ selectTime: 'Select time',notifyOnOccurrence: 'Remind about each occurrence',preview: 'Next occurrences',frequency: {diff --git a/web/src/locales/ru.ts b/web/src/locales/ru.tsindex 56c6bbb..4ab993e 100644--- a/web/src/locales/ru.ts+++ b/web/src/locales/ru.ts@@ -213,6 +213,7 @@ export default {pause: 'Пауза',resume: 'Продолжить',deleteSeries: 'Удалить серию',+ selectTime: 'Выбрать время',notifyOnOccurrence: 'Напоминать о каждом повторении',preview: 'Ближайшие повторения',frequency: {diff --git a/web/src/stores/tasks.store.ts b/web/src/stores/tasks.store.tsindex ffebfc2..c3125c1 100644--- a/web/src/stores/tasks.store.ts+++ b/web/src/stores/tasks.store.ts@@ -613,7 +613,7 @@ export const useTasksStore = defineStore('tasks', {this.tasks = this.tasks.filter(({ id }) => id !== args.taskId)if (details.openInstance) {- this.handleRecurrenceInstanceCreated(details.openInstance)+ this.insertRecurrenceInstance(details.openInstance)if (this.selectedTask?.id === args.taskId) {this.selectedTask = details.openInstance}@@ -630,11 +630,18 @@ export const useTasksStore = defineStore('tasks', {return true},- /** Realtime: the next instance of a series was materialized on the server. */- handleRecurrenceInstanceCreated(task: Task) {+ async handleRecurrenceInstanceCreated(data: { goalId: number; taskId: number }) {+ if (Number(this.fetchRules.goalId) !== data.goalId) return+ if (this.tasks.some(({ id }) => id === data.taskId)) return+ const task = await $tvApi.tasks.fetchTaskById(data.taskId).catch(() => null)+ if (!task) return+ this.insertRecurrenceInstance(task)+ },++ insertRecurrenceInstance(task: Task) {if (this.tasks.some(({ id }) => id === task.id)) returnif (Number(this.fetchRules.goalId) !== task.goalId) return- // Raw realtime payload may carry no relations — normalize to the client Task shape.+ // Normalize to the client Task shape in case relations are missing.this.tasks.unshift({...task,tags: task.tags ?? [],diff --git a/web/src/types/recurrence.types.ts b/web/src/types/recurrence.types.tsindex 50ce8aa..5bd4958 100644--- a/web/src/types/recurrence.types.ts+++ b/web/src/types/recurrence.types.ts@@ -12,5 +12,7 @@ export type RecurrenceFormValue = {count: number/** 'YYYY-MM-DD', used when ends is 'onDate'. */untilDate: string | null+ /** 'HH:mm' wall-clock time of the series, or null for a date-only series. */+ time: string | nullnotifyOnOccurrence: boolean}