@nexttylabs/echo 0.2.0

package/lib/db/schema/status-history.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { relations } from "drizzle-orm";
+import {
+  index,
+  pgTable,
+  serial,
+  text,
+  timestamp,
+  integer,
+} from "drizzle-orm/pg-core";
+import { feedback } from "./feedback";
+import { user } from "./auth";
+
+export const statusHistory = pgTable(
+  "status_history",
+  {
+    historyId: serial("historyId").primaryKey(),
+    feedbackId: integer("feedbackId")
+      .notNull()
+      .references(() => feedback.feedbackId, { onDelete: "cascade" }),
+    oldStatus: text("oldStatus").notNull(),
+    newStatus: text("newStatus").notNull(),
+    changedBy: text("changedBy").references(() => user.id, {
+      onDelete: "set null",
+    }),
+    changedAt: timestamp("changedAt").defaultNow().notNull(),
+    comment: text("comment"),
+  },
+  (table) => ({
+    feedbackIdx: index("idx_status_history_feedbackId").on(table.feedbackId),
+    changedAtIdx: index("idx_status_history_changedAt").on(table.changedAt),
+  }),
+);
+
+export const statusHistoryRelations = relations(statusHistory, ({ one }) => ({
+  feedback: one(feedback, {
+    fields: [statusHistory.feedbackId],
+    references: [feedback.feedbackId],
+  }),
+  changedByUser: one(user, {
+    fields: [statusHistory.changedBy],
+    references: [user.id],
+  }),
+}));
+
+export type StatusHistory = typeof statusHistory.$inferSelect;
+export type NewStatusHistory = typeof statusHistory.$inferInsert;

package/lib/db/schema/tags.ts

@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { relations } from "drizzle-orm";
+import {
+  index,
+  integer,
+  pgTable,
+  serial,
+  text,
+  timestamp,
+} from "drizzle-orm/pg-core";
+import { feedback } from "./feedback";
+
+export const tags = pgTable("tags", {
+  tagId: serial("tagId").primaryKey(),
+  name: text("name").notNull().unique(),
+  slug: text("slug").notNull().unique(),
+  color: text("color").default("#3b82f6"),
+  description: text("description"),
+  createdAt: timestamp("createdAt").defaultNow().notNull(),
+});
+
+export const feedbackTags = pgTable(
+  "feedback_tags",
+  {
+    id: serial("id").primaryKey(),
+    feedbackId: integer("feedbackId")
+      .notNull()
+      .references(() => feedback.feedbackId, { onDelete: "cascade" }),
+    tagId: integer("tagId")
+      .notNull()
+      .references(() => tags.tagId, { onDelete: "cascade" }),
+    createdAt: timestamp("createdAt").defaultNow().notNull(),
+  },
+  (table) => ({
+    feedbackIdIdx: index("idx_feedback_tags_feedbackId").on(table.feedbackId),
+    tagIdIdx: index("idx_feedback_tags_tagId").on(table.tagId),
+    uniqueFeedbackTag: index("idx_feedback_tags_unique").on(
+      table.feedbackId,
+      table.tagId,
+    ),
+  }),
+);
+
+export const tagsRelations = relations(tags, ({ many }) => ({
+  feedbackTags: many(feedbackTags),
+}));
+
+export const feedbackTagsRelations = relations(feedbackTags, ({ one }) => ({
+  feedback: one(feedback, {
+    fields: [feedbackTags.feedbackId],
+    references: [feedback.feedbackId],
+  }),
+  tag: one(tags, {
+    fields: [feedbackTags.tagId],
+    references: [tags.tagId],
+  }),
+}));
+
+export const PREDEFINED_TAGS = [
+  {
+    name: "Performance",
+    slug: "performance",
+    keywords: [
+      "performance",
+      "slow",
+      "lag",
+      "性能",
+      "慢",
+      "卡顿",
+      "延迟",
+      "优化",
+    ],
+  },
+  {
+    name: "UI/UX",
+    slug: "ui-ux",
+    keywords: [
+      "ui",
+      "ux",
+      "interface",
+      "design",
+      "layout",
+      "界面",
+      "设计",
+      "布局",
+      "体验",
+    ],
+  },
+  {
+    name: "Security",
+    slug: "security",
+    keywords: [
+      "security",
+      "auth",
+      "permission",
+      "安全",
+      "权限",
+      "认证",
+      "登录",
+    ],
+  },
+  {
+    name: "Mobile",
+    slug: "mobile",
+    keywords: ["mobile", "ios", "android", "app", "phone", "移动", "手机"],
+  },
+  {
+    name: "API",
+    slug: "api",
+    keywords: ["api", "endpoint", "integration", "接口", "集成"],
+  },
+  {
+    name: "Database",
+    slug: "database",
+    keywords: ["database", "db", "query", "data", "数据库", "查询", "数据"],
+  },
+  {
+    name: "Documentation",
+    slug: "documentation",
+    keywords: [
+      "docs",
+      "documentation",
+      "guide",
+      "tutorial",
+      "文档",
+      "指南",
+      "教程",
+    ],
+  },
+  {
+    name: "Accessibility",
+    slug: "accessibility",
+    keywords: ["a11y", "accessibility", "screen reader", "无障碍", "辅助"],
+  },
+  {
+    name: "Localization",
+    slug: "localization",
+    keywords: [
+      "i18n",
+      "l10n",
+      "localization",
+      "translation",
+      "language",
+      "国际化",
+      "翻译",
+      "语言",
+    ],
+  },
+  {
+    name: "Testing",
+    slug: "testing",
+    keywords: ["test", "testing", "spec", "测试"],
+  },
+  {
+    name: "Billing",
+    slug: "billing",
+    keywords: [
+      "billing",
+      "payment",
+      "price",
+      "subscription",
+      "账单",
+      "支付",
+      "价格",
+      "订阅",
+    ],
+  },
+  {
+    name: "Integration",
+    slug: "integration",
+    keywords: ["integration", "webhook", "third-party", "集成", "第三方"],
+  },
+] as const;
+
+export type Tag = typeof tags.$inferSelect;
+export type NewTag = typeof tags.$inferInsert;
+export type FeedbackTag = typeof feedbackTags.$inferSelect;
+export type NewFeedbackTag = typeof feedbackTags.$inferInsert;

package/lib/db/schema/user-profiles.ts

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { user } from "./auth";
+
+export const userProfiles = pgTable("user_profiles", {
+  userId: text("user_id")
+    .primaryKey()
+    .references(() => user.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at")
+    .defaultNow()
+    .$onUpdate(() => new Date())
+    .notNull(),
+});

package/lib/db/schema/votes.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { relations } from "drizzle-orm";
+import {
+  index,
+  pgTable,
+  serial,
+  text,
+  timestamp,
+  unique,
+} from "drizzle-orm/pg-core";
+import { feedback } from "./feedback";
+import { user } from "./auth";
+
+export const votes = pgTable(
+  "votes",
+  {
+    voteId: serial("voteId").primaryKey(),
+    feedbackId: serial("feedbackId")
+      .notNull()
+      .references(() => feedback.feedbackId, { onDelete: "cascade" }),
+    visitorId: text("visitorId"),
+    userId: text("userId").references(() => user.id, { onDelete: "set null" }),
+    createdAt: timestamp("createdAt").defaultNow().notNull(),
+  },
+  (table) => ({
+    feedbackIdx: index("idx_votes_feedbackId").on(table.feedbackId),
+    userIdx: index("idx_votes_userId").on(table.userId),
+    uniqueVote: unique("unique_vote").on(table.feedbackId, table.visitorId),
+  }),
+);
+
+export const votesRelations = relations(votes, ({ one }) => ({
+  feedback: one(feedback, {
+    fields: [votes.feedbackId],
+    references: [feedback.feedbackId],
+  }),
+  user: one(user, {
+    fields: [votes.userId],
+    references: [user.id],
+  }),
+}));
+
+export type Vote = typeof votes.$inferSelect;
+export type NewVote = typeof votes.$inferInsert;

package/lib/db/schema/webhooks.ts

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { relations } from "drizzle-orm";
+import {
+  boolean,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  serial,
+  text,
+  timestamp,
+} from "drizzle-orm/pg-core";
+import { organizations } from "./organizations";
+
+export const webhooks = pgTable(
+  "webhooks",
+  {
+    webhookId: serial("webhookId").primaryKey(),
+    organizationId: text("organizationId")
+      .notNull()
+      .references(() => organizations.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    url: text("url").notNull(),
+    secret: text("secret"),
+    events: jsonb("events").$type<string[]>().notNull(),
+    enabled: boolean("enabled").notNull().default(true),
+    createdAt: timestamp("createdAt").defaultNow().notNull(),
+    updatedAt: timestamp("updatedAt")
+      .defaultNow()
+      .$onUpdate(() => new Date())
+      .notNull(),
+  },
+  (table) => ({
+    orgIdx: index("idx_webhooks_orgId").on(table.organizationId),
+    enabledIdx: index("idx_webhooks_enabled").on(table.enabled),
+  }),
+);
+
+export const webhookEvents = pgTable(
+  "webhook_events",
+  {
+    eventId: serial("eventId").primaryKey(),
+    webhookId: integer("webhookId")
+      .notNull()
+      .references(() => webhooks.webhookId, { onDelete: "cascade" }),
+    eventType: text("eventType").notNull(),
+    payload: jsonb("payload").notNull(),
+    status: text("status", {
+      enum: ["pending", "sending", "delivered", "failed"],
+    })
+      .notNull()
+      .default("pending"),
+    responseStatus: integer("responseStatus"),
+    responseBody: text("responseBody"),
+    retryCount: integer("retryCount").notNull().default(0),
+    maxRetries: integer("maxRetries").notNull().default(3),
+    nextRetryAt: timestamp("nextRetryAt"),
+    deliveredAt: timestamp("deliveredAt"),
+    createdAt: timestamp("createdAt").defaultNow().notNull(),
+    updatedAt: timestamp("updatedAt")
+      .defaultNow()
+      .$onUpdate(() => new Date())
+      .notNull(),
+  },
+  (table) => ({
+    webhookIdx: index("idx_webhook_events_webhookId").on(table.webhookId),
+    statusIdx: index("idx_webhook_events_status").on(table.status),
+    nextRetryIdx: index("idx_webhook_events_nextRetry").on(table.nextRetryAt),
+  }),
+);
+
+export const webhooksRelations = relations(webhooks, ({ one, many }) => ({
+  organization: one(organizations, {
+    fields: [webhooks.organizationId],
+    references: [organizations.id],
+  }),
+  events: many(webhookEvents),
+}));
+
+export const webhookEventsRelations = relations(webhookEvents, ({ one }) => ({
+  webhook: one(webhooks, {
+    fields: [webhookEvents.webhookId],
+    references: [webhooks.webhookId],
+  }),
+}));
+
+export type Webhook = typeof webhooks.$inferSelect;
+export type NewWebhook = typeof webhooks.$inferInsert;
+export type WebhookEvent = typeof webhookEvents.$inferSelect;
+export type NewWebhookEvent = typeof webhookEvents.$inferInsert;

package/lib/feedback/filters.ts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+export function parseCsvParam(value?: string | null) {
+  if (!value) return [];
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function serializeCsvParam(values: string[]) {
+  return values.filter(Boolean).join(",");
+}

package/lib/feedback/find-similar.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import {
+  findDuplicates,
+  type DuplicateCandidate,
+  type FeedbackForDuplicateCheck,
+} from "@/lib/services/ai/duplicate-detector";
+
+export type SimilarFeedback = DuplicateCandidate;
+
+/**
+ * Build a list of similar feedbacks based on title and description.
+ * Reuses the duplicate detection algorithm.
+ */
+export function buildSimilarResponse(
+  title: string,
+  description: string,
+  existingFeedbacks: Array<{
+    feedbackId: number;
+    title: string;
+    description?: string | null;
+  }>,
+  threshold: number = 0.3
+): SimilarFeedback[] {
+  const feedbacks: FeedbackForDuplicateCheck[] = existingFeedbacks.map(
+    (item) => ({
+      feedbackId: item.feedbackId,
+      title: item.title,
+      description: item.description ?? null,
+    })
+  );
+
+  return findDuplicates(title, description, feedbacks, undefined, threshold);
+}

package/lib/feedback/get-feedback-by-id.ts

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2026 Echo Team
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import type { db as database } from "@/lib/db";
+import { feedback, attachments, user, votes, statusHistory } from "@/lib/db/schema";
+import { eq, desc } from "drizzle-orm";
+
+type Database = NonNullable<typeof database>;
+
+type DbShape = {
+  select: Database["select"];
+};
+
+export type GetFeedbackByIdOptions = {
+  userId?: string | null;
+  visitorId?: string | null;
+};
+
+export async function getFeedbackById(
+  db: DbShape,
+  id: number,
+  options: GetFeedbackByIdOptions = {},
+) {
+  const [row] = await db
+    .select({
+      feedbackId: feedback.feedbackId,
+      organizationId: feedback.organizationId,
+      title: feedback.title,
+      description: feedback.description,
+      type: feedback.type,
+      priority: feedback.priority,
+      status: feedback.status,
+      createdAt: feedback.createdAt,
+      updatedAt: feedback.updatedAt,
+      submittedOnBehalf: feedback.submittedOnBehalf,
+      submittedBy: feedback.submittedBy,
+      customerInfo: feedback.customerInfo,
+      deletedAt: feedback.deletedAt,
+    })
+    .from(feedback)
+    .where(eq(feedback.feedbackId, id))
+    .limit(1);
+
+  if (!row) {
+    return null;
+  }
+
+  if (row.deletedAt !== null) {
+    return { deleted: true as const };
+  }
+
+  const items = await db
+    .select()
+    .from(attachments)
+    .where(eq(attachments.feedbackId, id));
+
+  let submittedByUser: { id: string; name: string; email: string } | null = null;
+  if (row.submittedOnBehalf && row.submittedBy) {
+    const [userRow] = await db
+      .select({
+        id: user.id,
+        name: user.name,
+        email: user.email,
+      })
+      .from(user)
+      .where(eq(user.id, row.submittedBy))
+      .limit(1);
+    submittedByUser = userRow ?? null;
+  }
+
+  const feedbackVotes = await db
+    .select({
+      voteId: votes.voteId,
+      visitorId: votes.visitorId,
+      userId: votes.userId,
+      createdAt: votes.createdAt,
+      userName: user.name,
+      userEmail: user.email,
+    })
+    .from(votes)
+    .leftJoin(user, eq(votes.userId, user.id))
+    .where(eq(votes.feedbackId, id));
+
+  let userVote: { hasVoted: boolean; voteId: number | null } = {
+    hasVoted: false,
+    voteId: null,
+  };
+
+  if (options.userId) {
+    const foundVote = feedbackVotes.find((v) => v.userId === options.userId);
+    if (foundVote) {
+      userVote = { hasVoted: true, voteId: foundVote.voteId };
+    }
+  } else if (options.visitorId) {
+    const foundVote = feedbackVotes.find(
+      (v) => v.visitorId === options.visitorId,
+    );
+    if (foundVote) {
+      userVote = { hasVoted: true, voteId: foundVote.voteId };
+    }
+  }
+
+  const historyEntries = await db
+    .select({
+      historyId: statusHistory.historyId,
+      oldStatus: statusHistory.oldStatus,
+      newStatus: statusHistory.newStatus,
+      changedAt: statusHistory.changedAt,
+      comment: statusHistory.comment,
+      changedById: statusHistory.changedBy,
+      changedByName: user.name,
+      changedByEmail: user.email,
+    })
+    .from(statusHistory)
+    .leftJoin(user, eq(statusHistory.changedBy, user.id))
+    .where(eq(statusHistory.feedbackId, id))
+    .orderBy(desc(statusHistory.changedAt));
+
+  return {
+    feedback: {
+      ...row,
+      submittedByUser,
+    },
+    attachments: items,
+    votes: {
+      count: feedbackVotes.length,
+      list: feedbackVotes,
+      userVote,
+    },
+    statusHistory: historyEntries.map((entry) => ({
+      historyId: entry.historyId,
+      oldStatus: entry.oldStatus,
+      newStatus: entry.newStatus,
+      changedAt: entry.changedAt,
+      comment: entry.comment,
+      changedBy: entry.changedById
+        ? {
+            id: entry.changedById,
+            name: entry.changedByName,
+            email: entry.changedByEmail ?? "",
+          }
+        : null,
+    })),
+  };
+}