@nexttylabs/echo 0.2.0

package/app/api/v1/feedback/route.ts

@@ -0,0 +1,250 @@
+/*
+ * 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 { NextRequest, NextResponse } from "next/server";
+import { requireApiKey } from "@/lib/middleware/api-key";
+import { db } from "@/lib/db";
+import { feedback } from "@/lib/db/schema";
+import { eq, and, desc, asc, sql, like, or, isNull, count, type SQL } from "drizzle-orm";
+import { z, ZodError } from "zod";
+import { logger } from "@/lib/logger";
+import { FeedbackStatusEnum } from "@/lib/validations/feedback";
+import { getOrgContext } from "@/lib/auth/org-context";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+const createFeedbackSchema = z.object({
+  title: z.string().min(1).max(200),
+  description: z.string().max(5000).default(""),
+  type: z.enum(["bug", "feature", "issue", "other"]).default("other"),
+  priority: z.enum(["low", "medium", "high"]).default("medium"),
+  submittedOnBehalf: z.boolean().default(false),
+  customerInfo: z
+    .object({
+      name: z.string(),
+      email: z.string().email(),
+      phone: z.string().optional(),
+    })
+    .nullable()
+    .optional(),
+});
+
+export async function GET(req: NextRequest) {
+  const auth = await requireApiKey(req);
+  if (auth.error) return auth.error;
+
+  const { organizationId } = auth.context!;
+
+  if (!db) {
+    return NextResponse.json(
+      { error: "Database not configured", code: "DATABASE_NOT_CONFIGURED" },
+      { status: 500 },
+    );
+  }
+
+  try {
+    const context = await getOrgContext({
+      request: req,
+      db,
+      organizationId,
+    });
+    const { searchParams } = new URL(req.url);
+    const page = parseInt(searchParams.get("page") || "1");
+    const limit = Math.min(parseInt(searchParams.get("limit") || "20"), 100);
+    const offset = (page - 1) * limit;
+    const sort = searchParams.get("sort") || "createdAt";
+    const order = searchParams.get("order") || "desc";
+    const status = searchParams.get("status");
+    const type = searchParams.get("type");
+    const search = searchParams.get("search");
+
+    if (page < 1 || limit < 1) {
+      return NextResponse.json(
+        { error: "Invalid pagination parameters", code: "INVALID_PAGINATION" },
+        { status: 400 },
+      );
+    }
+
+    if (status && !FeedbackStatusEnum.safeParse(status).success) {
+      return NextResponse.json(
+        { error: "Invalid status", code: "INVALID_STATUS" },
+        { status: 400 },
+      );
+    }
+
+    const conditions: SQL[] = [
+      eq(feedback.organizationId, context.organizationId),
+      isNull(feedback.deletedAt),
+    ];
+
+    if (status) {
+      conditions.push(eq(feedback.status, status));
+    }
+
+    if (type) {
+      conditions.push(eq(feedback.type, type));
+    }
+
+    if (search) {
+      conditions.push(
+        or(
+          like(feedback.title, `%${search}%`),
+          like(feedback.description, `%${search}%`),
+        )!,
+      );
+    }
+
+    const whereClause = and(...conditions);
+
+    const orderByFunction = order === "asc" ? asc : desc;
+    let orderByClause;
+
+    if (sort === "voteCount") {
+      orderByClause = orderByFunction(
+        sql<number>`(SELECT COUNT(*)::int FROM "votes" WHERE "votes"."feedbackId" = "feedback"."feedbackId")`,
+      );
+    } else {
+      const orderByColumn =
+        {
+          createdAt: feedback.createdAt,
+          updatedAt: feedback.updatedAt,
+          title: feedback.title,
+          status: feedback.status,
+          priority: feedback.priority,
+        }[sort] || feedback.createdAt;
+      orderByClause = orderByFunction(orderByColumn);
+    }
+
+    const [feedbackList, totalResult] = await Promise.all([
+      db
+        .select({
+          feedbackId: feedback.feedbackId,
+          title: feedback.title,
+          description: feedback.description,
+          type: feedback.type,
+          priority: feedback.priority,
+          status: feedback.status,
+          createdAt: feedback.createdAt,
+          updatedAt: feedback.updatedAt,
+          voteCount: sql<number>`(
+            SELECT COUNT(*)::int
+            FROM "votes"
+            WHERE "votes"."feedbackId" = "feedback"."feedbackId"
+          )`,
+        })
+        .from(feedback)
+        .where(whereClause)
+        .orderBy(orderByClause)
+        .limit(limit)
+        .offset(offset),
+      db.select({ value: count() }).from(feedback).where(whereClause),
+    ]);
+
+    const total = totalResult[0].value;
+
+    return NextResponse.json({
+      data: feedbackList,
+      meta: {
+        page,
+        limit,
+        total,
+        totalPages: Math.ceil(total / limit),
+      },
+    });
+  } catch (error) {
+    if (error instanceof Error && error.message === "Missing organization") {
+      return NextResponse.json(
+        { error: "Organization ID is required", code: "MISSING_ORG_ID" },
+        { status: 400 },
+      );
+    }
+    logger.error({ err: error }, "API error");
+    return NextResponse.json(
+      { error: "Internal server error", code: "INTERNAL_ERROR" },
+      { status: 500 },
+    );
+  }
+}
+
+export async function POST(req: NextRequest) {
+  const auth = await requireApiKey(req);
+  if (auth.error) return auth.error;
+
+    const { organizationId } = auth.context!;
+
+  if (!db) {
+    return NextResponse.json(
+      { error: "Database not configured", code: "DATABASE_NOT_CONFIGURED" },
+      { status: 500 },
+    );
+  }
+
+  try {
+    const context = await getOrgContext({
+      request: req,
+      db,
+      organizationId,
+    });
+    const body = await req.json();
+    const validated = createFeedbackSchema.parse(body);
+
+    const result = await db
+      .insert(feedback)
+      .values({
+        ...validated,
+        organizationId: context.organizationId,
+        status: "new",
+      })
+      .returning();
+
+    logger.info({ feedbackId: result[0].feedbackId }, "Feedback created via API");
+
+    return NextResponse.json(
+      {
+        data: result[0],
+        meta: {
+          createdAt: result[0].createdAt,
+        },
+      },
+      { status: 201 },
+    );
+  } catch (error) {
+    if (error instanceof ZodError) {
+      return NextResponse.json(
+        {
+          error: "Validation failed",
+          code: "VALIDATION_ERROR",
+          details: error.issues,
+        },
+        { status: 400 },
+      );
+    }
+    if (error instanceof Error && error.message === "Missing organization") {
+      return NextResponse.json(
+        { error: "Organization ID is required", code: "MISSING_ORG_ID" },
+        { status: 400 },
+      );
+    }
+
+    logger.error({ err: error }, "API error");
+    return NextResponse.json(
+      { error: "Internal server error", code: "INTERNAL_ERROR" },
+      { status: 500 },
+    );
+  }
+}

package/app/api/v1/spec/route.ts

@@ -0,0 +1,356 @@
+/*
+ * 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 { NextResponse } from "next/server";
+
+const openApiSpec = {
+  openapi: "3.0.0",
+  info: {
+    title: "Echo API",
+    version: "1.0.0",
+    description: "Feedback management API",
+  },
+  servers: [
+    {
+      url: process.env.NEXT_PUBLIC_API_URL || "http://localhost:3000",
+      description: "API Server",
+    },
+  ],
+  security: [
+    {
+      ApiKeyAuth: [],
+    },
+  ],
+  components: {
+    securitySchemes: {
+      ApiKeyAuth: {
+        type: "apiKey",
+        in: "header",
+        name: "X-API-Key",
+      },
+    },
+    schemas: {
+      Feedback: {
+        type: "object",
+        properties: {
+          feedbackId: { type: "integer" },
+          title: { type: "string" },
+          description: { type: "string" },
+          type: { type: "string", enum: ["bug", "feature", "issue", "other"] },
+          priority: { type: "string", enum: ["low", "medium", "high"] },
+          status: {
+            type: "string",
+            enum: ["new", "in-progress", "planned", "completed", "closed"],
+          },
+          createdAt: { type: "string", format: "date-time" },
+          updatedAt: { type: "string", format: "date-time" },
+        },
+      },
+      Error: {
+        type: "object",
+        properties: {
+          error: { type: "string" },
+          code: { type: "string" },
+          details: { type: "object" },
+        },
+      },
+      PaginationMeta: {
+        type: "object",
+        properties: {
+          page: { type: "integer" },
+          limit: { type: "integer" },
+          total: { type: "integer" },
+          totalPages: { type: "integer" },
+        },
+      },
+    },
+  },
+  paths: {
+    "/api/v1/feedback": {
+      get: {
+        summary: "List feedback",
+        tags: ["Feedback"],
+        parameters: [
+          {
+            name: "page",
+            in: "query",
+            schema: { type: "integer", default: 1 },
+          },
+          {
+            name: "limit",
+            in: "query",
+            schema: { type: "integer", default: 20, maximum: 100 },
+          },
+          {
+            name: "sort",
+            in: "query",
+            schema: {
+              type: "string",
+              enum: ["createdAt", "updatedAt", "voteCount", "title", "status", "priority"],
+            },
+          },
+          {
+            name: "order",
+            in: "query",
+            schema: { type: "string", enum: ["asc", "desc"] },
+          },
+          { name: "status", in: "query", schema: { type: "string" } },
+          { name: "type", in: "query", schema: { type: "string" } },
+          { name: "search", in: "query", schema: { type: "string" } },
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: {
+                      type: "array",
+                      items: { $ref: "#/components/schemas/Feedback" },
+                    },
+                    meta: { $ref: "#/components/schemas/PaginationMeta" },
+                  },
+                },
+              },
+            },
+          },
+          "401": {
+            description: "Unauthorized",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" },
+              },
+            },
+          },
+        },
+      },
+      post: {
+        summary: "Create feedback",
+        tags: ["Feedback"],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                required: ["title"],
+                properties: {
+                  title: { type: "string", minLength: 1, maxLength: 200 },
+                  description: { type: "string", maxLength: 5000 },
+                  type: {
+                    type: "string",
+                    enum: ["bug", "feature", "issue", "other"],
+                  },
+                  priority: { type: "string", enum: ["low", "medium", "high"] },
+                  submittedOnBehalf: { type: "boolean" },
+                  customerInfo: {
+                    type: "object",
+                    properties: {
+                      name: { type: "string" },
+                      email: { type: "string", format: "email" },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        responses: {
+          "201": {
+            description: "Created",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: { $ref: "#/components/schemas/Feedback" },
+                    meta: {
+                      type: "object",
+                      properties: {
+                        createdAt: { type: "string", format: "date-time" },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          "400": {
+            description: "Validation error",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" },
+              },
+            },
+          },
+          "401": {
+            description: "Unauthorized",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" },
+              },
+            },
+          },
+        },
+      },
+    },
+    "/api/v1/feedback/{id}": {
+      get: {
+        summary: "Get feedback by ID",
+        tags: ["Feedback"],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: { type: "integer" },
+          },
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: { $ref: "#/components/schemas/Feedback" },
+                  },
+                },
+              },
+            },
+          },
+          "404": {
+            description: "Not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" },
+              },
+            },
+          },
+        },
+      },
+      put: {
+        summary: "Update feedback",
+        tags: ["Feedback"],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: { type: "integer" },
+          },
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  title: { type: "string", minLength: 1, maxLength: 200 },
+                  description: { type: "string", maxLength: 5000 },
+                  type: {
+                    type: "string",
+                    enum: ["bug", "feature", "issue", "other"],
+                  },
+                  priority: { type: "string", enum: ["low", "medium", "high"] },
+                  status: {
+                    type: "string",
+                    enum: ["new", "in-progress", "planned", "completed", "closed"],
+                  },
+                },
+              },
+            },
+          },
+        },
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    data: { $ref: "#/components/schemas/Feedback" },
+                  },
+                },
+              },
+            },
+          },
+          "400": {
+            description: "Validation error",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" },
+              },
+            },
+          },
+          "404": {
+            description: "Not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" },
+              },
+            },
+          },
+        },
+      },
+      delete: {
+        summary: "Delete feedback (soft delete)",
+        tags: ["Feedback"],
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            schema: { type: "integer" },
+          },
+        ],
+        responses: {
+          "200": {
+            description: "Success",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    success: { type: "boolean" },
+                  },
+                },
+              },
+            },
+          },
+          "404": {
+            description: "Not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+export async function GET() {
+  return NextResponse.json(openApiSpec);
+}