@lcas58/esmi-api-types 1.0.6 → 1.0.7

package/dist/src/routes/organizations/organizations.routes.js

@@ -0,0 +1,137 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent, jsonContentRequired } from "stoker/openapi/helpers";
+import { createErrorSchema } from "stoker/openapi/schemas";
+import { createOrganizationWithDetailsSchema, getOrganizationWithDetailsSchema, patchOrganizationSchema, selectOrganizationSchema } from "../../db/schema/organization.js";
+import { notFoundSchema, unauthorizedSchema, unprocessableEntitySchema } from "../../lib/constants.js";
+import { uuidParamsSchema } from "../../lib/openapi-schemas.js";
+import { isAuth } from "../../middlewares/is-auth.js";
+const tags = ["Organizations"];
+export const getOne = createRoute({
+    path: "/organizations/{id}",
+    method: "get",
+    tags,
+    middleware: [isAuth()],
+    request: {
+        params: z.object({
+            id: z.string(),
+        }),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(getOrganizationWithDetailsSchema, "The organization"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Organization not found"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(createErrorSchema(uuidParamsSchema("id")), "Invalid id error"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});
+export const list = createRoute({
+    path: "/organizations",
+    method: "get",
+    tags,
+    middleware: [isAuth()],
+    request: {
+        query: z.object({
+            ownerId: z.string().optional(),
+            city: z.string().optional(),
+            state: z.string().optional(),
+            country: z.string().optional(),
+        }),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(selectOrganizationSchema), "Organizations matching the provided owner or location filters"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(createErrorSchema(z.object({
+            ownerId: z.string(),
+        })), "Invalid ownerId error"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});
+export const listLocations = createRoute({
+    path: "/organizations/locations",
+    method: "get",
+    tags,
+    middleware: [isAuth()],
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.array(z.object({
+            city: z.string(),
+            state: z.string().nullable(),
+            country: z.string(),
+        })), "Distinct organization locations"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});
+export const create = createRoute({
+    path: "/organizations",
+    method: "post",
+    tags,
+    middleware: [isAuth()],
+    request: {
+        body: jsonContentRequired(createOrganizationWithDetailsSchema, "The organization to create with details"),
+    },
+    responses: {
+        [HttpStatusCodes.CREATED]: jsonContent(selectOrganizationSchema, "The created organization"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(createErrorSchema(createOrganizationWithDetailsSchema), "The validation error(s)"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});
+export const patch = createRoute({
+    path: "/organizations/{id}",
+    method: "patch",
+    tags,
+    request: {
+        params: uuidParamsSchema("id"),
+        body: jsonContentRequired(patchOrganizationSchema, "The organization to update"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(selectOrganizationSchema, "The updated organization"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Organization not found"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(createErrorSchema(uuidParamsSchema("id"))
+            .or(createErrorSchema(patchOrganizationSchema)), "The validation error(s)"),
+    },
+});
+export const remove = createRoute({
+    path: "/organizations/{id}",
+    method: "delete",
+    request: {
+        params: uuidParamsSchema("id"),
+    },
+    tags,
+    responses: {
+        [HttpStatusCodes.NO_CONTENT]: {
+            description: "Organization deleted",
+        },
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Organization not found"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(createErrorSchema(uuidParamsSchema("id")), "Invalid id error"),
+    },
+});
+export const checkOwnership = createRoute({
+    path: "/organizations/{id}/ownership",
+    method: "get",
+    tags,
+    middleware: [isAuth()],
+    request: {
+        params: uuidParamsSchema("id"),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.object({
+            isOwner: z.boolean(),
+        }), "Organization ownership status"),
+        [HttpStatusCodes.NOT_FOUND]: jsonContent(notFoundSchema, "Organization not found"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(createErrorSchema(uuidParamsSchema("id")), "Invalid id error"),
+        [HttpStatusCodes.UNAUTHORIZED]: jsonContent(unauthorizedSchema, "Unauthorized"),
+    },
+});
+export const checkOrganizationName = createRoute({
+    path: "/organizations/name",
+    method: "get",
+    tags,
+    request: {
+        query: z.object({ name: z.string() }),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.object({
+            exists: z.boolean(),
+            suggestions: z.array(z.string()).optional(),
+        }), "Organization name availability with suggestions"),
+        [HttpStatusCodes.UNPROCESSABLE_ENTITY]: jsonContent(unprocessableEntitySchema, "Invalid name error"),
+    },
+});

package/dist/src/routes/organizations/tasks.test.js

@@ -0,0 +1,181 @@
+"use strict";
+// /* eslint-disable ts/ban-ts-comment */
+// import { testClient } from "hono/testing";
+// import { execSync } from "node:child_process";
+// import fs from "node:fs";
+// import * as HttpStatusPhrases from "stoker/http-status-phrases";
+// import { afterAll, beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+// import { ZodIssueCode } from "zod";
+// import env from "../../env.js";
+// import { ZOD_ERROR_CODES, ZOD_ERROR_MESSAGES } from "../../lib/constants.js";
+// import createApp from "../../lib/create-app.js";
+// import router from "./tasks.index";
+// if (env.NODE_ENV !== "test") {
+//   throw new Error("NODE_ENV must be 'test'");
+// }
+// const client = testClient(createApp().route("/", router));
+// describe("tasks routes", () => {
+//   beforeAll(async () => {
+//     execSync("pnpm drizzle-kit push");
+//   });
+//   afterAll(async () => {
+//     fs.rmSync("test.db", { force: true });
+//   });
+//   it("post /tasks validates the body when creating", async () => {
+//     const response = await client.tasks.$post({
+//       // @ts-expect-error
+//       json: {
+//         done: false,
+//       },
+//     });
+//     expect(response.status).toBe(422);
+//     if (response.status === 422) {
+//       const json = await response.json();
+//       expect(json.error.issues[0].path[0]).toBe("name");
+//       expect(json.error.issues[0].message).toBe(ZOD_ERROR_MESSAGES.REQUIRED);
+//     }
+//   });
+//   const id = "1";
+//   const name = "Learn vitest";
+//   it("post /tasks creates a task", async () => {
+//     const response = await client.tasks.$post({
+//       json: {
+//         name,
+//         done: false,
+//       },
+//     });
+//     expect(response.status).toBe(200);
+//     if (response.status === 200) {
+//       const json = await response.json();
+//       expect(json.name).toBe(name);
+//       expect(json.done).toBe(false);
+//     }
+//   });
+//   it("get /tasks lists all tasks", async () => {
+//     const response = await client.tasks.$get();
+//     expect(response.status).toBe(200);
+//     if (response.status === 200) {
+//       const json = await response.json();
+//       expectTypeOf(json).toBeArray();
+//       expect(json.length).toBe(1);
+//     }
+//   });
+//   it("get /tasks/{id} validates the id param", async () => {
+//     const response = await client.tasks[":id"].$get({
+//       param: {
+//         id: "wat",
+//       },
+//     });
+//     expect(response.status).toBe(422);
+//     if (response.status === 422) {
+//       const json = await response.json();
+//       expect(json.error.issues[0].path[0]).toBe("id");
+//       expect(json.error.issues[0].message).toBe(ZOD_ERROR_MESSAGES.EXPECTED_NUMBER);
+//     }
+//   });
+//   it("get /tasks/{id} returns 404 when task not found", async () => {
+//     const response = await client.tasks[":id"].$get({
+//       param: {
+//         id: "999",
+//       },
+//     });
+//     expect(response.status).toBe(404);
+//     if (response.status === 404) {
+//       const json = await response.json();
+//       expect(json.message).toBe(HttpStatusPhrases.NOT_FOUND);
+//     }
+//   });
+//   it("get /tasks/{id} gets a single task", async () => {
+//     const response = await client.tasks[":id"].$get({
+//       param: {
+//         id,
+//       },
+//     });
+//     expect(response.status).toBe(200);
+//     if (response.status === 200) {
+//       const json = await response.json();
+//       expect(json.name).toBe(name);
+//       expect(json.done).toBe(false);
+//     }
+//   });
+//   it("patch /tasks/{id} validates the body when updating", async () => {
+//     const response = await client.tasks[":id"].$patch({
+//       param: {
+//         id,
+//       },
+//       json: {
+//         name: "",
+//       },
+//     });
+//     expect(response.status).toBe(422);
+//     if (response.status === 422) {
+//       const json = await response.json();
+//       expect(json.error.issues[0].path[0]).toBe("name");
+//       expect(json.error.issues[0].code).toBe(ZodIssueCode.too_small);
+//     }
+//   });
+//   it("patch /tasks/{id} validates the id param", async () => {
+//     const response = await client.tasks[":id"].$patch({
+//       param: {
+//         id: "wat",
+//       },
+//       json: {},
+//     });
+//     expect(response.status).toBe(422);
+//     if (response.status === 422) {
+//       const json = await response.json();
+//       expect(json.error.issues[0].path[0]).toBe("id");
+//       expect(json.error.issues[0].message).toBe(ZOD_ERROR_MESSAGES.EXPECTED_NUMBER);
+//     }
+//   });
+//   it("patch /tasks/{id} validates empty body", async () => {
+//     const response = await client.tasks[":id"].$patch({
+//       param: {
+//         id,
+//       },
+//       json: {},
+//     });
+//     expect(response.status).toBe(422);
+//     if (response.status === 422) {
+//       const json = await response.json();
+//       expect(json.error.issues[0].code).toBe(ZOD_ERROR_CODES.INVALID_UPDATES);
+//       expect(json.error.issues[0].message).toBe(ZOD_ERROR_MESSAGES.NO_UPDATES);
+//     }
+//   });
+//   it("patch /tasks/{id} updates a single property of a task", async () => {
+//     const response = await client.tasks[":id"].$patch({
+//       param: {
+//         id,
+//       },
+//       json: {
+//         done: true,
+//       },
+//     });
+//     expect(response.status).toBe(200);
+//     if (response.status === 200) {
+//       const json = await response.json();
+//       expect(json.done).toBe(true);
+//     }
+//   });
+//   it("delete /tasks/{id} validates the id when deleting", async () => {
+//     const response = await client.tasks[":id"].$delete({
+//       param: {
+//         id: "wat",
+//       },
+//     });
+//     expect(response.status).toBe(422);
+//     if (response.status === 422) {
+//       const json = await response.json();
+//       expect(json.error.issues[0].path[0]).toBe("id");
+//       expect(json.error.issues[0].message).toBe(ZOD_ERROR_MESSAGES.EXPECTED_NUMBER);
+//     }
+//   });
+//   it("delete /tasks/{id} removes a task", async () => {
+//     const response = await client.tasks[":id"].$delete({
+//       param: {
+//         id,
+//       },
+//     });
+//     expect(response.status).toBe(204);
+//   });
+// });

package/dist/src/routes/tags/tags.handlers.d.ts

@@ -0,0 +1,3 @@
+import type { AppRouteHandler } from "../../lib/types.js";
+import type { ListRoute } from "./tags.routes.js";
+export declare const list: AppRouteHandler<ListRoute>;

package/dist/src/routes/tags/tags.handlers.js

@@ -0,0 +1,15 @@
+import { createDb } from "../../db/index.js";
+export const list = async (c) => {
+    const { db } = createDb(c.env);
+    const { type } = c.req.valid("query");
+    const tags = await db.query.tags.findMany({
+        where: type ? (tags, { eq }) => eq(tags.type, type) : undefined,
+    });
+    return c.json({
+        tags: tags.map(tag => ({
+            ...tag,
+            createdAt: tag.createdAt.toISOString(),
+            updatedAt: tag.updatedAt.toISOString(),
+        })),
+    });
+};

package/dist/src/routes/tags/tags.index.d.ts

@@ -0,0 +1,24 @@
+declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../../shared/index.js").AppBindings, {
+    "/tags": {
+        $get: {
+            input: {
+                query: {
+                    type?: string | string[] | undefined;
+                };
+            };
+            output: {
+                tags: {
+                    id: string;
+                    type: string;
+                    name: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    description?: string | undefined;
+                }[];
+            };
+            outputFormat: "text" | "json";
+            status: 200;
+        };
+    };
+}, "/">;
+export default router;

package/dist/src/routes/tags/tags.index.js

@@ -0,0 +1,6 @@
+import { createRouter } from "../../lib/create-app.js";
+import * as handlers from "./tags.handlers.js";
+import * as routes from "./tags.routes.js";
+const router = createRouter()
+    .openapi(routes.list, handlers.list);
+export default router;

package/dist/src/routes/tags/tags.routes.d.ts

@@ -0,0 +1,68 @@
+import { z } from "@hono/zod-openapi";
+export declare const list: {
+    method: "get";
+    path: "/tags";
+    request: {
+        query: z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string | undefined;
+        }, {
+            type?: string | undefined;
+        }>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        tags: z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            type: z.ZodString;
+                            description: z.ZodOptional<z.ZodString>;
+                            createdAt: z.ZodDate;
+                            updatedAt: z.ZodDate;
+                        }, "strip", z.ZodTypeAny, {
+                            id: string;
+                            type: string;
+                            name: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            description?: string | undefined;
+                        }, {
+                            id: string;
+                            type: string;
+                            name: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            description?: string | undefined;
+                        }>, "many">;
+                    }, "strip", z.ZodTypeAny, {
+                        tags: {
+                            id: string;
+                            type: string;
+                            name: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            description?: string | undefined;
+                        }[];
+                    }, {
+                        tags: {
+                            id: string;
+                            type: string;
+                            name: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            description?: string | undefined;
+                        }[];
+                    }>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    getRoutingPath(): "/tags";
+};
+export type ListRoute = typeof list;

package/dist/src/routes/tags/tags.routes.js

@@ -0,0 +1,25 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import * as HttpStatusCodes from "stoker/http-status-codes";
+import { jsonContent } from "stoker/openapi/helpers";
+const tagSchema = z.object({
+    id: z.string().uuid(),
+    name: z.string(),
+    type: z.string(),
+    description: z.string().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export const list = createRoute({
+    method: "get",
+    path: "/tags",
+    request: {
+        query: z.object({
+            type: z.string().optional(),
+        }),
+    },
+    responses: {
+        [HttpStatusCodes.OK]: jsonContent(z.object({
+            tags: z.array(tagSchema),
+        }), "List of tags filtered by type"),
+    },
+});

package/dist/src/shared/client-types.d.ts

@@ -4,11 +4,16 @@
  * Usage in frontend:
  * ```typescript
  * import { hc } from 'hono/client';
- * import type { AppType } from '@esmi/api-types/client-types';
+ * import type { AppType } from '@lcas58/esmi-api-types/client-types';
  *
  * const client = hc<AppType>('https://api.example.com');
  * const res = await client.events.$get();
  * ```
  */
-import type app from "../app.js";
-export type AppType = typeof app;
+import type events from "../routes/events/events.index.js";
+import type index from "../routes/index.route.js";
+import type leagues from "../routes/leagues/leagues.index.js";
+import type marketing from "../routes/marketing/marketing.index.js";
+import type organizations from "../routes/organizations/organizations.index.js";
+import type tags from "../routes/tags/tags.index.js";
+export type AppType = typeof index | typeof organizations | typeof events | typeof leagues | typeof marketing | typeof tags;

package/dist/src/shared/client-types.js

@@ -4,7 +4,7 @@
  * Usage in frontend:
  * ```typescript
  * import { hc } from 'hono/client';
- * import type { AppType } from '@esmi/api-types/client-types';
+ * import type { AppType } from '@lcas58/esmi-api-types/client-types';
  *
  * const client = hc<AppType>('https://api.example.com');
  * const res = await client.events.$get();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lcas58/esmi-api-types",
   "type": "module",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "license": "MIT",
   "exports": {
     ".": {
@@ -20,7 +20,7 @@
     "dist/src/app.js",
     "dist/src/db/schema",
     "dist/src/lib/types.d.ts",
-    "dist/src/routes/*/schemas",
+    "dist/src/routes",
     "dist/src/shared"
   ],
   "scripts": {