@vitnode/blog 1.2.0-canary.75 → 1.2.0-canary.77

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1 @@
+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/events.d.ts

@@ -0,0 +1,28 @@
+declare module "@vitnode/core/api/models/events" {
+    interface VitNodeEvents {
+        "blog.category.created": {
+            categoryId: number;
+        };
+        "blog.category.deleted": {
+            categoryId: number;
+            postIds: number[];
+        };
+        "blog.category.updated": {
+            categoryId: number;
+        };
+        "blog.post.created": {
+            categoryId: number;
+            postId: number;
+        };
+        "blog.post.deleted": {
+            categoryId: number;
+            postId: number;
+        };
+        "blog.post.updated": {
+            categoryId: number;
+            postId: number;
+        };
+    }
+}
+export declare const cleanupCategorySearchListener: import("@vitnode/core/api/lib/events").BuildEventListenerReturn<keyof import("@vitnode/core/api/models/events").VitNodeEvents>;
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../src/api/lib/events.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,iCAAiC,CAAC;IAC/C,UAAU,aAAa;QACrB,uBAAuB,EAAE;YACvB,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC;QACF,uBAAuB,EAAE;YACvB,UAAU,EAAE,MAAM,CAAC;YACnB,OAAO,EAAE,MAAM,EAAE,CAAC;SACnB,CAAC;QACF,uBAAuB,EAAE;YACvB,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC;QACF,mBAAmB,EAAE;YACnB,UAAU,EAAE,MAAM,CAAC;YACnB,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;QACF,mBAAmB,EAAE;YACnB,UAAU,EAAE,MAAM,CAAC;YACnB,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;QACF,mBAAmB,EAAE;YACnB,UAAU,EAAE,MAAM,CAAC;YACnB,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;KACH;CACF;AAED,eAAO,MAAM,6BAA6B,gIAUxC,CAAC"}

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

@@ -0,0 +1 @@
+import{buildEventListener}from"@vitnode/core/api/lib/events";export const cleanupCategorySearchListener=buildEventListener({event:"blog.category.deleted",name:"cleanup-category-search",description:"Remove search index rows of posts cascade-deleted with a category",handler:async(c,payload)=>{for(const postId of payload.postIds){await c.get("search").delete("blog_post",postId)}}});

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1 @@
+{"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;AAepC,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;AAuDD,eAAO,MAAM,eAAe,GAC1B,GAAG,OAAO,EACV,MAAM,iBAAiB,KACtB,OAAO,CAAC,IAAI,CAoBd,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,aA6CnC,CAAC"}

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

@@ -0,0 +1 @@
+import{core_languages}from"@vitnode/core/database/languages";import{asc,count,eq}from"drizzle-orm";import{blog_posts}from"../../database/posts.js";import{getDefaultLanguageCode,loadPostTranslations,resolveLangValue}from"./posts-language.js";const getEnabledLanguageCodes=async c=>{const rows=await c.get("db").select({code:core_languages.code}).from(core_languages).where(eq(core_languages.enabled,true));return rows.map(row=>row.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,defaultLanguageCode,translations]=await Promise.all([getEnabledLanguageCodes(c),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,defaultLanguageCode,translations]=await Promise.all([getEnabledLanguageCodes(c),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/admin.module.d.ts

@@ -6,7 +6,11 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
+                        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>;
                 };
             };
@@ -18,7 +22,6 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
                 "application/json": {
                     schema: import("zod").ZodObject<{
                         id: import("zod").ZodNumber;
-                        title: import("zod").ZodString;
                         createdAt: import("zod").ZodDate;
                         updatedAt: import("zod").ZodDate;
                     }, import("zod/v4/core").$strip>;
@@ -43,7 +46,11 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
+                        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>;
                 };
             };
@@ -55,7 +62,6 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
                 "application/json": {
                     schema: import("zod").ZodObject<{
                         id: import("zod").ZodNumber;
-                        title: import("zod").ZodString;
                         createdAt: import("zod").ZodDate;
                         updatedAt: import("zod").ZodDate;
                     }, import("zod/v4/core").$strip>;
@@ -101,8 +107,18 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
-                        content: import("zod").ZodString;
+                        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>;
                 };
@@ -115,9 +131,6 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
                 "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;
@@ -143,8 +156,18 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
-                        content: import("zod").ZodString;
+                        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>;
                 };
@@ -157,9 +180,6 @@ export declare const adminModule: import("@vitnode/core/api/lib/module").BuildMo
                 "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;

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

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

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

@@ -1 +1 @@
-import{buildModule}from"@vitnode/core/api/lib/module";import{CONFIG_PLUGIN}from"../../../const.js";import{categoriesAdminModule}from"./categories/categories.admin.module.js";import{postsAdminModule}from"./posts/posts.admin.module.js";export const adminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"admin",modules:[categoriesAdminModule,postsAdminModule],routes:[]});
+import{buildModule}from"@vitnode/core/api/lib/module";import{CONFIG_PLUGIN}from"../../../const.js";import{cleanupCategorySearchListener}from"../../lib/events.js";import{categoriesAdminModule}from"./categories/categories.admin.module.js";import{postsAdminModule}from"./posts/posts.admin.module.js";export const adminModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"admin",modules:[categoriesAdminModule,postsAdminModule],routes:[],events:[cleanupCategorySearchListener]});

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

@@ -6,7 +6,11 @@ export declare const categoriesAdminModule: import("@vitnode/core/api/lib/module
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
+                        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>;
                 };
             };
@@ -18,7 +22,6 @@ export declare const categoriesAdminModule: import("@vitnode/core/api/lib/module
                 "application/json": {
                     schema: import("zod").ZodObject<{
                         id: import("zod").ZodNumber;
-                        title: import("zod").ZodString;
                         createdAt: import("zod").ZodDate;
                         updatedAt: import("zod").ZodDate;
                     }, import("zod/v4/core").$strip>;
@@ -43,7 +46,11 @@ export declare const categoriesAdminModule: import("@vitnode/core/api/lib/module
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
+                        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>;
                 };
             };
@@ -55,7 +62,6 @@ export declare const categoriesAdminModule: import("@vitnode/core/api/lib/module
                 "application/json": {
                     schema: import("zod").ZodObject<{
                         id: import("zod").ZodNumber;
-                        title: import("zod").ZodString;
                         createdAt: import("zod").ZodDate;
                         updatedAt: import("zod").ZodDate;
                     }, import("zod/v4/core").$strip>;

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

@@ -1 +1 @@
-{"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"}
+{"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/routes/create.route.d.ts

@@ -1,6 +1,10 @@
 import { z } from "@hono/zod-openapi";
 export declare const zodCreateCategorySchema: z.ZodObject<{
-    title: z.ZodString;
+    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";
@@ -10,7 +14,11 @@ export declare const createCategoryRoute: import("@vitnode/core/api/lib/route").
             content: {
                 "application/json": {
                     schema: z.ZodObject<{
-                        title: z.ZodString;
+                        title: z.ZodArray<z.ZodObject<{
+                            languageCode: z.ZodString;
+                            value: z.ZodString;
+                        }, z.core.$strip>>;
+                        color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strip>;
                 };
             };
@@ -22,7 +30,6 @@ export declare const createCategoryRoute: import("@vitnode/core/api/lib/route").
                 "application/json": {
                     schema: z.ZodObject<{
                         id: z.ZodNumber;
-                        title: z.ZodString;
                         createdAt: z.ZodDate;
                         updatedAt: z.ZodDate;
                     }, z.core.$strip>;

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

@@ -1 +1 @@
-{"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;AAgBtC,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0D9B,CAAC"}
+{"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 +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";const zodCategoryResponseSchema=z.object({id:z.number(),title:z.string(),createdAt:z.date(),updatedAt:z.date()});export const zodCreateCategorySchema=z.object({title:z.string()});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}=c.req.valid("json");const titleSeo=removeSpecialCharacters(title);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){throw new HTTPException(400,{message:"Category with this title already exists."})}const[category]=await c.get("db").insert(blog_categories).values({title,titleSeo:removeSpecialCharacters(title)}).returning();return c.json(category,201)}});
+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.map

@@ -1 +1 @@
-{"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;AAQtC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAmC9B,CAAC"}
+{"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 +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_categories}from"../../../../../database/categories.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 result=await c.get("db").delete(blog_categories).where(eq(blog_categories.id,id)).returning();if(result.length===0){throw new HTTPException(404)}return c.body(null,204)}});
+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

@@ -10,7 +10,11 @@ export declare const editCategoryRoute: import("@vitnode/core/api/lib/route").Ro
             content: {
                 "application/json": {
                     schema: z.ZodObject<{
-                        title: z.ZodString;
+                        title: z.ZodArray<z.ZodObject<{
+                            languageCode: z.ZodString;
+                            value: z.ZodString;
+                        }, z.core.$strip>>;
+                        color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strip>;
                 };
             };
@@ -22,7 +26,6 @@ export declare const editCategoryRoute: import("@vitnode/core/api/lib/route").Ro
                 "application/json": {
                     schema: z.ZodObject<{
                         id: z.ZodNumber;
-                        title: z.ZodString;
                         createdAt: z.ZodDate;
                         updatedAt: z.ZodDate;
                     }, z.core.$strip>;

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkF5B,CAAC"}
+{"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 +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({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}=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)}});
+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

@@ -9,8 +9,18 @@ export declare const postsAdminModule: import("@vitnode/core/api/lib/module").Bu
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
-                        content: import("zod").ZodString;
+                        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>;
                 };
@@ -23,9 +33,6 @@ export declare const postsAdminModule: import("@vitnode/core/api/lib/module").Bu
                 "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;
@@ -51,8 +58,18 @@ export declare const postsAdminModule: import("@vitnode/core/api/lib/module").Bu
             content: {
                 "application/json": {
                     schema: import("zod").ZodObject<{
-                        title: import("zod").ZodString;
-                        content: import("zod").ZodString;
+                        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>;
                 };
@@ -65,9 +82,6 @@ export declare const postsAdminModule: import("@vitnode/core/api/lib/module").Bu
                 "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;

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sMAI3B,CAAC"}
+{"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/routes/create.route.d.ts

@@ -1,7 +1,17 @@
 import { z } from "@hono/zod-openapi";
 export declare const zodCreatePostSchema: z.ZodObject<{
-    title: z.ZodString;
-    content: z.ZodString;
+    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", {
@@ -12,8 +22,18 @@ export declare const createPostRoute: import("@vitnode/core/api/lib/route").Rout
             content: {
                 "application/json": {
                     schema: z.ZodObject<{
-                        title: z.ZodString;
-                        content: z.ZodString;
+                        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>;
                 };
@@ -26,9 +46,6 @@ export declare const createPostRoute: import("@vitnode/core/api/lib/route").Rout
                 "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;

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

@@ -1 +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;AAoBtC,eAAO,MAAM,mBAAmB;;;;iBAO9B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6E1B,CAAC"}
+{"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 +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";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 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()});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,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)}});
+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)}});

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

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

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

@@ -1 +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({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"posts",permission:"can_delete"},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)}});
+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({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"posts",permission:"can_delete"},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)}await c.get("search").delete("blog_post",id);await c.get("events").emit("blog.post.deleted",{postId:id,categoryId:result[0].categoryId});return c.body(null,204)}});

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

@@ -10,8 +10,18 @@ export declare const editPostRoute: import("@vitnode/core/api/lib/route").Route<
             content: {
                 "application/json": {
                     schema: z.ZodObject<{
-                        title: z.ZodString;
-                        content: z.ZodString;
+                        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>;
                 };
@@ -24,9 +34,6 @@ export declare const editPostRoute: import("@vitnode/core/api/lib/route").Route<
                 "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;

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+FxB,CAAC"}
+{"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;AAyBtC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiHxB,CAAC"}

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

@@ -1 +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({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"posts",permission:"can_edit"},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)}});
+import{z}from"@hono/zod-openapi";import{buildRoute}from"@vitnode/core/api/lib/route";import{core_languages_words}from"@vitnode/core/database/languages";import{and,eq,inArray,ne}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";import{zodCreatePostSchema}from"./create.route.js";const zodPostResponseSchema=z.object({id:z.number(),categoryId:z.number(),createdAt:z.date(),updatedAt:z.date()});export const editPostRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,adminStaffPermission:{module:"posts",permission:"can_edit"},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,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[existingPost]=await c.get("db").select({id:blog_posts.id}).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[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),ne(core_languages_words.itemId,id))).limit(1);if(duplicate){throw new HTTPException(400,{message:"Post with this title already exists."})}const[post]=await c.get("db").update(blog_posts).set({categoryId}).where(eq(blog_posts.id,id)).returning();await savePostTranslations(c,id,{title,content,friendlyUrl});await reindexBlogPost(c,post);await c.get("events").emit("blog.post.updated",{postId:post.id,categoryId:post.categoryId});return c.json(post)}});