@vitnode/blog 1.2.0-canary.78 → 2.0.0-canary.2

package/src/locales/pl.json

@@ -0,0 +1,69 @@
+{
+  "@vitnode/blog": {
+    "title": "Blog",
+    "content": {
+      "post": {
+        "label": "{count, plural, one {Artykuł} few {Artykuły} many {Artykułów} other {Artykułu}}",
+        "title": "Artykuły",
+        "desc": "Pisz artykuły na blogu i zarządzaj nimi.",
+        "fields": {
+          "title": "Tytuł",
+          "friendlyUrl": "Przyjazny adres URL",
+          "content": "Treść",
+          "categoryId": "Kategoria",
+          "authorId": "Autor",
+          "coverImage": "Obraz wyróżniający",
+          "coverImageAlt": "Tekst alternatywny obrazu",
+          "status": "Status",
+          "publishedAt": "Opublikowano",
+          "updatedAt": "Zaktualizowano"
+        }
+      },
+      "category": {
+        "label": "{count, plural, one {Kategoria} few {Kategorie} many {Kategorii} other {Kategorii}}",
+        "title": "Kategorie",
+        "desc": "Grupuj artykuły razem.",
+        "fields": {
+          "name": "Nazwa",
+          "color": "Kolor",
+          "updatedAt": "Zaktualizowano"
+        }
+      }
+    },
+    "admin": {
+      "article": {
+        "content": {
+          "label": "Treść"
+        },
+        "form": {
+          "publish": "Publikacja",
+          "cover": {
+            "title": "Obraz wyróżniający"
+          },
+          "settings": {
+            "title": "Ustawienia artykułu"
+          }
+        }
+      },
+      "category": {
+        "color": {
+          "label": "Kolor",
+          "desc": "Wyświetlany obok kategorii na listach.",
+          "none": "Brak koloru"
+        }
+      }
+    }
+  },
+  "@vitnode/blog:posts": "Artykuły",
+  "@vitnode/blog:posts:can_view": "Wyświetlanie listy artykułów",
+  "@vitnode/blog:posts:can_create": "Tworzenie artykułów",
+  "@vitnode/blog:posts:can_edit": "Edytowanie artykułów",
+  "@vitnode/blog:posts:can_delete": "Usuwanie artykułów",
+  "@vitnode/blog:posts:can_publish": "Publikowanie i cofanie publikacji artykułów",
+  "@vitnode/blog:posts:can_restore": "Przywracanie wcześniejszej wersji artykułu",
+  "@vitnode/blog:categories": "Kategorie",
+  "@vitnode/blog:categories:can_view": "Wyświetlanie listy kategorii",
+  "@vitnode/blog:categories:can_create": "Tworzenie kategorii",
+  "@vitnode/blog:categories:can_edit": "Edytowanie kategorii",
+  "@vitnode/blog:categories:can_delete": "Usuwanie kategorii"
+}

package/tsconfig.build.json

@@ -1,5 +1,10 @@
 {
   "$schema": "https://json.schemastore.org/tsconfig",
   "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "**/*.test.ts", "**/*.test.tsx"]
+  "exclude": [
+    "node_modules",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.test-d.ts"
+  ]
 }

package/dist/src/api/lib/categories-language.d.ts

@@ -1,10 +0,0 @@
-import type { MultiLangValue } from "@vitnode/core/lib/helpers/multi-lang";
-import type { Context } from "hono";
-export declare const CATEGORY_LANG_TABLE = "blog_categories";
-export declare const CATEGORY_LANG_VARIABLE = "title";
-export interface CategoryTranslations {
-    title: MultiLangValue;
-}
-export declare const saveCategoryTranslations: (c: Context, itemId: number, { title }: CategoryTranslations) => Promise<void>;
-export declare const loadCategoryTranslations: (c: Context, categoryIds: number[]) => Promise<Map<number, MultiLangValue>>;
-//# sourceMappingURL=categories-language.d.ts.map

package/dist/src/api/lib/categories-language.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"categories-language.d.ts","sourceRoot":"","sources":["../../../../src/api/lib/categories-language.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAC3E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAQpC,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AACrD,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAE9C,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,cAAc,CAAC;CACvB;AAID,eAAO,MAAM,wBAAwB,GACnC,GAAG,OAAO,EACV,QAAQ,MAAM,EACd,WAAW,oBAAoB,KAC9B,OAAO,CAAC,IAAI,CAQd,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,GAAG,OAAO,EACV,aAAa,MAAM,EAAE,KACpB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAiCrC,CAAC"}

package/dist/src/api/lib/categories-language.js

@@ -1 +0,0 @@
-import{saveLanguageWords}from"@vitnode/core/api/lib/save-language-words";import{core_languages_words}from"@vitnode/core/database/languages";import{and,eq,inArray}from"drizzle-orm";import{CONFIG_PLUGIN}from"../../const.js";export const CATEGORY_LANG_TABLE="blog_categories";export const CATEGORY_LANG_VARIABLE="title";export const saveCategoryTranslations=async(c,itemId,{title})=>{await saveLanguageWords(c,{pluginCode:CONFIG_PLUGIN.pluginId,tableName:CATEGORY_LANG_TABLE,variable:CATEGORY_LANG_VARIABLE,itemId,values:title})};export const loadCategoryTranslations=async(c,categoryIds)=>{const result=new Map;if(categoryIds.length===0){return result}const words=await c.get("db").select({itemId:core_languages_words.itemId,languageCode:core_languages_words.languageCode,value:core_languages_words.value}).from(core_languages_words).where(and(eq(core_languages_words.pluginCode,CONFIG_PLUGIN.pluginId),eq(core_languages_words.tableName,CATEGORY_LANG_TABLE),eq(core_languages_words.variable,CATEGORY_LANG_VARIABLE),inArray(core_languages_words.itemId,categoryIds)));for(const id of categoryIds){result.set(id,words.filter(word=>word.itemId===id).map(({languageCode,value})=>({languageCode,value})))}return result};

package/dist/src/api/lib/posts-language.d.ts

@@ -1,17 +0,0 @@
-import type { MultiLangValue } from "@vitnode/core/lib/helpers/multi-lang";
-import type { Context } from "hono";
-export declare const POST_LANG_TABLE = "blog_posts";
-export declare const POST_LANG_VARIABLES: readonly ["title", "content", "friendlyUrl"];
-export type PostLangVariable = (typeof POST_LANG_VARIABLES)[number];
-export interface PostTranslations {
-    content: MultiLangValue;
-    friendlyUrl: MultiLangValue;
-    title: MultiLangValue;
-}
-export declare const slugifyMultiLang: (values: MultiLangValue) => MultiLangValue;
-export declare const getDefaultLanguageCode: (c: Context) => Promise<null | string>;
-export declare const pickDefaultValue: (values: MultiLangValue, defaultLanguageCode: null | string) => string;
-export declare const resolveLangValue: (values: MultiLangValue | undefined, languageCode: string, defaultLanguageCode: null | string) => string;
-export declare const savePostTranslations: (c: Context, itemId: number, translations: PostTranslations) => Promise<void>;
-export declare const loadPostTranslations: (c: Context, postIds: number[]) => Promise<Map<number, PostTranslations>>;
-//# sourceMappingURL=posts-language.d.ts.map

package/dist/src/api/lib/posts-language.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"posts-language.d.ts","sourceRoot":"","sources":["../../../../src/api/lib/posts-language.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAC3E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAapC,eAAO,MAAM,eAAe,eAAe,CAAC;AAC5C,eAAO,MAAM,mBAAmB,8CAA+C,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,cAAc,CAAC;IACxB,WAAW,EAAE,cAAc,CAAC;IAC5B,KAAK,EAAE,cAAc,CAAC;CACvB;AAED,eAAO,MAAM,gBAAgB,GAAI,QAAQ,cAAc,KAAG,cAIrD,CAAC;AAEN,eAAO,MAAM,sBAAsB,GACjC,GAAG,OAAO,KACT,OAAO,CAAC,IAAI,GAAG,MAAM,CASvB,CAAC;AAKF,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,cAAc,EACtB,qBAAqB,IAAI,GAAG,MAAM,KACjC,MAGC,CAAC;AAKL,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,cAAc,GAAG,SAAS,EAClC,cAAc,MAAM,EACpB,qBAAqB,IAAI,GAAG,MAAM,KACjC,MAEkD,CAAC;AAEtD,eAAO,MAAM,oBAAoB,GAC/B,GAAG,OAAO,EACV,QAAQ,MAAM,EACd,cAAc,gBAAgB,KAC7B,OAAO,CAAC,IAAI,CAed,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,GAAG,OAAO,EACV,SAAS,MAAM,EAAE,KAChB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAuCvC,CAAC"}

package/dist/src/api/lib/posts-language.js

@@ -1 +0,0 @@
-import{saveLanguageWords}from"@vitnode/core/api/lib/save-language-words";import{core_languages,core_languages_words}from"@vitnode/core/database/languages";import{getLangValue}from"@vitnode/core/lib/helpers/multi-lang";import{removeSpecialCharacters}from"@vitnode/core/lib/special-characters";import{and,eq,inArray}from"drizzle-orm";import{CONFIG_PLUGIN}from"../../const.js";export const POST_LANG_TABLE="blog_posts";export const POST_LANG_VARIABLES=["title","content","friendlyUrl"];export const slugifyMultiLang=values=>values.map(({languageCode,value})=>({languageCode,value:removeSpecialCharacters(value)}));export const getDefaultLanguageCode=async c=>{const[language]=await c.get("db").select({code:core_languages.code}).from(core_languages).where(eq(core_languages.default,true)).limit(1);return language?.code??null};export const pickDefaultValue=(values,defaultLanguageCode)=>values.find(item=>item.languageCode===defaultLanguageCode)?.value??values[0]?.value??"";export const resolveLangValue=(values,languageCode,defaultLanguageCode)=>getLangValue(values,languageCode)||pickDefaultValue(values??[],defaultLanguageCode);export const savePostTranslations=async(c,itemId,translations)=>{await Promise.all(POST_LANG_VARIABLES.map(async variable=>{await saveLanguageWords(c,{pluginCode:CONFIG_PLUGIN.pluginId,tableName:POST_LANG_TABLE,variable,itemId,values:variable==="friendlyUrl"?slugifyMultiLang(translations.friendlyUrl):translations[variable]})}))};export const loadPostTranslations=async(c,postIds)=>{const result=new Map;if(postIds.length===0){return result}const words=await c.get("db").select({itemId:core_languages_words.itemId,variable:core_languages_words.variable,languageCode:core_languages_words.languageCode,value:core_languages_words.value}).from(core_languages_words).where(and(eq(core_languages_words.pluginCode,CONFIG_PLUGIN.pluginId),eq(core_languages_words.tableName,POST_LANG_TABLE),inArray(core_languages_words.variable,[...POST_LANG_VARIABLES]),inArray(core_languages_words.itemId,postIds)));for(const id of postIds){result.set(id,{title:words.filter(word=>word.itemId===id&&word.variable==="title").map(({languageCode,value})=>({languageCode,value})),content:words.filter(word=>word.itemId===id&&word.variable==="content").map(({languageCode,value})=>({languageCode,value})),friendlyUrl:words.filter(word=>word.itemId===id&&word.variable==="friendlyUrl").map(({languageCode,value})=>({languageCode,value}))})}return result};

package/dist/src/api/lib/search.d.ts

@@ -1,13 +0,0 @@
-import type { SearchIndexer } from "@vitnode/core/api/models/search";
-import type { Context } from "hono";
-interface BlogPostForSearch {
-    authorId: null | number;
-    categoryId: number;
-    createdAt: Date;
-    id: number;
-    updatedAt?: Date;
-}
-export declare const reindexBlogPost: (c: Context, post: BlogPostForSearch) => Promise<void>;
-export declare const blogPostSearchIndexer: SearchIndexer;
-export {};
-//# sourceMappingURL=search.d.ts.map

package/dist/src/api/lib/search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/api/lib/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,aAAa,EACd,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAcpC,UAAU,iBAAiB;IACzB,QAAQ,EAAE,IAAI,GAAG,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAmDD,eAAO,MAAM,eAAe,GAC1B,GAAG,OAAO,EACV,MAAM,iBAAiB,KACtB,OAAO,CAAC,IAAI,CAoBd,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,aA4CnC,CAAC"}

package/dist/src/api/lib/search.js

@@ -1 +0,0 @@
-import{asc,count}from"drizzle-orm";import{blog_posts}from"../../database/posts.js";import{getDefaultLanguageCode,loadPostTranslations,resolveLangValue}from"./posts-language.js";const getEnabledLanguageCodes=c=>c.get("core").i18n.locales.filter(locale=>locale.enabled!==false).map(locale=>locale.code);const buildDocumentsForPost=(post,languageCodes,translations,defaultLanguageCode)=>{const codes=languageCodes.length>0?languageCodes:[""];return codes.map(languageCode=>{const friendlyUrl=resolveLangValue(translations?.friendlyUrl,languageCode,defaultLanguageCode);return{itemType:"blog_post",itemId:post.id,languageCode,authorId:post.authorId,title:resolveLangValue(translations?.title,languageCode,defaultLanguageCode),content:resolveLangValue(translations?.content,languageCode,defaultLanguageCode),containerType:"blog_category",containerId:post.categoryId,url:`/blog/${post.categoryId}/${friendlyUrl}`,isPublic:true,createdAt:post.createdAt,updatedAt:post.updatedAt}})};export const reindexBlogPost=async(c,post)=>{const languageCodes=getEnabledLanguageCodes(c);const[defaultLanguageCode,translations]=await Promise.all([getDefaultLanguageCode(c),loadPostTranslations(c,[post.id])]);await c.get("search").delete("blog_post",post.id);await c.get("search").bulkIndex(buildDocumentsForPost(post,languageCodes,translations.get(post.id),defaultLanguageCode))};export const blogPostSearchIndexer={itemType:"blog_post",count:async c=>{const[row]=await c.get("db").select({value:count()}).from(blog_posts);return row?.value??0},load:async(c,offset,limit)=>{const rows=await c.get("db").select({id:blog_posts.id,categoryId:blog_posts.categoryId,authorId:blog_posts.authorId,createdAt:blog_posts.createdAt,updatedAt:blog_posts.updatedAt}).from(blog_posts).orderBy(asc(blog_posts.id)).limit(limit).offset(offset);if(rows.length===0){return[]}const languageCodes=getEnabledLanguageCodes(c);const[defaultLanguageCode,translations]=await Promise.all([getDefaultLanguageCode(c),loadPostTranslations(c,rows.map(row=>row.id))]);return rows.flatMap(post=>buildDocumentsForPost(post,languageCodes,translations.get(post.id),defaultLanguageCode))}};

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

@@ -1,100 +0,0 @@
-export declare const categoriesAdminModule: import("@vitnode/core/api/lib/module").BuildModuleReturn<"@vitnode/blog", "categories", [import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "post";
-    path: "/";
-    request: {
-        body: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        title: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        color: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-        };
-    };
-    responses: {
-        201: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        id: import("zod").ZodNumber;
-                        createdAt: import("zod").ZodDate;
-                        updatedAt: import("zod").ZodDate;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-            description: string;
-        };
-        400: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "put";
-    path: "/{id}";
-    request: {
-        params: import("zod").ZodObject<{
-            id: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<number, string>>;
-        }, import("zod/v4/core").$strip>;
-        body: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        title: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        color: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-        };
-    };
-    responses: {
-        200: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        id: import("zod").ZodNumber;
-                        createdAt: import("zod").ZodDate;
-                        updatedAt: import("zod").ZodDate;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-            description: string;
-        };
-        400: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "delete";
-    path: "/{id}";
-    request: {
-        params: import("zod").ZodObject<{
-            id: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<number, string>>;
-        }, import("zod/v4/core").$strip>;
-    };
-    responses: {
-        204: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>], import("@vitnode/core/api/lib/module").BaseBuildModuleReturn<"@vitnode/blog", string, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", import("@hono/zod-openapi").RouteConfig>[]>[]>;
-//# sourceMappingURL=categories.admin.module.d.ts.map

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

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

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

@@ -1 +0,0 @@
-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";export const categoriesAdminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"categories",routes:[createCategoryRoute,editCategoryRoute,deleteCategoryRoute]});

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

@@ -1,47 +0,0 @@
-import { z } from "@hono/zod-openapi";
-export declare const zodCreateCategorySchema: z.ZodObject<{
-    title: z.ZodArray<z.ZodObject<{
-        languageCode: z.ZodString;
-        value: z.ZodString;
-    }, z.core.$strip>>;
-    color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export declare const createCategoryRoute: import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "post";
-    path: "/";
-    request: {
-        body: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        title: z.ZodArray<z.ZodObject<{
-                            languageCode: z.ZodString;
-                            value: z.ZodString;
-                        }, z.core.$strip>>;
-                        color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>;
-                };
-            };
-        };
-    };
-    responses: {
-        201: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        id: z.ZodNumber;
-                        createdAt: z.ZodDate;
-                        updatedAt: z.ZodDate;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-        400: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>;
-//# sourceMappingURL=create.route.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/admin/categories/routes/create.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAetC,eAAO,MAAM,uBAAuB;;;;;;iBAGlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+C9B,CAAC"}

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

@@ -1 +0,0 @@
-import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{multiLangValueSchema}from"@vitnode/core/lib/helpers/multi-lang";import{CONFIG_PLUGIN}from"../../../../../const.js";import{blog_categories}from"../../../../../database/categories.js";import{saveCategoryTranslations}from"../../../../lib/categories-language.js";const zodCategoryResponseSchema=z.object({id:z.number(),createdAt:z.date(),updatedAt:z.date()});export const zodCreateCategorySchema=z.object({title:multiLangValueSchema({minLength:1,maxLength:100}).min(1),color:z.string().nullish()});export const createCategoryRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"categories",permission:"can_create"},route:{method:"post",path:"/",request:{body:{content:{"application/json":{schema:zodCreateCategorySchema}}}},responses:{201:{content:{"application/json":{schema:zodCategoryResponseSchema}},description:"Category created successfully"},400:{description:"Bad request - Invalid input data"}}},handler:async c=>{const{title,color}=c.req.valid("json");const[category]=await c.get("db").insert(blog_categories).values({color:color?.trim()?color:null}).returning();await saveCategoryTranslations(c,category.id,{title});await c.get("events").emit("blog.category.created",{categoryId:category.id});return c.json(category,201)}});

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

@@ -1,21 +0,0 @@
-import { z } from "@hono/zod-openapi";
-export declare const deleteCategoryRoute: import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "delete";
-    path: "/{id}";
-    request: {
-        params: z.ZodObject<{
-            id: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
-        }, z.core.$strip>;
-    };
-    responses: {
-        204: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>;
-//# sourceMappingURL=delete.route.d.ts.map

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

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

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

@@ -1 +0,0 @@
-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_categories}from"../../../../../database/categories.js";import{blog_posts}from"../../../../../database/posts.js";export const deleteCategoryRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"categories",permission:"can_delete"},route:{method:"delete",path:"/{id}",request:{params:z.object({id:z.string().transform(Number)})},responses:{204:{description:"Category deleted successfully"},404:{description:"Category not found"}}},handler:async c=>{const{id}=c.req.valid("param");const posts=await c.get("db").select({id:blog_posts.id}).from(blog_posts).where(eq(blog_posts.categoryId,id));const result=await c.get("db").delete(blog_categories).where(eq(blog_categories.id,id)).returning();if(result.length===0){throw new HTTPException(404)}await c.get("events").emit("blog.category.deleted",{categoryId:id,postIds:posts.map(post=>post.id)});return c.body(null,204)}});

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

@@ -1,46 +0,0 @@
-import { z } from "@hono/zod-openapi";
-export declare const editCategoryRoute: import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "put";
-    path: "/{id}";
-    request: {
-        params: z.ZodObject<{
-            id: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;
-        }, z.core.$strip>;
-        body: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        title: z.ZodArray<z.ZodObject<{
-                            languageCode: z.ZodString;
-                            value: z.ZodString;
-                        }, z.core.$strip>>;
-                        color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    }, z.core.$strip>;
-                };
-            };
-        };
-    };
-    responses: {
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        id: z.ZodNumber;
-                        createdAt: z.ZodDate;
-                        updatedAt: z.ZodDate;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-        400: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>;
-//# sourceMappingURL=edit.route.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAiBtC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkE5B,CAAC"}

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

@@ -1 +0,0 @@
-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_categories}from"../../../../../database/categories.js";import{saveCategoryTranslations}from"../../../../lib/categories-language.js";import{zodCreateCategorySchema}from"./create.route.js";const zodCategoryResponseSchema=z.object({id:z.number(),createdAt:z.date(),updatedAt:z.date()});export const editCategoryRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"categories",permission:"can_edit"},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,color}=c.req.valid("json");const[editData]=await c.get("db").select({id:blog_categories.id}).from(blog_categories).where(eq(blog_categories.id,id)).limit(1);if(!editData){throw new HTTPException(404)}const[category]=await c.get("db").update(blog_categories).set({color:color?.trim()?color:null}).where(eq(blog_categories.id,id)).returning();await saveCategoryTranslations(c,id,{title});await c.get("events").emit("blog.category.updated",{categoryId:id});return c.json(category)}});

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

@@ -1,121 +0,0 @@
-export declare const postsAdminModule: import("@vitnode/core/api/lib/module").BuildModuleReturn<"@vitnode/blog", "posts", [import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "put";
-    path: "/{id}";
-    request: {
-        params: import("zod").ZodObject<{
-            id: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<number, string>>;
-        }, import("zod/v4/core").$strip>;
-        body: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        title: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        content: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        friendlyUrl: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        categoryId: import("zod").ZodNumber;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-        };
-    };
-    responses: {
-        200: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        id: import("zod").ZodNumber;
-                        categoryId: import("zod").ZodNumber;
-                        createdAt: import("zod").ZodDate;
-                        updatedAt: import("zod").ZodDate;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-            description: string;
-        };
-        400: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "post";
-    path: "/";
-    request: {
-        body: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        title: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        content: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        friendlyUrl: import("zod").ZodArray<import("zod").ZodObject<{
-                            languageCode: import("zod").ZodString;
-                            value: import("zod").ZodString;
-                        }, import("zod/v4/core").$strip>>;
-                        categoryId: import("zod").ZodNumber;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-        };
-    };
-    responses: {
-        201: {
-            content: {
-                "application/json": {
-                    schema: import("zod").ZodObject<{
-                        id: import("zod").ZodNumber;
-                        categoryId: import("zod").ZodNumber;
-                        createdAt: import("zod").ZodDate;
-                        updatedAt: import("zod").ZodDate;
-                    }, import("zod/v4/core").$strip>;
-                };
-            };
-            description: string;
-        };
-        400: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "delete";
-    path: "/{id}";
-    request: {
-        params: import("zod").ZodObject<{
-            id: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<number, string>>;
-        }, import("zod/v4/core").$strip>;
-    };
-    responses: {
-        204: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>], import("@vitnode/core/api/lib/module").BaseBuildModuleReturn<"@vitnode/blog", string, import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", 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

@@ -1 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sMAI3B,CAAC"}

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

@@ -1 +0,0 @@
-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({pluginId:CONFIG_PLUGIN.pluginId,name:"posts",routes:[editPostRoute,createPostRoute,deletePostRoute]});

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

@@ -1,67 +0,0 @@
-import { z } from "@hono/zod-openapi";
-export declare const zodCreatePostSchema: z.ZodObject<{
-    title: z.ZodArray<z.ZodObject<{
-        languageCode: z.ZodString;
-        value: z.ZodString;
-    }, z.core.$strip>>;
-    content: z.ZodArray<z.ZodObject<{
-        languageCode: z.ZodString;
-        value: z.ZodString;
-    }, z.core.$strip>>;
-    friendlyUrl: z.ZodArray<z.ZodObject<{
-        languageCode: z.ZodString;
-        value: z.ZodString;
-    }, z.core.$strip>>;
-    categoryId: z.ZodNumber;
-}, z.core.$strip>;
-export declare const createPostRoute: import("@vitnode/core/api/lib/route").Route<"@vitnode/blog", {
-    method: "post";
-    path: "/";
-    request: {
-        body: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        title: z.ZodArray<z.ZodObject<{
-                            languageCode: z.ZodString;
-                            value: z.ZodString;
-                        }, z.core.$strip>>;
-                        content: z.ZodArray<z.ZodObject<{
-                            languageCode: z.ZodString;
-                            value: z.ZodString;
-                        }, z.core.$strip>>;
-                        friendlyUrl: z.ZodArray<z.ZodObject<{
-                            languageCode: z.ZodString;
-                            value: z.ZodString;
-                        }, z.core.$strip>>;
-                        categoryId: z.ZodNumber;
-                    }, z.core.$strip>;
-                };
-            };
-        };
-    };
-    responses: {
-        201: {
-            content: {
-                "application/json": {
-                    schema: z.ZodObject<{
-                        id: z.ZodNumber;
-                        categoryId: z.ZodNumber;
-                        createdAt: z.ZodDate;
-                        updatedAt: z.ZodDate;
-                    }, z.core.$strip>;
-                };
-            };
-            description: string;
-        };
-        400: {
-            description: string;
-        };
-        404: {
-            description: string;
-        };
-    };
-} & {
-    path: string;
-}>;
-//# sourceMappingURL=create.route.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAyBtC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoG1B,CAAC"}

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

@@ -1 +0,0 @@
-import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{core_languages_words}from"@vitnode/core/database/languages";import{multiLangValueSchema}from"@vitnode/core/lib/helpers/multi-lang";import{and,eq,inArray}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{POST_LANG_TABLE,savePostTranslations,slugifyMultiLang}from"../../../../lib/posts-language.js";import{reindexBlogPost}from"../../../../lib/search.js";const zodPostResponseSchema=z.object({id:z.number(),categoryId:z.number(),createdAt:z.date(),updatedAt:z.date()});export const zodCreatePostSchema=z.object({title:multiLangValueSchema({minLength:3,maxLength:255}).min(1),content:multiLangValueSchema(),friendlyUrl:multiLangValueSchema({minLength:1,maxLength:255}).min(1),categoryId:z.number()});export const createPostRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"posts",permission:"can_create"},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,friendlyUrl,categoryId}=c.req.valid("json");const slugFriendlyUrl=slugifyMultiLang(friendlyUrl);const friendlyUrlValues=[...new Set(slugFriendlyUrl.map(item=>item.value).filter(Boolean))];if(friendlyUrlValues.length===0){throw new HTTPException(400,{message:"Friendly URL is required."})}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[duplicate]=await c.get("db").select({itemId:core_languages_words.itemId}).from(core_languages_words).where(and(eq(core_languages_words.pluginCode,CONFIG_PLUGIN.pluginId),eq(core_languages_words.tableName,POST_LANG_TABLE),eq(core_languages_words.variable,"friendlyUrl"),inArray(core_languages_words.value,friendlyUrlValues))).limit(1);if(duplicate){throw new HTTPException(400,{message:"Post with this title already exists."})}const[post]=await c.get("db").insert(blog_posts).values({categoryId,authorId:c.get("admin")?.user.id??c.get("user")?.id??null}).returning();await savePostTranslations(c,post.id,{title,content,friendlyUrl});await reindexBlogPost(c,post);await c.get("events").emit("blog.post.created",{postId:post.id,categoryId:post.categoryId});return c.json(post,201)}});