Fix BASE_URL config loading, add tasks/projects; robust .env path resolution

- Config: try ENV_FILE, .env, ../.env for loading; trim trailing slash from BaseURL
- Log BASE_URL at server startup for verification
- .env.example: document BASE_URL
- Tasks, projects, tags, migrations and related API/handlers

Made-with: Cursor

internal/api/handlers/project.go

@@ -0,0 +1,185 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/calendarapi/internal/middleware"
+	"github.com/calendarapi/internal/models"
+	"github.com/calendarapi/internal/service"
+	"github.com/calendarapi/internal/utils"
+	"github.com/go-chi/chi/v5"
+)
+
+type ProjectHandler struct {
+	projectSvc *service.ProjectService
+}
+
+func NewProjectHandler(projectSvc *service.ProjectService) *ProjectHandler {
+	return &ProjectHandler{projectSvc: projectSvc}
+}
+
+func (h *ProjectHandler) List(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+
+	projects, err := h.projectSvc.List(r.Context(), userID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteList(w, projects, models.PageInfo{Limit: len(projects)})
+}
+
+func (h *ProjectHandler) Create(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+
+	var req struct {
+		Name     string  `json:"name"`
+		Color    *string `json:"color"`
+		IsShared *bool   `json:"is_shared"`
+		Deadline *string `json:"deadline"`
+		SortOrder *int   `json:"sort_order"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	createReq := service.CreateProjectRequest{
+		Name:     req.Name,
+		Color:    req.Color,
+		IsShared: req.IsShared,
+		SortOrder: req.SortOrder,
+	}
+	if req.Deadline != nil {
+		if t, err := utils.ParseTime(*req.Deadline); err == nil {
+			createReq.Deadline = &t
+		}
+	}
+
+	project, err := h.projectSvc.Create(r.Context(), userID, createReq)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"project": project})
+}
+
+func (h *ProjectHandler) Get(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	project, err := h.projectSvc.Get(r.Context(), userID, projectID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"project": project})
+}
+
+func (h *ProjectHandler) Update(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	var req struct {
+		Name     *string `json:"name"`
+		Color    *string `json:"color"`
+		IsShared *bool   `json:"is_shared"`
+		Deadline *string `json:"deadline"`
+		SortOrder *int   `json:"sort_order"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	updateReq := service.UpdateProjectRequest{
+		Name:     req.Name,
+		Color:    req.Color,
+		IsShared: req.IsShared,
+		SortOrder: req.SortOrder,
+	}
+	if req.Deadline != nil {
+		if t, err := utils.ParseTime(*req.Deadline); err == nil {
+			updateReq.Deadline = &t
+		}
+	}
+
+	project, err := h.projectSvc.Update(r.Context(), userID, projectID, updateReq)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"project": project})
+}
+
+func (h *ProjectHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.projectSvc.Delete(r.Context(), userID, projectID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}
+
+func (h *ProjectHandler) Share(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	var req struct {
+		Target struct {
+			Email string `json:"email"`
+		} `json:"target"`
+		Role string `json:"role"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.projectSvc.Share(r.Context(), userID, projectID, req.Target.Email, req.Role); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}
+
+func (h *ProjectHandler) ListMembers(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	members, err := h.projectSvc.ListMembers(r.Context(), userID, projectID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"members": members})
+}

internal/api/handlers/tag.go

@@ -0,0 +1,159 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/calendarapi/internal/middleware"
+	"github.com/calendarapi/internal/models"
+	"github.com/calendarapi/internal/service"
+	"github.com/calendarapi/internal/utils"
+	"github.com/go-chi/chi/v5"
+)
+
+type TagHandler struct {
+	tagSvc *service.TagService
+}
+
+func NewTagHandler(tagSvc *service.TagService) *TagHandler {
+	return &TagHandler{tagSvc: tagSvc}
+}
+
+func (h *TagHandler) List(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+
+	tags, err := h.tagSvc.List(r.Context(), userID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteList(w, tags, models.PageInfo{Limit: len(tags)})
+}
+
+func (h *TagHandler) Create(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+
+	var req struct {
+		Name  string  `json:"name"`
+		Color *string `json:"color"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	tag, err := h.tagSvc.Create(r.Context(), userID, service.CreateTagRequest{
+		Name:  req.Name,
+		Color: req.Color,
+	})
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"tag": tag})
+}
+
+func (h *TagHandler) Get(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	tagID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	tag, err := h.tagSvc.Get(r.Context(), userID, tagID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"tag": tag})
+}
+
+func (h *TagHandler) Update(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	tagID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	var req struct {
+		Name  *string `json:"name"`
+		Color *string `json:"color"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	tag, err := h.tagSvc.Update(r.Context(), userID, tagID, service.UpdateTagRequest{
+		Name:  req.Name,
+		Color: req.Color,
+	})
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"tag": tag})
+}
+
+func (h *TagHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	tagID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.tagSvc.Delete(r.Context(), userID, tagID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}
+
+func (h *TagHandler) AttachToTask(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	tagID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "taskId"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.tagSvc.AttachToTask(r.Context(), userID, tagID, taskID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}
+
+func (h *TagHandler) DetachFromTask(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	tagID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "taskId"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.tagSvc.DetachFromTask(r.Context(), userID, tagID, taskID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}

internal/api/handlers/task.go

@@ -0,0 +1,263 @@
+package handlers
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/calendarapi/internal/middleware"
+	"github.com/calendarapi/internal/models"
+	"github.com/calendarapi/internal/service"
+	"github.com/calendarapi/internal/utils"
+	"github.com/go-chi/chi/v5"
+)
+
+type TaskHandler struct {
+	taskSvc *service.TaskService
+}
+
+func NewTaskHandler(taskSvc *service.TaskService) *TaskHandler {
+	return &TaskHandler{taskSvc: taskSvc}
+}
+
+func (h *TaskHandler) List(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	q := r.URL.Query()
+
+	params := service.ListTasksParams{
+		Limit: 50,
+	}
+	if s := q.Get("status"); s != "" {
+		params.Status = &s
+	}
+	if p := q.Get("priority"); p != "" {
+		params.Priority = &p
+	}
+	if pid := q.Get("project_id"); pid != "" {
+		if id, err := utils.ValidateUUID(pid); err == nil {
+			params.ProjectID = &id
+		}
+	}
+	if df := q.Get("due_from"); df != "" {
+		if t, err := utils.ParseTime(df); err == nil {
+			params.DueFrom = &t
+		}
+	}
+	if dt := q.Get("due_to"); dt != "" {
+		if t, err := utils.ParseTime(dt); err == nil {
+			params.DueTo = &t
+		}
+	}
+	if l := q.Get("limit"); l != "" {
+		if v, err := strconv.Atoi(l); err == nil {
+			params.Limit = v
+		}
+	}
+	params.Cursor = q.Get("cursor")
+
+	tasks, cursor, err := h.taskSvc.List(r.Context(), userID, params)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	limit := int(utils.ClampLimit(params.Limit))
+	page := models.PageInfo{Limit: limit}
+	if cursor != nil {
+		page.NextCursor = cursor
+	}
+	utils.WriteList(w, tasks, page)
+}
+
+func (h *TaskHandler) Create(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+
+	var req struct {
+		Title          string  `json:"title"`
+		Description    *string `json:"description"`
+		Status         *string `json:"status"`
+		Priority       *string `json:"priority"`
+		DueDate        *string `json:"due_date"`
+		ProjectID      *string `json:"project_id"`
+		ParentID       *string `json:"parent_id"`
+		SortOrder      *int    `json:"sort_order"`
+		RecurrenceRule *string `json:"recurrence_rule"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	createReq := service.CreateTaskRequest{
+		Title:          req.Title,
+		Description:    req.Description,
+		Status:         req.Status,
+		Priority:       req.Priority,
+		SortOrder:      req.SortOrder,
+		RecurrenceRule: req.RecurrenceRule,
+	}
+	if req.DueDate != nil {
+		if t, err := utils.ParseTime(*req.DueDate); err == nil {
+			createReq.DueDate = &t
+		}
+	}
+	if req.ProjectID != nil {
+		if id, err := utils.ValidateUUID(*req.ProjectID); err == nil {
+			createReq.ProjectID = &id
+		}
+	}
+	if req.ParentID != nil {
+		if id, err := utils.ValidateUUID(*req.ParentID); err == nil {
+			createReq.ParentID = &id
+		}
+	}
+
+	task, err := h.taskSvc.Create(r.Context(), userID, createReq)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"task": task})
+}
+
+func (h *TaskHandler) Get(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	task, err := h.taskSvc.Get(r.Context(), userID, taskID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"task": task})
+}
+
+func (h *TaskHandler) Update(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	var req struct {
+		Title          *string `json:"title"`
+		Description    *string `json:"description"`
+		Status         *string `json:"status"`
+		Priority       *string `json:"priority"`
+		DueDate        *string `json:"due_date"`
+		ProjectID      *string `json:"project_id"`
+		SortOrder      *int    `json:"sort_order"`
+		RecurrenceRule *string `json:"recurrence_rule"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	updateReq := service.UpdateTaskRequest{
+		Title:          req.Title,
+		Description:    req.Description,
+		Status:         req.Status,
+		Priority:       req.Priority,
+		SortOrder:      req.SortOrder,
+		RecurrenceRule: req.RecurrenceRule,
+	}
+	if req.DueDate != nil {
+		if t, err := utils.ParseTime(*req.DueDate); err == nil {
+			updateReq.DueDate = &t
+		}
+	}
+	if req.ProjectID != nil {
+		if id, err := utils.ValidateUUID(*req.ProjectID); err == nil {
+			updateReq.ProjectID = &id
+		}
+	}
+
+	task, err := h.taskSvc.Update(r.Context(), userID, taskID, updateReq)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"task": task})
+}
+
+func (h *TaskHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	permanent := r.URL.Query().Get("permanent") == "true"
+
+	if err := h.taskSvc.Delete(r.Context(), userID, taskID, permanent); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}
+
+func (h *TaskHandler) MarkComplete(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	task, err := h.taskSvc.MarkComplete(r.Context(), userID, taskID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"task": task})
+}
+
+func (h *TaskHandler) MarkUncomplete(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	var req struct {
+		Status *string `json:"status"`
+	}
+	_ = utils.DecodeJSON(r, &req)
+
+	task, err := h.taskSvc.MarkUncomplete(r.Context(), userID, taskID, req.Status)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"task": task})
+}
+
+func (h *TaskHandler) ListSubtasks(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	tasks, err := h.taskSvc.ListSubtasks(r.Context(), userID, taskID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteList(w, tasks, models.PageInfo{Limit: len(tasks)})
+}

internal/api/handlers/task_dependency.go

@@ -0,0 +1,88 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/calendarapi/internal/middleware"
+	"github.com/calendarapi/internal/models"
+	"github.com/calendarapi/internal/service"
+	"github.com/calendarapi/internal/utils"
+	"github.com/go-chi/chi/v5"
+)
+
+type TaskDependencyHandler struct {
+	depSvc *service.TaskDependencyService
+}
+
+func NewTaskDependencyHandler(depSvc *service.TaskDependencyService) *TaskDependencyHandler {
+	return &TaskDependencyHandler{depSvc: depSvc}
+}
+
+func (h *TaskDependencyHandler) ListBlockers(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	tasks, err := h.depSvc.ListBlockers(r.Context(), userID, taskID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteList(w, tasks, models.PageInfo{Limit: len(tasks)})
+}
+
+func (h *TaskDependencyHandler) Add(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	var req struct {
+		BlocksTaskID string `json:"blocks_task_id"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	blocksTaskID, err := utils.ValidateUUID(req.BlocksTaskID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.depSvc.Add(r.Context(), userID, taskID, blocksTaskID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}
+
+func (h *TaskDependencyHandler) Remove(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	blocksTaskID, err := utils.ValidateUUID(chi.URLParam(r, "blocksTaskId"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.depSvc.Remove(r.Context(), userID, taskID, blocksTaskID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}

internal/api/handlers/task_reminder.go

@@ -0,0 +1,94 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/calendarapi/internal/middleware"
+	"github.com/calendarapi/internal/models"
+	"github.com/calendarapi/internal/service"
+	"github.com/calendarapi/internal/utils"
+	"github.com/go-chi/chi/v5"
+)
+
+type TaskReminderHandler struct {
+	reminderSvc *service.TaskReminderService
+}
+
+func NewTaskReminderHandler(reminderSvc *service.TaskReminderService) *TaskReminderHandler {
+	return &TaskReminderHandler{reminderSvc: reminderSvc}
+}
+
+func (h *TaskReminderHandler) List(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	reminders, err := h.reminderSvc.List(r.Context(), userID, taskID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteList(w, reminders, models.PageInfo{Limit: len(reminders)})
+}
+
+func (h *TaskReminderHandler) Add(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	var req struct {
+		Type        string                 `json:"type"`
+		Config      map[string]interface{} `json:"config"`
+		ScheduledAt string                 `json:"scheduled_at"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	t, err := utils.ParseTime(req.ScheduledAt)
+	if err != nil {
+		utils.WriteError(w, models.NewValidationError("invalid scheduled_at"))
+		return
+	}
+
+	reminder, err := h.reminderSvc.Create(r.Context(), userID, taskID, service.CreateTaskReminderRequest{
+		Type:        req.Type,
+		Config:      req.Config,
+		ScheduledAt: t,
+	})
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"reminder": reminder})
+}
+
+func (h *TaskReminderHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	taskID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+	reminderID, err := utils.ValidateUUID(chi.URLParam(r, "reminderId"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.reminderSvc.Delete(r.Context(), userID, taskID, reminderID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}

internal/api/handlers/task_webhook.go

@@ -0,0 +1,73 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/calendarapi/internal/middleware"
+	"github.com/calendarapi/internal/models"
+	"github.com/calendarapi/internal/service"
+	"github.com/calendarapi/internal/utils"
+	"github.com/go-chi/chi/v5"
+)
+
+type TaskWebhookHandler struct {
+	webhookSvc *service.TaskWebhookService
+}
+
+func NewTaskWebhookHandler(webhookSvc *service.TaskWebhookService) *TaskWebhookHandler {
+	return &TaskWebhookHandler{webhookSvc: webhookSvc}
+}
+
+func (h *TaskWebhookHandler) List(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+
+	webhooks, err := h.webhookSvc.List(r.Context(), userID)
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteList(w, webhooks, models.PageInfo{Limit: len(webhooks)})
+}
+
+func (h *TaskWebhookHandler) Create(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+
+	var req struct {
+		URL    string   `json:"url"`
+		Events []string `json:"events"`
+		Secret *string  `json:"secret"`
+	}
+	if err := utils.DecodeJSON(r, &req); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	webhook, err := h.webhookSvc.Create(r.Context(), userID, service.TaskWebhookCreateRequest{
+		URL:    req.URL,
+		Events: req.Events,
+		Secret: req.Secret,
+	})
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"webhook": webhook})
+}
+
+func (h *TaskWebhookHandler) Delete(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.GetUserID(r.Context())
+	webhookID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
+	if err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	if err := h.webhookSvc.Delete(r.Context(), userID, webhookID); err != nil {
+		utils.WriteError(w, err)
+		return
+	}
+
+	utils.WriteOK(w)
+}