@vitnode/blog 1.2.0-canary.22 → 1.2.0-canary.24

package/dist/src/api/modules/{categories → admin/categories}/routes/edit.route.d.ts

@@ -1,6 +1,6 @@
 import { z } from '@hono/zod-openapi';
 export declare const editCategoryRoute: {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/:id", {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/:id", {
         in: {
             param: {
                 id: string;

package/dist/src/api/modules/admin/categories/routes/edit.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/categories/routes/edit.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAkBtC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiF5B,CAAC"}

package/dist/src/api/modules/admin/categories/routes/edit.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{removeSpecialCharacters}from"@vitnode/core/lib/special-characters";import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{CONFIG_PLUGIN}from"../../../../../const.js";import{blog_categories}from"../../../../../database/categories.js";import{zodCreateCategorySchema}from"./create.route.js";const zodCategoryResponseSchema=z.object({id:z.number(),title:z.string(),createdAt:z.date(),updatedAt:z.date()});export const editCategoryRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"put",path:"/{id}",request:{params:z.object({id:z.string().transform(Number)}),body:{content:{"application/json":{schema:zodCreateCategorySchema}}}},responses:{200:{content:{"application/json":{schema:zodCategoryResponseSchema}},description:"Category updated successfully"},400:{description:"Bad request - Invalid input data"},404:{description:"Category not found"}}},handler:async c=>{const{id}=c.req.valid("param");const{title}=c.req.valid("json");const titleSeo=removeSpecialCharacters(title);const[editData]=await c.get("db").select({titleSeo:blog_categories.titleSeo}).from(blog_categories).where(eq(blog_categories.id,id)).limit(1);if(!editData){throw new HTTPException(404)}const[titleSEODuplocate]=await c.get("db").select({titleSeo:blog_categories.titleSeo}).from(blog_categories).where(eq(blog_categories.titleSeo,titleSeo)).limit(1);if(titleSEODuplocate?.titleSeo===titleSeo&&titleSEODuplocate.titleSeo!==editData.titleSeo){throw new HTTPException(400,{message:"Category with this title already exists."})}const[category]=await c.get("db").update(blog_categories).set({title,titleSeo:removeSpecialCharacters(title)}).where(eq(blog_categories.id,id)).returning();return c.json(category)}});

package/dist/src/api/modules/admin/posts/posts.admin.module.d.ts

@@ -0,0 +1,243 @@
+export declare const postsAdminModule: import("@vitnode/core/api/lib/module").BuildModuleReturn<"@vitnode/blog", "posts", [{
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/:id", {
+        in: {
+            param: {
+                id: string;
+            };
+        };
+        out: {
+            param: {
+                id: number;
+            };
+        };
+    } & {
+        in: {
+            json: {
+                title: string;
+                content: string;
+                categoryId: number;
+            };
+        };
+        out: {
+            json: {
+                title: string;
+                content: string;
+                categoryId: number;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        id: number;
+        title: string;
+        titleSeo: string;
+        content: string;
+        categoryId: number;
+        createdAt: string;
+        updatedAt: string;
+    }, 400 | 200 | 404, "json">>;
+    pluginId: "@vitnode/blog";
+    route: {
+        method: "put";
+        path: "/{id}";
+        request: {
+            params: import("zod").ZodObject<{
+                id: import("zod").ZodEffects<import("zod").ZodString, number, string>;
+            }, "strip", import("zod").ZodTypeAny, {
+                id: number;
+            }, {
+                id: string;
+            }>;
+            body: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            title: import("zod").ZodString;
+                            content: import("zod").ZodString;
+                            categoryId: import("zod").ZodNumber;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            title: import("zod").ZodString;
+                            titleSeo: import("zod").ZodString;
+                            content: import("zod").ZodString;
+                            categoryId: import("zod").ZodNumber;
+                            createdAt: import("zod").ZodDate;
+                            updatedAt: import("zod").ZodDate;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            id: number;
+                            title: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            titleSeo: string;
+                            content: string;
+                            categoryId: number;
+                        }, {
+                            id: number;
+                            title: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            titleSeo: string;
+                            content: string;
+                            categoryId: number;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+            400: {
+                description: string;
+            };
+            404: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:id";
+    };
+}, {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/", {
+        in: {
+            json: {
+                title: string;
+                content: string;
+                categoryId: number;
+            };
+        };
+        out: {
+            json: {
+                title: string;
+                content: string;
+                categoryId: number;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        id: number;
+        title: string;
+        createdAt: string;
+        updatedAt: string;
+        titleSeo: string;
+        content: string;
+        categoryId: number;
+    }, 201, "json">>;
+    pluginId: "@vitnode/blog";
+    route: {
+        method: "post";
+        path: "/";
+        request: {
+            body: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            title: import("zod").ZodString;
+                            content: import("zod").ZodString;
+                            categoryId: import("zod").ZodNumber;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            201: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            title: import("zod").ZodString;
+                            titleSeo: import("zod").ZodString;
+                            content: import("zod").ZodString;
+                            categoryId: import("zod").ZodNumber;
+                            createdAt: import("zod").ZodDate;
+                            updatedAt: import("zod").ZodDate;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            id: number;
+                            title: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            titleSeo: string;
+                            content: string;
+                            categoryId: number;
+                        }, {
+                            id: number;
+                            title: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            titleSeo: string;
+                            content: string;
+                            categoryId: number;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+            400: {
+                description: string;
+            };
+            404: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+}, {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/:id", {
+        in: {
+            param: {
+                id: string;
+            };
+        };
+        out: {
+            param: {
+                id: number;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<null, 204, "body">>;
+    pluginId: "@vitnode/blog";
+    route: {
+        method: "delete";
+        path: "/{id}";
+        request: {
+            params: import("zod").ZodObject<{
+                id: import("zod").ZodEffects<import("zod").ZodString, number, string>;
+            }, "strip", import("zod").ZodTypeAny, {
+                id: number;
+            }, {
+                id: string;
+            }>;
+        };
+        responses: {
+            204: {
+                description: string;
+            };
+            404: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:id";
+    };
+}], import("@vitnode/core/api/lib/module").BaseBuildModuleReturn<"@vitnode/blog", string, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", import("@hono/zod-openapi").RouteConfig, import("@hono/zod-openapi").RouteHandler<import("@hono/zod-openapi").RouteConfig>>[]>[]>;
+//# sourceMappingURL=posts.admin.module.d.ts.map

package/dist/src/api/modules/admin/posts/posts.admin.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posts.admin.module.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/admin/posts/posts.admin.module.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wRAI3B,CAAC"}

package/dist/src/api/modules/admin/posts/posts.admin.module.js

@@ -0,0 +1 @@
+import{buildModule}from"@vitnode/core/api/lib/module";import{CONFIG_PLUGIN}from"../../../../const.js";import{createPostRoute}from"./routes/create.route.js";import{deletePostRoute}from"./routes/delete.route.js";import{editPostRoute}from"./routes/edit.route.js";export const postsAdminModule=buildModule({...CONFIG_PLUGIN,name:"posts",routes:[editPostRoute,createPostRoute,deletePostRoute]});

package/dist/src/api/modules/{posts → admin/posts}/routes/create.route.d.ts

@@ -13,7 +13,7 @@ export declare const zodCreatePostSchema: z.ZodObject<{
     categoryId: number;
 }>;
 export declare const createPostRoute: {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/", {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/", {
         in: {
             json: {
                 title: string;

package/dist/src/api/modules/admin/posts/routes/create.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/posts/routes/create.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAUtC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAO9B,CAAC;AAYH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4E1B,CAAC"}

package/dist/src/api/modules/admin/posts/routes/create.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{removeSpecialCharacters}from"@vitnode/core/lib/special-characters";import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{CONFIG_PLUGIN}from"../../../../../const.js";import{blog_categories}from"../../../../../database/categories.js";import{blog_posts}from"../../../../../database/posts.js";export const zodCreatePostSchema=z.object({title:z.string().min(3,"Title must be at least 3 characters long").max(255,"Title must not exceed 255 characters"),content:z.string(),categoryId:z.number()});const zodPostResponseSchema=z.object({id:z.number(),title:z.string(),titleSeo:z.string(),content:z.string(),categoryId:z.number(),createdAt:z.date(),updatedAt:z.date()});export const createPostRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"post",path:"/",request:{body:{content:{"application/json":{schema:zodCreatePostSchema}}}},responses:{201:{content:{"application/json":{schema:zodPostResponseSchema}},description:"Post created successfully"},400:{description:"Bad request - Invalid input data"},404:{description:"Category not found"}}},handler:async c=>{const{title,content,categoryId}=c.req.valid("json");const titleSeo=removeSpecialCharacters(title);const[category]=await c.get("db").select({id:blog_categories.id}).from(blog_categories).where(eq(blog_categories.id,categoryId)).limit(1);if(!category){throw new HTTPException(404,{message:"Category not found."})}const[titleSEODuplicate]=await c.get("db").select({titleSeo:blog_posts.titleSeo}).from(blog_posts).where(eq(blog_posts.titleSeo,titleSeo)).limit(1);if(titleSEODuplicate?.titleSeo===titleSeo){throw new HTTPException(400,{message:"Post with this title already exists."})}const[post]=await c.get("db").insert(blog_posts).values({title,titleSeo,content,categoryId}).returning();return c.json(post,201)}});

package/dist/src/api/modules/{posts → admin/posts}/routes/delete.route.d.ts

@@ -1,6 +1,6 @@
 import { z } from '@hono/zod-openapi';
 export declare const deletePostRoute: {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/:id", {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/:id", {
         in: {
             param: {
                 id: string;

package/dist/src/api/modules/admin/posts/routes/delete.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/posts/routes/delete.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAQtC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC1B,CAAC"}

package/dist/src/api/modules/admin/posts/routes/delete.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{CONFIG_PLUGIN}from"../../../../../const.js";import{blog_posts}from"../../../../../database/posts.js";export const deletePostRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"delete",path:"/{id}",request:{params:z.object({id:z.string().transform(Number)})},responses:{204:{description:"Post deleted successfully"},404:{description:"Post not found"}}},handler:async c=>{const{id}=c.req.valid("param");const result=await c.get("db").delete(blog_posts).where(eq(blog_posts.id,id)).returning();if(result.length===0){throw new HTTPException(404)}return c.body(null,204)}});

package/dist/src/api/modules/{posts → admin/posts}/routes/edit.route.d.ts

@@ -1,6 +1,6 @@
 import { z } from '@hono/zod-openapi';
 export declare const editPostRoute: {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/:id", {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/:id", {
         in: {
             param: {
                 id: string;

package/dist/src/api/modules/admin/posts/routes/edit.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/posts/routes/edit.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAsBtC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8FxB,CAAC"}

package/dist/src/api/modules/admin/posts/routes/edit.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{removeSpecialCharacters}from"@vitnode/core/lib/special-characters";import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{CONFIG_PLUGIN}from"../../../../../const.js";import{blog_categories}from"../../../../../database/categories.js";import{blog_posts}from"../../../../../database/posts.js";import{zodCreatePostSchema}from"./create.route.js";const zodPostResponseSchema=z.object({id:z.number(),title:z.string(),titleSeo:z.string(),content:z.string(),categoryId:z.number(),createdAt:z.date(),updatedAt:z.date()});export const editPostRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"put",path:"/{id}",request:{params:z.object({id:z.string().transform(Number)}),body:{content:{"application/json":{schema:zodCreatePostSchema}}}},responses:{200:{content:{"application/json":{schema:zodPostResponseSchema}},description:"Post updated successfully"},400:{description:"Bad request - Invalid input data"},404:{description:"Post or category not found"}}},handler:async c=>{const{id}=c.req.valid("param");const{title,content,categoryId}=c.req.valid("json");const titleSeo=removeSpecialCharacters(title);const[existingPost]=await c.get("db").select({titleSeo:blog_posts.titleSeo}).from(blog_posts).where(eq(blog_posts.id,id)).limit(1);if(!existingPost){throw new HTTPException(404,{message:"Post not found."})}const[category]=await c.get("db").select({id:blog_categories.id}).from(blog_categories).where(eq(blog_categories.id,categoryId)).limit(1);if(!category){throw new HTTPException(404,{message:"Category not found."})}const[titleSEODuplicate]=await c.get("db").select({titleSeo:blog_posts.titleSeo}).from(blog_posts).where(eq(blog_posts.titleSeo,titleSeo)).limit(1);if(titleSEODuplicate?.titleSeo===titleSeo&&titleSEODuplicate.titleSeo!==existingPost.titleSeo){throw new HTTPException(400,{message:"Post with this title already exists."})}const[post]=await c.get("db").update(blog_posts).set({title,titleSeo,content,categoryId}).where(eq(blog_posts.id,id)).returning();return c.json(post)}});

package/dist/src/api/modules/categories/categories.module.d.ts

@@ -1,7 +1,8 @@
 export declare const categoriesModule: import("@vitnode/core/api/lib/module").BuildModuleReturn<"@vitnode/blog", "categories", [{
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/", {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/", {
         in: {
             query: {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;
@@ -11,6 +12,7 @@ export declare const categoriesModule: import("@vitnode/core/api/lib/module").Bu
         };
         out: {
             query: {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;
@@ -47,13 +49,16 @@ export declare const categoriesModule: import("@vitnode/core/api/lib/module").Bu
             } & {
                 order: import("zod").ZodOptional<import("zod").ZodEnum<["asc", "desc"]>>;
                 orderBy: import("zod").ZodOptional<import("zod").ZodEnum<["updatedAt"]>>;
+                search: import("zod").ZodOptional<import("zod").ZodString>;
             }, "strip", import("zod").ZodTypeAny, {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;
                 last?: string | undefined;
                 order?: "asc" | "desc" | undefined;
             }, {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;
@@ -143,201 +148,5 @@ export declare const categoriesModule: import("@vitnode/core/api/lib/module").Bu
     } & {
         getRoutingPath: () => "/";
     };
-}, {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/", {
-        in: {
-            json: {
-                title: string;
-            };
-        };
-        out: {
-            json: {
-                title: string;
-            };
-        };
-    }>) => Promise<Response & import("hono").TypedResponse<{
-        id: number;
-        title: string;
-        createdAt: string;
-        updatedAt: string;
-        titleSeo: string;
-    }, 201, "json">>;
-    pluginId: "@vitnode/blog";
-    route: {
-        method: "post";
-        path: "/";
-        request: {
-            body: {
-                content: {
-                    'application/json': {
-                        schema: import("zod").ZodObject<{
-                            title: import("zod").ZodString;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            title: string;
-                        }, {
-                            title: string;
-                        }>;
-                    };
-                };
-            };
-        };
-        responses: {
-            201: {
-                content: {
-                    'application/json': {
-                        schema: import("zod").ZodObject<{
-                            id: import("zod").ZodNumber;
-                            title: import("zod").ZodString;
-                            createdAt: import("zod").ZodDate;
-                            updatedAt: import("zod").ZodDate;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            id: number;
-                            title: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                        }, {
-                            id: number;
-                            title: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                        }>;
-                    };
-                };
-                description: string;
-            };
-            400: {
-                description: string;
-            };
-        };
-    } & {
-        getRoutingPath: () => "/";
-    };
-}, {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/:id", {
-        in: {
-            param: {
-                id: string;
-            };
-        };
-        out: {
-            param: {
-                id: number;
-            };
-        };
-    } & {
-        in: {
-            json: {
-                title: string;
-            };
-        };
-        out: {
-            json: {
-                title: string;
-            };
-        };
-    }>) => Promise<Response & import("hono").TypedResponse<{
-        id: number;
-        title: string;
-        createdAt: string;
-        updatedAt: string;
-        titleSeo: string;
-    }, 400 | 200 | 404, "json">>;
-    pluginId: "@vitnode/blog";
-    route: {
-        method: "put";
-        path: "/{id}";
-        request: {
-            params: import("zod").ZodObject<{
-                id: import("zod").ZodEffects<import("zod").ZodString, number, string>;
-            }, "strip", import("zod").ZodTypeAny, {
-                id: number;
-            }, {
-                id: string;
-            }>;
-            body: {
-                content: {
-                    'application/json': {
-                        schema: import("zod").ZodObject<{
-                            title: import("zod").ZodString;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            title: string;
-                        }, {
-                            title: string;
-                        }>;
-                    };
-                };
-            };
-        };
-        responses: {
-            200: {
-                content: {
-                    'application/json': {
-                        schema: import("zod").ZodObject<{
-                            id: import("zod").ZodNumber;
-                            title: import("zod").ZodString;
-                            createdAt: import("zod").ZodDate;
-                            updatedAt: import("zod").ZodDate;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            id: number;
-                            title: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                        }, {
-                            id: number;
-                            title: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                        }>;
-                    };
-                };
-                description: string;
-            };
-            400: {
-                description: string;
-            };
-            404: {
-                description: string;
-            };
-        };
-    } & {
-        getRoutingPath: () => "/:id";
-    };
-}, {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/:id", {
-        in: {
-            param: {
-                id: string;
-            };
-        };
-        out: {
-            param: {
-                id: number;
-            };
-        };
-    }>) => Promise<Response & import("hono").TypedResponse<null, 204, "body">>;
-    pluginId: "@vitnode/blog";
-    route: {
-        method: "delete";
-        path: "/{id}";
-        request: {
-            params: import("zod").ZodObject<{
-                id: import("zod").ZodEffects<import("zod").ZodString, number, string>;
-            }, "strip", import("zod").ZodTypeAny, {
-                id: number;
-            }, {
-                id: string;
-            }>;
-        };
-        responses: {
-            204: {
-                description: string;
-            };
-            404: {
-                description: string;
-            };
-        };
-    } & {
-        getRoutingPath: () => "/:id";
-    };
 }], import("@vitnode/core/api/lib/module").BaseBuildModuleReturn<"@vitnode/blog", string, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", import("@hono/zod-openapi").RouteConfig, import("@hono/zod-openapi").RouteHandler<import("@hono/zod-openapi").RouteConfig>>[]>[]>;
 //# sourceMappingURL=categories.module.d.ts.map

package/dist/src/api/modules/categories/categories.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"categories.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/categories/categories.module.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wRAS3B,CAAC"}
+{"version":3,"file":"categories.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/categories/categories.module.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wRAI3B,CAAC"}

package/dist/src/api/modules/categories/categories.module.js

@@ -1 +1 @@
-import{buildModule}from"@vitnode/core/api/lib/module";import{CONFIG_PLUGIN}from"../../../const.js";import{createCategoryRoute}from"./routes/create.route.js";import{deleteCategoryRoute}from"./routes/delete.route.js";import{editCategoryRoute}from"./routes/edit.route.js";import{categoriesRoute}from"./routes/get.route.js";export const categoriesModule=buildModule({...CONFIG_PLUGIN,name:"categories",routes:[categoriesRoute,createCategoryRoute,editCategoryRoute,deleteCategoryRoute]});
+import{buildModule}from"@vitnode/core/api/lib/module";import{CONFIG_PLUGIN}from"../../../const.js";import{categoriesRoute}from"./routes/get.route.js";export const categoriesModule=buildModule({...CONFIG_PLUGIN,name:"categories",routes:[categoriesRoute]});

package/dist/src/api/modules/categories/routes/get.route.d.ts

@@ -1,8 +1,9 @@
 import { z } from '@hono/zod-openapi';
 export declare const categoriesRoute: {
-    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/", {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global.middleware").EnvVitNode, "/", {
         in: {
             query: {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;
@@ -12,6 +13,7 @@ export declare const categoriesRoute: {
         };
         out: {
             query: {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;
@@ -48,13 +50,16 @@ export declare const categoriesRoute: {
             } & {
                 order: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
                 orderBy: z.ZodOptional<z.ZodEnum<["updatedAt"]>>;
+                search: z.ZodOptional<z.ZodString>;
             }, "strip", z.ZodTypeAny, {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;
                 last?: string | undefined;
                 order?: "asc" | "desc" | undefined;
             }, {
+                search?: string | undefined;
                 orderBy?: "updatedAt" | undefined;
                 cursor?: string | undefined;
                 first?: string | undefined;

package/dist/src/api/modules/categories/routes/get.route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/categories/routes/get.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAkBtC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqD1B,CAAC"}
+{"version":3,"file":"get.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/categories/routes/get.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAmBtC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE1B,CAAC"}

package/dist/src/api/modules/categories/routes/get.route.js

@@ -1 +1 @@
-import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"@vitnode/core/api/lib/with-pagination";import{CONFIG_PLUGIN}from"../../../../const.js";import{blog_categories}from"../../../../database/categories.js";const zodCategorySchema=z.object({id:z.number(),title:z.string(),createdAt:z.date(),updatedAt:z.date()});export const categoriesRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"get",path:"/",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["updatedAt"]).optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(zodCategorySchema),pageInfo:zodPaginationPageInfo})}},description:"Categories retrieved successfully"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({c,params:{query},primaryCursor:blog_categories.id,query:async({limit,where,orderBy})=>await c.get("db").select().from(blog_categories).where(where).orderBy(orderBy).limit(limit),table:blog_categories,orderBy:{column:query.orderBy?blog_categories[query.orderBy]:blog_categories.updatedAt,order:query.order??"desc"}});return c.json(data)}});
+import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"@vitnode/core/api/lib/with-pagination";import{and,ilike}from"drizzle-orm";import{CONFIG_PLUGIN}from"../../../../const.js";import{blog_categories}from"../../../../database/categories.js";const zodCategorySchema=z.object({id:z.number(),title:z.string(),createdAt:z.date(),updatedAt:z.date()});export const categoriesRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"get",path:"/",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["updatedAt"]).optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(zodCategorySchema),pageInfo:zodPaginationPageInfo})}},description:"Categories retrieved successfully"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({c,params:{query},primaryCursor:blog_categories.id,query:async({limit,where,orderBy})=>{const searchCondition=query.search?ilike(blog_categories.title,`%${query.search}%`):undefined;const combinedWhere=searchCondition?where?and(where,searchCondition):searchCondition:where;return await c.get("db").select().from(blog_categories).where(combinedWhere).orderBy(orderBy).limit(limit)},table:blog_categories,orderBy:{column:query.orderBy?blog_categories[query.orderBy]:blog_categories.updatedAt,order:query.order??"desc"}});return c.json(data)}});