@nexttylabs/echo 0.2.0

package/tests/api/feedback-status-filter.test.ts

@@ -0,0 +1,117 @@
+/*
+ * 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 { describe, expect, it, mock, beforeEach } from "bun:test";
+import { NextRequest } from "next/server";
+
+describe("Feedback status filter validation", () => {
+  beforeEach(() => {
+    mock.restore();
+  });
+
+  it("returns 400 for invalid status in /api/feedback", async () => {
+    const mockDb = {
+      select: mock(() => ({
+        from: mock(() => ({
+          where: mock(() => {
+            const result = [{ value: 0 }];
+            const adminRows = [{ role: "admin" }];
+            return {
+              orderBy: mock(() => ({
+                limit: mock(() => ({
+                  offset: mock(() => Promise.resolve([])),
+                })),
+              })),
+              limit: mock(() => ({
+                then: (resolve: (value: typeof adminRows) => void) =>
+                  Promise.resolve(adminRows).then(resolve),
+              })),
+              then: (resolve: (value: typeof result) => void) =>
+                Promise.resolve(result).then(resolve),
+              [Symbol.iterator]: () => result[Symbol.iterator](),
+            };
+          }),
+        })),
+      })),
+    };
+
+    mock.module("next/headers", () => ({
+      headers: () => Promise.resolve(new Headers()),
+      cookies: () => Promise.resolve({ get: () => undefined }),
+    }));
+
+    mock.module("@/lib/auth/config", () => ({
+      auth: {
+        api: {
+          getSession: mock(() => Promise.resolve({ user: { id: "user_1" } })),
+        },
+        options: {
+          session: {
+            expiresIn: 60 * 60 * 24 * 30,
+          },
+        },
+      },
+    }));
+
+    mock.module("@/lib/db", () => ({ db: mockDb }));
+
+    const { GET } = await import("@/app/api/feedback/route");
+    const req = new NextRequest(
+      "http://localhost:3000/api/feedback?status=processing&organizationId=org_1",
+    );
+
+    const response = await GET(req);
+    expect(response.status).toBe(400);
+  });
+
+  it("returns 400 for invalid status in /api/v1/feedback", async () => {
+    const mockDb = {
+      select: mock(() => ({
+        from: mock(() => ({
+          where: mock(() => {
+            const result = [{ value: 0 }];
+            return {
+              orderBy: mock(() => ({
+                limit: mock(() => ({
+                  offset: mock(() => Promise.resolve([])),
+                })),
+              })),
+              then: (resolve: (value: typeof result) => void) =>
+                Promise.resolve(result).then(resolve),
+              [Symbol.iterator]: () => result[Symbol.iterator](),
+            };
+          }),
+        })),
+      })),
+    };
+
+    mock.module("@/lib/db", () => ({ db: mockDb }));
+    mock.module("@/lib/middleware/api-key", () => ({
+      requireApiKey: async () => ({
+        context: { organizationId: "org_1", apiKeyId: 1 },
+      }),
+    }));
+
+    const { GET } = await import("@/app/api/v1/feedback/route");
+    const req = new NextRequest(
+      "http://localhost:3000/api/v1/feedback?status=processing",
+    );
+
+    const response = await GET(req);
+    expect(response.status).toBe(400);
+  });
+});

package/tests/api/feedback-submit-on-behalf.test.ts

@@ -0,0 +1,269 @@
+/*
+ * 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 { describe, expect, it } from "bun:test";
+import { buildCreateFeedbackHandler } from "@/app/api/feedback/handler";
+
+type InsertStub = {
+  insert: () => {
+    values: () => {
+      returning: () => Promise<unknown[]>;
+    };
+  };
+};
+
+const makeDb = (overrides?: Partial<Record<string, unknown>>) => ({
+  insert: () => ({
+    values: () => ({
+      returning: async () => [
+        {
+          feedbackId: 1,
+          title: "Customer reported issue",
+          description: "Customer cannot login",
+          type: "bug",
+          priority: "high",
+          status: "new",
+          organizationId: "org",
+          submittedOnBehalf: true,
+          submittedBy: "user-1",
+          customerInfo: {
+            name: "John Doe",
+            email: "john@example.com",
+            phone: "+86 13800000000",
+          },
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          ...overrides,
+        },
+      ],
+    }),
+  }),
+});
+
+describe("POST /api/feedback (submit on behalf)", () => {
+  it("should allow customer support to submit on behalf", async () => {
+    const formData = {
+      title: "Customer reported issue",
+      description: "Customer cannot login",
+      type: "bug",
+      priority: "high",
+      submittedOnBehalf: true,
+      customerInfo: {
+        name: "John Doe",
+        email: "john@example.com",
+        phone: "+86 13800000000",
+      },
+    };
+
+    const handler = buildCreateFeedbackHandler({ db: makeDb() as InsertStub });
+    const response = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-user-id": "user-1",
+          "x-user-role": "customer_support",
+          "x-organization-id": "org",
+        },
+        body: JSON.stringify(formData),
+      }),
+    );
+
+    const data = await response.json();
+
+    expect(response.status).toBe(201);
+    expect(data.data.submittedOnBehalf).toBe(true);
+    expect(data.data.customerInfo).toBeDefined();
+    expect(data.data.customerInfo.name).toBe("John Doe");
+    expect(data.data.trackingUrl).toBe("/feedback/1");
+  });
+
+  it("should allow admin to submit on behalf", async () => {
+    const formData = {
+      title: "Admin submitted feedback",
+      description: "Admin creating feedback for customer",
+      type: "feature",
+      priority: "medium",
+      submittedOnBehalf: true,
+      customerInfo: {
+        name: "Jane Doe",
+        email: "jane@example.com",
+      },
+    };
+
+    const handler = buildCreateFeedbackHandler({ db: makeDb() as InsertStub });
+    const response = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-user-id": "admin-1",
+          "x-user-role": "admin",
+          "x-organization-id": "org",
+        },
+        body: JSON.stringify(formData),
+      }),
+    );
+
+    expect(response.status).toBe(201);
+  });
+
+  it("should reject developer trying to submit on behalf", async () => {
+    const formData = {
+      title: "Test",
+      description: "Test description",
+      type: "bug",
+      priority: "medium",
+      submittedOnBehalf: true,
+      customerInfo: {
+        name: "Test",
+        email: "test@example.com",
+      },
+    };
+
+    const handler = buildCreateFeedbackHandler({ db: makeDb() as InsertStub });
+    const response = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-user-id": "dev-1",
+          "x-user-role": "developer",
+          "x-organization-id": "org",
+        },
+        body: JSON.stringify(formData),
+      }),
+    );
+
+    const data = await response.json();
+
+    expect(response.status).toBe(403);
+    expect(data.code).toBe("FORBIDDEN");
+  });
+
+  it("should reject customer trying to submit on behalf", async () => {
+    const formData = {
+      title: "Test",
+      description: "Test description",
+      type: "bug",
+      priority: "medium",
+      submittedOnBehalf: true,
+      customerInfo: {
+        name: "Test",
+        email: "test@example.com",
+      },
+    };
+
+    const handler = buildCreateFeedbackHandler({ db: makeDb() as InsertStub });
+    const response = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-user-id": "customer-1",
+          "x-user-role": "customer",
+          "x-organization-id": "org",
+        },
+        body: JSON.stringify(formData),
+      }),
+    );
+
+    const data = await response.json();
+
+    expect(response.status).toBe(403);
+    expect(data.code).toBe("FORBIDDEN");
+  });
+
+  it("should require customer info when submitting on behalf", async () => {
+    const formData = {
+      title: "Test",
+      description: "Test description",
+      type: "bug",
+      priority: "medium",
+      submittedOnBehalf: true,
+    };
+
+    const handler = buildCreateFeedbackHandler({ db: makeDb() as InsertStub });
+    const response = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-user-id": "user-1",
+          "x-user-role": "customer_support",
+          "x-organization-id": "org",
+        },
+        body: JSON.stringify(formData),
+      }),
+    );
+
+    const data = await response.json();
+
+    expect(response.status).toBe(400);
+    expect(data.code).toBe("CUSTOMER_INFO_REQUIRED");
+  });
+
+  it("should allow normal submission without on-behalf flag", async () => {
+    const formData = {
+      title: "Normal feedback",
+      description: "This is a normal feedback",
+      type: "feature",
+      priority: "low",
+    };
+
+    const normalDb = {
+      insert: () => ({
+        values: () => ({
+          returning: async () => [
+            {
+              feedbackId: 2,
+              title: "Normal feedback",
+              description: "This is a normal feedback",
+              type: "feature",
+              priority: "low",
+              status: "new",
+              organizationId: "org",
+              submittedOnBehalf: false,
+              submittedBy: null,
+              customerInfo: null,
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            },
+          ],
+        }),
+      }),
+    };
+
+    const handler = buildCreateFeedbackHandler({ db: normalDb as InsertStub });
+    const response = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-organization-id": "org",
+        },
+        body: JSON.stringify(formData),
+      }),
+    );
+
+    const data = await response.json();
+
+    expect(response.status).toBe(201);
+    expect(data.data.submittedOnBehalf).toBe(false);
+    expect(data.data.customerInfo).toBeNull();
+  });
+});

package/tests/api/feedback.test.ts

@@ -0,0 +1,175 @@
+/*
+ * 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 { describe, expect, it } from "bun:test";
+import { buildCreateFeedbackHandler } from "@/app/api/feedback/handler";
+import { feedback } from "@/lib/db/schema";
+
+type FakeDeps = Parameters<typeof buildCreateFeedbackHandler>[0];
+
+type InsertReturn = {
+  values: (values: Record<string, unknown>) => {
+    returning: () => Promise<Array<Record<string, unknown>>>;
+  };
+};
+
+const makeDeps = () => {
+  let inserted: Record<string, unknown> | null = null;
+
+  const insert = (table?: unknown) => ({
+    values: (values: Record<string, unknown>) => {
+      if (table === feedback) {
+        inserted = values;
+      }
+      return {
+        returning: async () => [
+          {
+            feedbackId: 1,
+            ...values,
+            status: values.status ?? "new",
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+        ],
+      };
+    },
+  });
+
+  const db: FakeDeps["db"] = {
+    insert: insert as unknown as () => InsertReturn,
+  };
+
+  return {
+    db,
+    getInserted: () => inserted,
+  } satisfies FakeDeps & { getInserted: () => Record<string, unknown> | null };
+};
+
+const makeDepsWithInsertError = () => {
+  const insert = () => ({
+    values: () => ({
+      returning: async () => {
+        throw new Error("DB failure");
+      },
+    }),
+  });
+
+  const db: FakeDeps["db"] = {
+    insert: insert as unknown as () => InsertReturn,
+  };
+
+  return { db } satisfies FakeDeps;
+};
+
+describe("POST /api/feedback", () => {
+  it("creates feedback when payload is valid", async () => {
+    const deps = makeDeps();
+    const handler = buildCreateFeedbackHandler(deps);
+
+    const res = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-organization-id": "org_1",
+        },
+        body: JSON.stringify({
+          title: "Great idea",
+          description: "Please add dark mode",
+          type: "feature",
+          priority: "high",
+        }),
+      }),
+    );
+
+    const json = await res.json();
+    expect(res.status).toBe(201);
+    expect(json.data.feedbackId).toBe(1);
+    expect(deps.getInserted()?.organizationId).toBe("org_1");
+  });
+
+  it("returns 400 when organization id is missing", async () => {
+    const handler = buildCreateFeedbackHandler(makeDeps());
+
+    const res = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          title: "Great idea",
+          description: "Please add dark mode",
+          type: "feature",
+          priority: "high",
+        }),
+      }),
+    );
+
+    const json = await res.json();
+    expect(res.status).toBe(400);
+    expect(json.code).toBe("VALIDATION_ERROR");
+  });
+
+  it("returns 400 when payload is invalid", async () => {
+    const handler = buildCreateFeedbackHandler(makeDeps());
+
+    const res = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-organization-id": "org_1",
+        },
+        body: JSON.stringify({
+          title: "",
+          description: "x",
+          type: "bug",
+          priority: "high",
+        }),
+      }),
+    );
+
+    const json = await res.json();
+    expect(res.status).toBe(400);
+    expect(json.code).toBe("VALIDATION_ERROR");
+  });
+
+  it("returns 500 when database insert fails", async () => {
+    const handler = buildCreateFeedbackHandler(makeDepsWithInsertError());
+
+    const res = await handler(
+      new Request("http://localhost/api/feedback", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-organization-id": "org_1",
+        },
+        body: JSON.stringify({
+          title: "Great idea",
+          description: "Please add dark mode",
+          type: "feature",
+          priority: "high",
+        }),
+      }),
+    );
+
+    const json = await res.json();
+    expect(res.status).toBe(500);
+    expect(json.code).toBe("INTERNAL_ERROR");
+  });
+});

package/tests/api/identify-jwt.test.ts

@@ -0,0 +1,25 @@
+/*
+ * 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 { describe, expect, it } from "bun:test";
+import { parseJwtIdentity } from "@/lib/auth/jwt-identity";
+
+describe("parseJwtIdentity", () => {
+  it("returns null when token is empty", () => {
+    expect(parseJwtIdentity("")).toBe(null);
+  });
+});