@vitnode/blog 1.2.0-canary.16 → 1.2.0-canary.18

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

@@ -0,0 +1,109 @@
+import { z } from '@hono/zod-openapi';
+export declare const zodCreatePostSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+    categoryId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    content: string;
+    categoryId: number;
+}, {
+    title: string;
+    content: string;
+    categoryId: number;
+}>;
+export declare const createPostRoute: {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").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: z.ZodObject<{
+                            title: z.ZodString;
+                            content: z.ZodString;
+                            categoryId: z.ZodNumber;
+                        }, "strip", z.ZodTypeAny, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            201: {
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            id: z.ZodNumber;
+                            title: z.ZodString;
+                            titleSeo: z.ZodString;
+                            content: z.ZodString;
+                            categoryId: z.ZodNumber;
+                            createdAt: z.ZodDate;
+                            updatedAt: z.ZodDate;
+                        }, "strip", z.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: () => "/";
+    };
+};
+//# sourceMappingURL=create.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/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/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"../../../../config.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().min(10,"Content must be at least 10 characters long"),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/routes/delete.route.d.ts

@@ -0,0 +1,40 @@
+import { z } from '@hono/zod-openapi';
+export declare const deletePostRoute: {
+    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: z.ZodObject<{
+                id: z.ZodEffects<z.ZodString, number, string>;
+            }, "strip", z.ZodTypeAny, {
+                id: number;
+            }, {
+                id: string;
+            }>;
+        };
+        responses: {
+            204: {
+                description: string;
+            };
+            404: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:id";
+    };
+};
+//# sourceMappingURL=delete.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/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/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"../../../../config.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/routes/edit.route.d.ts

@@ -0,0 +1,127 @@
+import { z } from '@hono/zod-openapi';
+export declare const zodEditPostSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+    categoryId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    content: string;
+    categoryId: number;
+}, {
+    title: string;
+    content: string;
+    categoryId: number;
+}>;
+export declare const editPostRoute: {
+    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;
+                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: z.ZodObject<{
+                id: z.ZodEffects<z.ZodString, number, string>;
+            }, "strip", z.ZodTypeAny, {
+                id: number;
+            }, {
+                id: string;
+            }>;
+            body: {
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            title: z.ZodString;
+                            content: z.ZodString;
+                            categoryId: z.ZodNumber;
+                        }, "strip", z.ZodTypeAny, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }, {
+                            title: string;
+                            content: string;
+                            categoryId: number;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            id: z.ZodNumber;
+                            title: z.ZodString;
+                            titleSeo: z.ZodString;
+                            content: z.ZodString;
+                            categoryId: z.ZodNumber;
+                            createdAt: z.ZodDate;
+                            updatedAt: z.ZodDate;
+                        }, "strip", z.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";
+    };
+};
+//# sourceMappingURL=edit.route.d.ts.map

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

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

package/dist/src/api/modules/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"../../../../config.js";import{blog_categories}from"../../../../database/categories.js";import{blog_posts}from"../../../../database/posts.js";export const zodEditPostSchema=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().min(10,"Content must be at least 10 characters long"),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 editPostRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"put",path:"/{id}",request:{params:z.object({id:z.string().transform(Number)}),body:{content:{"application/json":{schema:zodEditPostSchema}}}},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/posts/routes/get.route.d.ts

@@ -0,0 +1,208 @@
+import { z } from '@hono/zod-openapi';
+export declare const postsRoute: {
+    handler: (c: import("hono").Context<import("@vitnode/core/api/middlewares/global/global").EnvVitNode, "/", {
+        in: {
+            query: {
+                orderBy?: "createdAt" | "updatedAt" | undefined;
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                categoryId?: string | undefined;
+            };
+        };
+        out: {
+            query: {
+                orderBy?: "createdAt" | "updatedAt" | undefined;
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                categoryId?: number | undefined;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        edges: {
+            id: number;
+            title: string;
+            titleSeo: string;
+            content: string;
+            categoryId: number;
+            createdAt: string;
+            updatedAt: string;
+            category: {
+                id: number;
+                title: string;
+                titleSeo: string;
+            };
+        }[];
+        pageInfo: {
+            count: number;
+            endCursor: null | number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor: null | number;
+            totalCount: number;
+        };
+    }, 200, "json">>;
+    pluginId: "@vitnode/blog";
+    route: {
+        method: "get";
+        path: "/";
+        request: {
+            query: z.ZodObject<{
+                cursor: z.ZodOptional<z.ZodString>;
+                first: z.ZodOptional<z.ZodString>;
+                last: z.ZodOptional<z.ZodString>;
+            } & {
+                order: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+                orderBy: z.ZodOptional<z.ZodEnum<["updatedAt", "createdAt"]>>;
+                categoryId: z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>;
+            }, "strip", z.ZodTypeAny, {
+                orderBy?: "createdAt" | "updatedAt" | undefined;
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                categoryId?: number | undefined;
+            }, {
+                orderBy?: "createdAt" | "updatedAt" | undefined;
+                cursor?: string | undefined;
+                first?: string | undefined;
+                last?: string | undefined;
+                order?: "asc" | "desc" | undefined;
+                categoryId?: string | undefined;
+            }>;
+        };
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            edges: z.ZodArray<z.ZodObject<{
+                                id: z.ZodNumber;
+                                title: z.ZodString;
+                                titleSeo: z.ZodString;
+                                content: z.ZodString;
+                                categoryId: z.ZodNumber;
+                                createdAt: z.ZodDate;
+                                updatedAt: z.ZodDate;
+                                category: z.ZodObject<{
+                                    id: z.ZodNumber;
+                                    title: z.ZodString;
+                                    titleSeo: z.ZodString;
+                                }, "strip", z.ZodTypeAny, {
+                                    id: number;
+                                    title: string;
+                                    titleSeo: string;
+                                }, {
+                                    id: number;
+                                    title: string;
+                                    titleSeo: string;
+                                }>;
+                            }, "strip", z.ZodTypeAny, {
+                                id: number;
+                                title: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                titleSeo: string;
+                                content: string;
+                                category: {
+                                    id: number;
+                                    title: string;
+                                    titleSeo: string;
+                                };
+                                categoryId: number;
+                            }, {
+                                id: number;
+                                title: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                titleSeo: string;
+                                content: string;
+                                category: {
+                                    id: number;
+                                    title: string;
+                                    titleSeo: string;
+                                };
+                                categoryId: number;
+                            }>, "many">;
+                            pageInfo: z.ZodObject<{
+                                totalCount: z.ZodNumber;
+                                count: z.ZodNumber;
+                                hasNextPage: z.ZodBoolean;
+                                hasPreviousPage: z.ZodBoolean;
+                                startCursor: z.ZodNullable<z.ZodNumber>;
+                                endCursor: z.ZodNullable<z.ZodNumber>;
+                            }, "strip", z.ZodTypeAny, {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            }, {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            }>;
+                        }, "strip", z.ZodTypeAny, {
+                            edges: {
+                                id: number;
+                                title: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                titleSeo: string;
+                                content: string;
+                                category: {
+                                    id: number;
+                                    title: string;
+                                    titleSeo: string;
+                                };
+                                categoryId: number;
+                            }[];
+                            pageInfo: {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            };
+                        }, {
+                            edges: {
+                                id: number;
+                                title: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                titleSeo: string;
+                                content: string;
+                                category: {
+                                    id: number;
+                                    title: string;
+                                    titleSeo: string;
+                                };
+                                categoryId: number;
+                            }[];
+                            pageInfo: {
+                                count: number;
+                                totalCount: number;
+                                hasNextPage: boolean;
+                                hasPreviousPage: boolean;
+                                startCursor: number | null;
+                                endCursor: number | null;
+                            };
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+};
+//# sourceMappingURL=get.route.d.ts.map

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

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

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

@@ -0,0 +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{eq}from"drizzle-orm";import{CONFIG_PLUGIN}from"../../../../config.js";import{blog_categories}from"../../../../database/categories.js";import{blog_posts}from"../../../../database/posts.js";const zodPostSchema=z.object({id:z.number(),title:z.string(),titleSeo:z.string(),content:z.string(),categoryId:z.number(),createdAt:z.date(),updatedAt:z.date(),category:z.object({id:z.number(),title:z.string(),titleSeo:z.string()})});export const postsRoute=buildRoute({...CONFIG_PLUGIN,route:{method:"get",path:"/",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["updatedAt","createdAt"]).optional(),categoryId:z.string().transform(Number).optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(zodPostSchema),pageInfo:zodPaginationPageInfo})}},description:"Posts retrieved successfully"}}},handler:async c=>{const query=c.req.valid("query");const data=await withPagination({c,params:{query},primaryCursor:blog_posts.id,query:async({limit,where,orderBy})=>await c.get("db").select({id:blog_posts.id,title:blog_posts.title,titleSeo:blog_posts.titleSeo,content:blog_posts.content,categoryId:blog_posts.categoryId,createdAt:blog_posts.createdAt,updatedAt:blog_posts.updatedAt,category:{id:blog_categories.id,title:blog_categories.title,titleSeo:blog_categories.titleSeo}}).from(blog_posts).innerJoin(blog_categories,eq(blog_posts.categoryId,blog_categories.id)).where(query.categoryId?eq(blog_posts.categoryId,query.categoryId):where).orderBy(orderBy).limit(limit),table:blog_posts,orderBy:{column:query.orderBy?blog_posts[query.orderBy]:blog_posts.updatedAt,order:query.order??"desc"}});return c.json(data)}});

package/dist/src/app_admin/blog/categories/page.d.ts

@@ -0,0 +1,5 @@
+import type { Metadata } from 'next';
+import { CategoriesAdminView } from '../../../views/admin/categories/categories-admin-view';
+export declare const generateMetadata: () => Promise<Metadata>;
+export default function CategoriesPage(params: React.ComponentProps<typeof CategoriesAdminView>): Promise<import("react/jsx-runtime").JSX.Element>;
+//# sourceMappingURL=page.d.ts.map

package/dist/src/app_admin/blog/categories/page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../../../../../src/app_admin/blog/categories/page.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAMrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gDAAgD,CAAC;AAIrF,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,QAAQ,CAMzD,CAAC;AAEF,wBAA8B,cAAc,CAC1C,MAAM,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,mBAAmB,CAAC,oDAkBzD"}

package/dist/src/app_admin/blog/categories/page.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{I18nProvider}from"@vitnode/core/components/i18n-provider";import{HeaderContent}from"@vitnode/core/components/ui/header-content";import{getTranslations}from"next-intl/server";import{CategoriesAdminView}from"../../../views/admin/categories/categories-admin-view.js";import{ActionsCategoriesAdmin}from"../../../views/admin/categories/actions/actions.js";export const generateMetadata=async()=>{const t=await getTranslations("@vitnode/blog.admin.nav");return{title:t("categories")}};export default async function CategoriesPage(params){const[t,tNav]=await Promise.all([getTranslations("@vitnode/blog.admin.categories"),getTranslations("@vitnode/blog.admin.nav")]);return _jsx(I18nProvider,{namespaces:["@vitnode/blog.admin.categories"],children:_jsxs("div",{className:"container mx-auto p-4",children:[_jsx(HeaderContent,{desc:t("desc"),h1:tNav("categories"),children:_jsx(ActionsCategoriesAdmin,{})}),_jsx(CategoriesAdminView,{...params})]})})}

package/dist/src/config.api.d.ts

@@ -0,0 +1,2 @@
+export declare const blogApiPlugin: () => import("@vitnode/core/api/lib/plugin").BuildPluginApiReturn;
+//# sourceMappingURL=config.api.d.ts.map

package/dist/src/config.api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.api.d.ts","sourceRoot":"","sources":["../../src/config.api.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,aAAa,mEAKzB,CAAC"}

package/dist/src/config.api.js

@@ -0,0 +1 @@
+import{buildApiPlugin}from"@vitnode/core/api/lib/plugin";import{CONFIG_PLUGIN}from"./config.js";import{categoriesModule}from"./api/modules/categories/categories.module.js";import{postsModule}from"./api/modules/posts/posts.module.js";export const blogApiPlugin=()=>{return buildApiPlugin({...CONFIG_PLUGIN,modules:[categoriesModule,postsModule]})};

package/dist/src/config.d.ts

@@ -0,0 +1,4 @@
+export declare const CONFIG_PLUGIN: {
+    pluginId: "@vitnode/blog";
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;CAEzB,CAAC"}

package/dist/src/config.js

@@ -0,0 +1 @@
+export const CONFIG_PLUGIN={pluginId:"@vitnode/blog"};

package/dist/src/database/categories.d.ts

@@ -0,0 +1,97 @@
+export declare const blog_categories: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "blog_categories";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "blog_categories";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        title: import("drizzle-orm/pg-core").PgColumn<{
+            name: "title";
+            tableName: "blog_categories";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 100;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "blog_categories";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "blog_categories";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        titleSeo: import("drizzle-orm/pg-core").PgColumn<{
+            name: "titleSeo";
+            tableName: "blog_categories";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 100;
+        }>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+//# sourceMappingURL=categories.d.ts.map

package/dist/src/database/categories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"categories.d.ts","sourceRoot":"","sources":["../../../src/database/categories.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBASb,CAAC"}