@nexttylabs/echo 0.4.0 → 0.5.0

package/tests/api/feedback.test.ts

@@ -1,175 +0,0 @@
-/*
- * 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

@@ -1,25 +0,0 @@
-/*
- * 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);
-  });
-});

package/tests/api/invitation-accept.test.ts

@@ -1,213 +0,0 @@
-/*
- * 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 { buildAcceptInvitationHandler } from "@/app/api/invitations/accept/handler";
-import { invitations, organizationMembers } from "@/lib/db/schema";
-
-type FakeDeps = Parameters<typeof buildAcceptInvitationHandler>[0];
-
-type SelectReturn<T> = {
-  from: () => {
-    where: () => {
-      limit: (count: number) => Promise<T[]>;
-    };
-  };
-};
-
-type InsertReturn = {
-  values: (values: Record<string, unknown>) => Promise<unknown>;
-};
-
-type UpdateReturn = {
-  set: (values: Record<string, unknown>) => {
-    where: () => Promise<unknown>;
-  };
-};
-
-const now = new Date("2026-01-01T00:00:00.000Z");
-
-const makeDeps = () => {
-  const auth: FakeDeps["auth"] = {
-    api: {
-      getSession: async () => ({ user: { id: "user_1" } }),
-    },
-  };
-
-  let invitationRecord: {
-    id: string;
-    organizationId: string;
-    email: string;
-    role: string;
-    token: string;
-    expiresAt: Date;
-    acceptedAt: Date | null;
-  } | null = {
-    id: "inv_1",
-    organizationId: "org_1",
-    email: "test@example.com",
-    role: "member",
-    token: "token_123",
-    expiresAt: new Date("2026-01-10T00:00:00.000Z"),
-    acceptedAt: null,
-  };
-
-  const select = () => ({
-    from: () => ({
-      where: () => ({
-        limit: async () => (invitationRecord ? [invitationRecord] : []),
-      }),
-    }),
-  });
-
-  let insertedMember: Record<string, unknown> | null = null;
-  let updatedInvitation: Record<string, unknown> | null = null;
-
-  const insert = (table?: unknown) => ({
-    values: async (values: Record<string, unknown>) => {
-      if (table === organizationMembers) {
-        insertedMember = values;
-      }
-      return {};
-    },
-  });
-
-  const update = (table?: unknown) => ({
-    set: (values: Record<string, unknown>) => {
-      if (table === invitations) {
-        updatedInvitation = values;
-      }
-      return {
-        where: async () => ({}),
-      };
-    },
-  });
-
-  const db: FakeDeps["db"] = {
-    select: select as unknown as () => SelectReturn<typeof invitationRecord>,
-    transaction: async (fn) =>
-      fn({
-        insert: insert as unknown as () => InsertReturn,
-        update: update as unknown as () => UpdateReturn,
-      }),
-  };
-
-  return {
-    auth,
-    db,
-    setInvitation: (next: typeof invitationRecord) => {
-      invitationRecord = next;
-    },
-    getInsertedMember: () => insertedMember,
-    getUpdatedInvitation: () => updatedInvitation,
-  } satisfies FakeDeps & {
-    setInvitation: (next: typeof invitationRecord) => void;
-    getInsertedMember: () => Record<string, unknown> | null;
-    getUpdatedInvitation: () => Record<string, unknown> | null;
-  };
-};
-
-describe("POST /api/invitations/accept", () => {
-  it("rejects unauthenticated requests", async () => {
-    const deps = makeDeps();
-    deps.auth.api.getSession = async () => null;
-    const handler = buildAcceptInvitationHandler(deps);
-    const res = await handler(
-      new Request("http://localhost/api/invitations/accept", {
-        method: "POST",
-        body: JSON.stringify({ token: "token_123" }),
-      }),
-    );
-    expect(res.status).toBe(401);
-  });
-
-  it("returns 404 for invalid token", async () => {
-    const deps = makeDeps();
-    deps.setInvitation(null);
-    const handler = buildAcceptInvitationHandler(deps);
-    const res = await handler(
-      new Request("http://localhost/api/invitations/accept", {
-        method: "POST",
-        body: JSON.stringify({ token: "missing" }),
-      }),
-    );
-    expect(res.status).toBe(404);
-  });
-
-  it("returns 410 for expired token", async () => {
-    const deps = makeDeps();
-    deps.setInvitation({
-      id: "inv_1",
-      organizationId: "org_1",
-      email: "test@example.com",
-      role: "member",
-      token: "token_123",
-      expiresAt: new Date("2025-12-01T00:00:00.000Z"),
-      acceptedAt: null,
-    });
-    const handler = buildAcceptInvitationHandler(deps, () => now);
-    const res = await handler(
-      new Request("http://localhost/api/invitations/accept", {
-        method: "POST",
-        body: JSON.stringify({ token: "token_123" }),
-      }),
-    );
-    expect(res.status).toBe(410);
-    const json = await res.json();
-    expect(json.error).toBe("邀请已过期");
-  });
-
-  it("returns 409 for already accepted invitations", async () => {
-    const deps = makeDeps();
-    deps.setInvitation({
-      id: "inv_1",
-      organizationId: "org_1",
-      email: "test@example.com",
-      role: "member",
-      token: "token_123",
-      expiresAt: new Date("2026-01-10T00:00:00.000Z"),
-      acceptedAt: new Date("2026-01-02T00:00:00.000Z"),
-    });
-    const handler = buildAcceptInvitationHandler(deps, () => now);
-    const res = await handler(
-      new Request("http://localhost/api/invitations/accept", {
-        method: "POST",
-        body: JSON.stringify({ token: "token_123" }),
-      }),
-    );
-    expect(res.status).toBe(409);
-  });
-
-  it("adds member and marks accepted", async () => {
-    const deps = makeDeps();
-    const handler = buildAcceptInvitationHandler(deps, () => now);
-    const res = await handler(
-      new Request("http://localhost/api/invitations/accept", {
-        method: "POST",
-        body: JSON.stringify({ token: "token_123" }),
-      }),
-    );
-    expect(res.status).toBe(200);
-    const member = deps.getInsertedMember();
-    expect(member?.organizationId).toBe("org_1");
-    expect(member?.userId).toBe("user_1");
-    expect(member?.role).toBe("member");
-
-    const updated = deps.getUpdatedInvitation();
-    expect(updated?.acceptedAt).toEqual(now);
-  });
-});

package/tests/api/organization-invitations.test.ts

@@ -1,186 +0,0 @@
-/*
- * 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 { buildCreateInvitationHandler } from "@/app/api/organizations/[orgId]/invitations/handler";
-import { invitations } from "@/lib/db/schema";
-
-type FakeDeps = Parameters<typeof buildCreateInvitationHandler>[0];
-
-type SelectReturn = {
-  from: () => {
-    where: () => {
-      limit: (count: number) => Promise<Array<{ role: string }>>;
-    };
-  };
-};
-
-type InsertReturn = {
-  values: (values: Record<string, unknown>) => {
-    returning: () => Promise<Array<{ id: string }>>;
-  };
-};
-
-const makeDeps = () => {
-  const auth: FakeDeps["auth"] = {
-    api: {
-      getSession: async () => ({ user: { id: "user_1", role: "admin" } }),
-    },
-  };
-
-  const select = () => ({
-    from: () => ({
-      where: () => ({
-        limit: async () => [{ role: "admin" }],
-      }),
-    }),
-  });
-
-  let invitationValues: Record<string, unknown> | null = null;
-  let sentEmail: { to: string; subject: string; html: string } | null = null;
-
-  const insert = (table?: unknown) => ({
-    values: (values: Record<string, unknown>) => {
-      if (table === invitations) {
-        invitationValues = values;
-      }
-      return {
-        returning: async () => [{ id: "inv_1" }],
-      };
-    },
-  });
-
-  const db: FakeDeps["db"] = {
-    select: select as unknown as () => SelectReturn,
-    insert: insert as unknown as () => InsertReturn,
-  };
-
-  const email: FakeDeps["email"] = {
-    sendEmail: async (payload) => {
-      sentEmail = payload;
-    },
-  };
-
-  return {
-    auth,
-    db,
-    email,
-    getInvitationValues: () => invitationValues,
-    getSentEmail: () => sentEmail,
-  } satisfies FakeDeps & {
-    getInvitationValues: () => Record<string, unknown> | null;
-    getSentEmail: () => { to: string; subject: string; html: string } | null;
-  };
-};
-
-const makeDepsWithRole = (role: string | null) => {
-  const deps = makeDeps();
-  const select = () => ({
-    from: () => ({
-      where: () => ({
-        limit: async () => (role ? [{ role }] : []),
-      }),
-    }),
-  });
-  deps.db.select = select as unknown as () => SelectReturn;
-  return deps;
-};
-
-describe("POST /api/organizations/:orgId/invitations", () => {
-  it("rejects unauthenticated requests", async () => {
-    const deps = makeDeps();
-    deps.auth.api.getSession = async () => null;
-    const handler = buildCreateInvitationHandler(deps);
-    const res = await handler(
-      new Request("http://localhost/api/organizations/org_1/invitations", { method: "POST" }),
-      { params: { orgId: "org_1" } },
-    );
-    expect(res.status).toBe(401);
-  });
-
-  it("rejects non-admin members", async () => {
-    const deps = makeDepsWithRole("member");
-    const handler = buildCreateInvitationHandler(deps);
-    const res = await handler(
-      new Request("http://localhost/api/organizations/org_1/invitations", {
-        method: "POST",
-        body: JSON.stringify({ email: "test@example.com", role: "member" }),
-      }),
-      { params: { orgId: "org_1" } },
-    );
-    expect(res.status).toBe(403);
-  });
-
-  it("rejects non-members", async () => {
-    const deps = makeDepsWithRole(null);
-    const handler = buildCreateInvitationHandler(deps);
-    const res = await handler(
-      new Request("http://localhost/api/organizations/org_1/invitations", {
-        method: "POST",
-        body: JSON.stringify({ email: "test@example.com", role: "member" }),
-      }),
-      { params: { orgId: "org_1" } },
-    );
-    expect(res.status).toBe(403);
-  });
-
-  it("creates invitation and sends email", async () => {
-    const deps = makeDeps();
-    const handler = buildCreateInvitationHandler(deps);
-    const originalUrl = process.env.NEXT_PUBLIC_APP_URL;
-    process.env.NEXT_PUBLIC_APP_URL = "http://app.test";
-
-    try {
-      const res = await handler(
-        new Request("http://localhost/api/organizations/org_1/invitations", {
-          method: "POST",
-          body: JSON.stringify({ email: "test@example.com", role: "member" }),
-        }),
-        { params: { orgId: "org_1" } },
-      );
-
-      expect(res.status).toBe(201);
-      const invitationValues = deps.getInvitationValues();
-      expect(invitationValues?.organizationId).toBe("org_1");
-      expect(invitationValues?.email).toBe("test@example.com");
-      expect(invitationValues?.role).toBe("member");
-      expect(typeof invitationValues?.token).toBe("string");
-      expect(invitationValues?.token).toBeDefined();
-
-      const sentEmail = deps.getSentEmail();
-      expect(sentEmail?.to).toBe("test@example.com");
-      expect(sentEmail?.subject).toBe("加入组织的邀请");
-      expect(sentEmail?.html).toContain("http://app.test/invite/");
-      expect(sentEmail?.html).toContain(String(invitationValues?.token));
-    } finally {
-      process.env.NEXT_PUBLIC_APP_URL = originalUrl;
-    }
-  });
-
-  it("returns 400 on invalid body", async () => {
-    const deps = makeDeps();
-    const handler = buildCreateInvitationHandler(deps);
-    const res = await handler(
-      new Request("http://localhost/api/organizations/org_1/invitations", {
-        method: "POST",
-        body: JSON.stringify({ email: "not-an-email", role: "" }),
-      }),
-      { params: { orgId: "org_1" } },
-    );
-    expect(res.status).toBe(400);
-  });
-});

package/tests/api/organization-members-list.test.ts

@@ -1,79 +0,0 @@
-/*
- * 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 { afterEach, describe, expect, it, mock } from "bun:test";
-import { NextRequest } from "next/server";
-
-afterEach(() => {
-  mock.restore();
-});
-
-describe("GET /api/organizations/[orgId]/members", () => {
-  it("returns members with displayName", async () => {
-    const memberRow = {
-      userId: "user_1",
-      displayName: "Ada",
-      email: "ada@example.com",
-      avatarUrl: null,
-    };
-    const mockDb = {
-      select: (fields?: unknown) => {
-        if (fields) {
-          return {
-            from: () => ({
-              innerJoin: () => ({
-                where: async () => [memberRow],
-              }),
-            }),
-          };
-        }
-
-        return {
-          from: () => ({
-            where: () => ({
-              limit: async () => [{ role: "admin" }],
-            }),
-          }),
-        };
-      },
-    };
-
-    mock.module("@/lib/auth/config", () => ({
-      auth: {
-        api: {
-          getSession: mock(() => Promise.resolve({ user: { id: "user_1" } })),
-        },
-      },
-    }));
-
-    mock.module("@/lib/db", () => ({ db: mockDb }));
-    const { GET } = await import(
-      "@/app/api/organizations/[orgId]/members/route"
-    );
-    const req = new NextRequest(
-      "http://localhost:3000/api/organizations/org_1/members",
-    );
-    const res = await GET(req, {
-      params: Promise.resolve({ orgId: "org_1" }),
-    });
-
-    expect(res.status).toBe(200);
-    const json = await res.json();
-    expect(json.data[0]).toHaveProperty("userId");
-    expect(json.data[0]).toHaveProperty("displayName");
-  });
-});