@vitnode/core 0.0.1-canary.0

package/dist/src/api/modules/queue/cron/process-queue.cron.js

@@ -0,0 +1 @@
+import{buildCron}from"../../../lib/cron.js";import{processQueueTasks}from"../helpers/process-queue-tasks.js";export const processQueueCron=buildCron({name:"process-queue",description:"Process pending database queue tasks",schedule:"* * * * *",handler:async c=>{await processQueueTasks(c)}});

package/dist/src/api/modules/queue/helpers/process-queue-tasks.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from "hono";
+import type { EnvVitNode } from "../../../../api/middlewares/global.middleware";
+export declare const processQueueTasks: (c: Context<EnvVitNode>) => Promise<void>;
+//# sourceMappingURL=process-queue-tasks.d.ts.map

package/dist/src/api/modules/queue/helpers/process-queue-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-queue-tasks.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/queue/helpers/process-queue-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAgBtE,eAAO,MAAM,iBAAiB,GAC5B,GAAG,OAAO,CAAC,UAAU,CAAC,KACrB,OAAO,CAAC,IAAI,CAmGd,CAAC"}

package/dist/src/api/modules/queue/helpers/process-queue-tasks.js

@@ -0,0 +1 @@
+import{and,asc,desc,eq,inArray,lt,lte,sql}from"drizzle-orm";import{core_queue}from"../../../../database/queue.js";import{resolveQueueTaskOutcome}from"../../../../lib/api/resolve-queue-task-outcome.js";const QUEUE_BATCH_SIZE=25;const QUEUE_LOCK_KEY="queue:process";const QUEUE_LOCK_TTL_SECONDS=55;const QUEUE_RETENTION_DAYS=7;export const processQueueTasks=async c=>{const gotLock=await c.get("cache").acquireLock(QUEUE_LOCK_KEY,QUEUE_LOCK_TTL_SECONDS);if(!gotLock)return;try{const db=c.get("db");const now=new Date;const claimed=await db.transaction(async tx=>{const rows=await tx.select({id:core_queue.id}).from(core_queue).where(and(eq(core_queue.status,"pending"),lte(core_queue.availableAt,now))).orderBy(desc(core_queue.priority),asc(core_queue.id)).limit(QUEUE_BATCH_SIZE).for("update",{skipLocked:true});if(rows.length===0)return[];return tx.update(core_queue).set({status:"processing",reservedAt:now,attempts:sql`${core_queue.attempts} + 1`}).where(inArray(core_queue.id,rows.map(row=>row.id))).returning()});if(claimed.length>0){const handlerMap=new Map(c.get("core").queue.map(task=>[`${task.pluginId}:${task.name}`,task]));for(const task of claimed){const key=`${task.pluginId}:${task.name}`;const registered=handlerMap.get(key);let error=null;if(!registered){error=`No handler registered for queue task "${key}"`;await c.get("log").warn(error)}else{try{await registered.handler(c,task.payload)}catch(err){error=err instanceof Error?err.message:String(err);await c.get("log").error(`Queue task "${key}" failed: ${error}`)}}const outcome=resolveQueueTaskOutcome({attempts:task.attempts,maxAttempts:task.maxAttempts,error});await db.update(core_queue).set({status:outcome.status,lastError:outcome.lastError,availableAt:outcome.availableAt??task.availableAt,completedAt:outcome.completedAt??null,reservedAt:null}).where(eq(core_queue.id,task.id))}}const cutoff=new Date(now.getTime()-QUEUE_RETENTION_DAYS*24*60*60*1e3);await db.delete(core_queue).where(and(inArray(core_queue.status,["completed","failed"]),lt(core_queue.completedAt,cutoff)))}finally{await c.get("cache").releaseLock(QUEUE_LOCK_KEY)}};

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

@@ -0,0 +1,2 @@
+export declare const queueModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "queue", [], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=queue.module.d.ts.map

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

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

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

@@ -0,0 +1 @@
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{processQueueCron}from"./cron/process-queue.cron.js";import{sendEmailQueueTask}from"./tasks/send-email.task.js";export const queueModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"queue",routes:[],cronJobs:[processQueueCron],queueTasks:[sendEmailQueueTask]});

package/dist/src/api/modules/queue/tasks/send-email.task.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const sendEmailPayloadSchema: z.ZodObject<{
+    to: z.ZodString;
+    subject: z.ZodString;
+    html: z.ZodString;
+    text: z.ZodString;
+    replyTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const sendEmailQueueTask: import("../../../../api/lib/queue").BuildQueueTaskReturn;
+//# sourceMappingURL=send-email.task.d.ts.map

package/dist/src/api/modules/queue/tasks/send-email.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-email.task.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/queue/tasks/send-email.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,sBAAsB;;;;;;iBAMjC,CAAC;AAEH,eAAO,MAAM,kBAAkB,gDAQ7B,CAAC"}

package/dist/src/api/modules/queue/tasks/send-email.task.js

@@ -0,0 +1 @@
+import{z}from"zod";import{buildQueueTask}from"../../../lib/queue.js";import{EmailModel}from"../../../models/email.js";export const sendEmailPayloadSchema=z.object({to:z.string(),subject:z.string(),html:z.string(),text:z.string(),replyTo:z.string().optional()});export const sendEmailQueueTask=buildQueueTask({name:"send-email",description:"Deliver a rendered email through the configured provider.",handler:async(c,payload)=>{const email=sendEmailPayloadSchema.parse(payload);await new EmailModel(c).deliver(email)}});

package/dist/src/api/modules/search/routes/search.route.d.ts

@@ -0,0 +1,91 @@
+import { z } from "@hono/zod-openapi";
+export declare const zodSearchHitSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    pluginId: z.ZodString;
+    itemType: z.ZodString;
+    itemId: z.ZodNumber;
+    languageCode: z.ZodString;
+    authorId: z.ZodNullable<z.ZodNumber>;
+    title: z.ZodString;
+    content: z.ZodString;
+    containerType: z.ZodNullable<z.ZodString>;
+    containerId: z.ZodNullable<z.ZodNumber>;
+    url: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodDate;
+    score: z.ZodNullable<z.ZodNumber>;
+    author: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        nameCode: z.ZodString;
+        avatarColor: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const searchRoute: import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/";
+    request: {
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            first: z.ZodOptional<z.ZodString>;
+            last: z.ZodOptional<z.ZodString>;
+            search: z.ZodOptional<z.ZodString>;
+            types: z.ZodOptional<z.ZodString>;
+            authorId: z.ZodOptional<z.ZodString>;
+            containerId: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                newest: "newest";
+                oldest: "oldest";
+                relevance: "relevance";
+            }>>;
+            from: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+            lang: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            pluginId: z.ZodString;
+                            itemType: z.ZodString;
+                            itemId: z.ZodNumber;
+                            languageCode: z.ZodString;
+                            authorId: z.ZodNullable<z.ZodNumber>;
+                            title: z.ZodString;
+                            content: z.ZodString;
+                            containerType: z.ZodNullable<z.ZodString>;
+                            containerId: z.ZodNullable<z.ZodNumber>;
+                            url: z.ZodNullable<z.ZodString>;
+                            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            createdAt: z.ZodDate;
+                            score: z.ZodNullable<z.ZodNumber>;
+                            author: z.ZodNullable<z.ZodObject<{
+                                id: z.ZodNumber;
+                                name: z.ZodString;
+                                nameCode: z.ZodString;
+                                avatarColor: z.ZodString;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>;
+                        pageInfo: z.ZodObject<{
+                            totalCount: z.ZodNumber;
+                            count: z.ZodNumber;
+                            hasNextPage: z.ZodBoolean;
+                            hasPreviousPage: z.ZodBoolean;
+                            startCursor: z.ZodNullable<z.ZodNumber>;
+                            endCursor: z.ZodNullable<z.ZodNumber>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=search.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/search/routes/search.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAwBtC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBAuB7B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDtB,CAAC"}

package/dist/src/api/modules/search/routes/search.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{CONFIG_PLUGIN}from"../../../../config.js";import{buildRoute}from"../../../lib/route.js";import{zodPaginationQuery}from"../../../lib/with-pagination.js";const zodSearchPageInfo=z.object({totalCount:z.number(),count:z.number(),hasNextPage:z.boolean(),hasPreviousPage:z.boolean(),startCursor:z.number().nullable(),endCursor:z.number().nullable()});export const zodSearchHitSchema=z.object({id:z.number(),pluginId:z.string(),itemType:z.string(),itemId:z.number(),languageCode:z.string(),authorId:z.number().nullable(),title:z.string(),content:z.string(),containerType:z.string().nullable(),containerId:z.number().nullable(),url:z.string().nullable(),metadata:z.record(z.string(),z.unknown()),createdAt:z.date(),score:z.number().nullable(),author:z.object({id:z.number(),name:z.string(),nameCode:z.string(),avatarColor:z.string()}).nullable()});export const searchRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Search and browse indexed community content.",path:"/",request:{query:zodPaginationQuery.extend({search:z.string().optional(),types:z.string().optional(),authorId:z.string().optional(),containerId:z.string().optional(),sort:z.enum(["newest","oldest","relevance"]).optional(),from:z.string().optional(),to:z.string().optional(),lang:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(zodSearchHitSchema),pageInfo:zodSearchPageInfo})}},description:"Search results"}}},handler:async c=>{const query=c.req.valid("query");const result=await c.get("search").search({term:query.search,itemTypes:query.types?query.types.split(",").filter(Boolean):undefined,authorId:query.authorId?Number(query.authorId):undefined,containerId:query.containerId?Number(query.containerId):undefined,sort:query.sort,dateFrom:query.from?new Date(query.from):undefined,dateTo:query.to?new Date(query.to):undefined,first:query.first?Number(query.first):undefined,cursor:query.cursor,languageCode:query.lang,includePrivate:false});return c.json(result)}});

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

@@ -0,0 +1,68 @@
+export declare const searchModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "search", [import("../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/";
+    request: {
+        query: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodString>;
+            first: import("zod").ZodOptional<import("zod").ZodString>;
+            last: import("zod").ZodOptional<import("zod").ZodString>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+            types: import("zod").ZodOptional<import("zod").ZodString>;
+            authorId: import("zod").ZodOptional<import("zod").ZodString>;
+            containerId: import("zod").ZodOptional<import("zod").ZodString>;
+            sort: import("zod").ZodOptional<import("zod").ZodEnum<{
+                newest: "newest";
+                oldest: "oldest";
+                relevance: "relevance";
+            }>>;
+            from: import("zod").ZodOptional<import("zod").ZodString>;
+            to: import("zod").ZodOptional<import("zod").ZodString>;
+            lang: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        edges: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            pluginId: import("zod").ZodString;
+                            itemType: import("zod").ZodString;
+                            itemId: import("zod").ZodNumber;
+                            languageCode: import("zod").ZodString;
+                            authorId: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            title: import("zod").ZodString;
+                            content: import("zod").ZodString;
+                            containerType: import("zod").ZodNullable<import("zod").ZodString>;
+                            containerId: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            url: import("zod").ZodNullable<import("zod").ZodString>;
+                            metadata: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                            createdAt: import("zod").ZodDate;
+                            score: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            author: import("zod").ZodNullable<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                name: import("zod").ZodString;
+                                nameCode: import("zod").ZodString;
+                                avatarColor: import("zod").ZodString;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>>;
+                        pageInfo: import("zod").ZodObject<{
+                            totalCount: import("zod").ZodNumber;
+                            count: import("zod").ZodNumber;
+                            hasNextPage: import("zod").ZodBoolean;
+                            hasPreviousPage: import("zod").ZodBoolean;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodNumber>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=search.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/search/search.module.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8KAKvB,CAAC"}

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

@@ -0,0 +1 @@
+import{buildModule}from"../../lib/module.js";import{CONFIG_PLUGIN}from"../../../config.js";import{searchRoute}from"./routes/search.route.js";import{rebuildSearchIndexTask}from"./tasks/rebuild-index.task.js";export const searchModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"search",routes:[searchRoute],queueTasks:[rebuildSearchIndexTask]});

package/dist/src/api/modules/search/tasks/rebuild-index.task.d.ts

@@ -0,0 +1,2 @@
+export declare const rebuildSearchIndexTask: import("../../../../api/lib/queue").BuildQueueTaskReturn;
+//# sourceMappingURL=rebuild-index.task.d.ts.map

package/dist/src/api/modules/search/tasks/rebuild-index.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuild-index.task.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/search/tasks/rebuild-index.task.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,sBAAsB,gDA6DjC,CAAC"}

package/dist/src/api/modules/search/tasks/rebuild-index.task.js

@@ -0,0 +1 @@
+import{buildQueueTask}from"../../../lib/queue.js";import{normalizeSearchIndexerPage,searchDocumentOwner}from"../../../models/search.js";const PAGE_SIZE=200;export const rebuildSearchIndexTask=buildQueueTask({name:"rebuild-search-index",description:"Clear and rebuild the content search index. With no `itemType` payload it rebuilds every registered indexer; with one it rebuilds just that collection.",handler:async(c,payload)=>{const search=c.get("search");const itemType=typeof payload.itemType==="string"?payload.itemType:undefined;const indexers=c.get("core").searchIndexers.filter(indexer=>!itemType||indexer.itemType===itemType);if(itemType&&indexers.length===0){throw new Error(`[Search] Cannot rebuild collection "${itemType}": no search indexer is registered. Its documents were left alone - they may still be maintained by live writes, so remove them explicitly if that is what you meant.`)}await search.clear(itemType);for(const indexer of indexers){for(let offset=0;;){const page=normalizeSearchIndexerPage(await indexer.load(c,offset,PAGE_SIZE),PAGE_SIZE);if(page.itemsRead===0)break;if(page.documents.length>0){await search.bulkIndex(page.documents.map(document=>({...document,pluginId:searchDocumentOwner(document.pluginId)??indexer.pluginId})))}offset+=page.itemsRead}}}});

package/dist/src/api/modules/users/avatar-color.d.ts

@@ -0,0 +1,2 @@
+export declare const generateAvatarColor: (name: string) => string;
+//# sourceMappingURL=avatar-color.d.ts.map

package/dist/src/api/modules/users/avatar-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avatar-color.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/users/avatar-color.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,MAQlD,CAAC"}

package/dist/src/api/modules/users/avatar-color.js

@@ -0,0 +1 @@
+import{convertColor}from"../../../lib/colors.js";const getHashOfString=str=>{let hash=0;for(let i=0;i<str.length;i++){hash=str.charCodeAt(i)+((hash<<5)-hash)}hash=Math.abs(hash);return hash};const normalizeHash=(hash,min,max)=>{return Math.floor(hash%(max-min)+min)};const generateHSLFromName=name=>{const hRange=[0,360];const lRange=[25,60];const sRange=[50,75];const hash=getHashOfString(name);const h=normalizeHash(hash,hRange[0],hRange[1]);const s=normalizeHash(hash,sRange[0],sRange[1]);const l=normalizeHash(hash,lRange[0],lRange[1]);return[h,s,l]};export const generateAvatarColor=name=>{const hslName=generateHSLFromName(name);return convertColor.hslToHex({h:hslName[0],s:hslName[1],l:hslName[2]})};

package/dist/src/api/modules/users/files/files.module.d.ts

@@ -0,0 +1,143 @@
+export declare const userFilesModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "files", [import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/";
+    request: {
+        query: import("zod").ZodObject<{
+            cursor: import("zod").ZodOptional<import("zod").ZodString>;
+            first: import("zod").ZodOptional<import("zod").ZodString>;
+            last: import("zod").ZodOptional<import("zod").ZodString>;
+            order: import("zod").ZodOptional<import("zod").ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                createdAt: "createdAt";
+                size: "size";
+                name: "name";
+            }>>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        edges: import("zod").ZodArray<import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            name: import("zod").ZodString;
+                            folder: import("zod").ZodString;
+                            mimeType: import("zod").ZodNullable<import("zod").ZodString>;
+                            size: import("zod").ZodNumber;
+                            metadata: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                            createdAt: import("zod").ZodDate;
+                            dimensions: import("zod").ZodNullable<import("zod").ZodObject<{
+                                width: import("zod").ZodNumber;
+                                height: import("zod").ZodNumber;
+                            }, import("zod/v4/core").$strip>>;
+                            url: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>>;
+                        pageInfo: import("zod").ZodObject<{
+                            totalCount: import("zod").ZodNumber;
+                            count: import("zod").ZodNumber;
+                            hasNextPage: import("zod").ZodBoolean;
+                            hasPreviousPage: import("zod").ZodBoolean;
+                            startCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}/download";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/octet-stream": {
+                    schema: import("zod").ZodString;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>, import("../../../lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        query: import("zod").ZodObject<{
+            force: import("zod").ZodOptional<import("zod").ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        error: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: import("zod").ZodObject<{
+                        code: import("zod").ZodString;
+                        content: import("zod").ZodBoolean;
+                        id: import("zod").ZodNumber;
+                        revisions: import("zod").ZodNumber;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>], import("../../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
+//# sourceMappingURL=files.module.d.ts.map

package/dist/src/api/modules/users/files/files.module.d.ts.map

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

package/dist/src/api/modules/users/files/files.module.js

@@ -0,0 +1 @@
+import{buildModule}from"../../../lib/module.js";import{CONFIG_PLUGIN}from"../../../../config.js";import{deleteUserFileRoute}from"./routes/delete.route.js";import{downloadUserFileRoute}from"./routes/download.route.js";import{listUserFilesRoute}from"./routes/list.route.js";export const userFilesModule=buildModule({pluginId:CONFIG_PLUGIN.pluginId,name:"files",routes:[listUserFilesRoute,downloadUserFileRoute,deleteUserFileRoute]});

package/dist/src/api/modules/users/files/routes/delete.route.d.ts

@@ -0,0 +1,51 @@
+import { z } from "@hono/zod-openapi";
+export declare const deleteUserFileRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "delete";
+    description: string;
+    path: "/{id}";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        query: z.ZodObject<{
+            force: z.ZodOptional<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        409: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        code: z.ZodString;
+                        content: z.ZodBoolean;
+                        id: z.ZodNumber;
+                        revisions: z.ZodNumber;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=delete.route.d.ts.map

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

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

package/dist/src/api/modules/users/files/routes/delete.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{HTTPException}from"hono/http-exception";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";export const deleteUserFileRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"delete",description:"Delete one of the current user's files.",path:"/{id}",request:{params:z.object({id:z.string().openapi({example:"1"})}),query:z.object({force:z.enum(["true","false"]).optional()})},responses:{200:{description:"File deleted"},401:{description:"Not signed in"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"},409:{content:{"application/json":{schema:z.object({code:z.string(),content:z.boolean(),id:z.number(),revisions:z.number()})}},description:"Still referenced by content or by a retained revision, so the file was kept"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const{id}=c.req.valid("param");const fileId=Number(id);if(!Number.isInteger(fileId)){return c.json({error:"File not found"},404)}await c.get("storage").deleteFile(fileId,{force:c.req.query("force")==="true",ownerId:user.id});return c.body(null,200)}});

package/dist/src/api/modules/users/files/routes/download.route.d.ts

@@ -0,0 +1,37 @@
+import { z } from "@hono/zod-openapi";
+export declare const downloadUserFileRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/{id}/download";
+    request: {
+        params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/octet-stream": {
+                    schema: z.ZodString;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+        404: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        error: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=download.route.d.ts.map

package/dist/src/api/modules/users/files/routes/download.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/users/files/routes/download.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAQtC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8EhC,CAAC"}

package/dist/src/api/modules/users/files/routes/download.route.js

@@ -0,0 +1 @@
+import{z}from"@hono/zod-openapi";import{and,eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import{buildRoute}from"../../../../lib/route.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_files}from"../../../../../database/files.js";export const downloadUserFileRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"Download one of the current user's files as an attachment with its original name.",path:"/{id}/download",request:{params:z.object({id:z.string().openapi({example:"1"})})},responses:{200:{content:{"application/octet-stream":{schema:z.string().openapi({format:"binary",type:"string"})}},description:"File contents"},401:{description:"Not signed in"},404:{content:{"application/json":{schema:z.object({error:z.string()})}},description:"File not found"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const{id}=c.req.valid("param");const fileId=Number(id);if(!Number.isInteger(fileId)){return c.json({error:"File not found"},404)}const[file]=await c.get("db").select({name:core_files.name,key:core_files.key,mimeType:core_files.mimeType}).from(core_files).where(and(eq(core_files.id,fileId),eq(core_files.userId,user.id))).limit(1);if(!file||!c.get("core").storage?.adapter){return c.json({error:"File not found"},404)}const upstream=await fetch(c.get("storage").getUrl(file.key));if(!upstream.ok||!upstream.body){return c.json({error:"File not found"},404)}c.header("Content-Type",file.mimeType??"application/octet-stream");c.header("Content-Disposition",`attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`);const length=upstream.headers.get("content-length");if(length){c.header("Content-Length",length)}return c.body(upstream.body,200)}});

package/dist/src/api/modules/users/files/routes/list.route.d.ts

@@ -0,0 +1,62 @@
+import z from "zod";
+export declare const listUserFilesRoute: import("../../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "get";
+    description: string;
+    path: "/";
+    request: {
+        query: z.ZodObject<{
+            cursor: z.ZodOptional<z.ZodString>;
+            first: z.ZodOptional<z.ZodString>;
+            last: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>>;
+            orderBy: z.ZodOptional<z.ZodEnum<{
+                createdAt: "createdAt";
+                size: "size";
+                name: "name";
+            }>>;
+            search: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    responses: {
+        200: {
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        edges: z.ZodArray<z.ZodObject<{
+                            id: z.ZodNumber;
+                            name: z.ZodString;
+                            folder: z.ZodString;
+                            mimeType: z.ZodNullable<z.ZodString>;
+                            size: z.ZodNumber;
+                            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                            createdAt: z.ZodDate;
+                            dimensions: z.ZodNullable<z.ZodObject<{
+                                width: z.ZodNumber;
+                                height: z.ZodNumber;
+                            }, z.core.$strip>>;
+                            url: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>>;
+                        pageInfo: z.ZodObject<{
+                            totalCount: z.ZodNumber;
+                            count: z.ZodNumber;
+                            hasNextPage: z.ZodBoolean;
+                            hasPreviousPage: z.ZodBoolean;
+                            startCursor: z.ZodNullable<z.ZodString>;
+                            endCursor: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=list.route.d.ts.map

package/dist/src/api/modules/users/files/routes/list.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.route.d.ts","sourceRoot":"","sources":["../../../../../../../src/api/modules/users/files/routes/list.route.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAC;AAYpB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgG7B,CAAC"}

package/dist/src/api/modules/users/files/routes/list.route.js

@@ -0,0 +1 @@
+import{eq}from"drizzle-orm";import{HTTPException}from"hono/http-exception";import z from"zod";import{buildRoute}from"../../../../lib/route.js";import{withPagination,zodPaginationPageInfo,zodPaginationQuery}from"../../../../lib/with-pagination.js";import{CONFIG_PLUGIN}from"../../../../../config.js";import{core_files}from"../../../../../database/files.js";import{parseImageDimensions}from"../../../../../lib/api/upload.js";export const listUserFilesRoute=buildRoute({pluginId:CONFIG_PLUGIN.pluginId,route:{method:"get",description:"List files uploaded by the current user.",path:"/",request:{query:zodPaginationQuery.extend({order:z.enum(["asc","desc"]).optional(),orderBy:z.enum(["name","size","createdAt"]).optional(),search:z.string().optional()})},responses:{200:{content:{"application/json":{schema:z.object({edges:z.array(z.object({id:z.number(),name:z.string(),folder:z.string(),mimeType:z.string().nullable(),size:z.number(),metadata:z.record(z.string(),z.unknown()),createdAt:z.date(),dimensions:z.object({width:z.number(),height:z.number()}).nullable(),url:z.string().nullable()})),pageInfo:zodPaginationPageInfo})}},description:"List of the current user's files"},401:{description:"Not signed in"}}},handler:async c=>{const user=c.get("user");if(!user){throw new HTTPException(401,{message:"Unauthorized"})}const query=c.req.valid("query");const hasAdapter=!!c.get("core").storage?.adapter;const storage=c.get("storage");const data=await withPagination({params:{query},c,primaryCursor:core_files.id,search:[core_files.name],where:eq(core_files.userId,user.id),query:async({cursorSelection,limit,where,orderBy})=>await c.get("db").select({...cursorSelection,id:core_files.id,name:core_files.name,key:core_files.key,folder:core_files.folder,mimeType:core_files.mimeType,size:core_files.size,metadata:core_files.metadata,createdAt:core_files.createdAt}).from(core_files).where(where).orderBy(orderBy).limit(limit),table:core_files,orderBy:{column:query.orderBy?core_files[query.orderBy]:core_files.createdAt,order:query.order??"desc"}});return c.json({...data,edges:data.edges.map(({key,...file})=>({...file,url:hasAdapter?storage.getUrl(key):null,dimensions:parseImageDimensions(file.metadata)}))})}});

package/dist/src/api/modules/users/routes/change-password.route.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const zodChangePasswordSchema: z.ZodObject<{
+    password: z.ZodString;
+    userId: z.ZodNumber;
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare const changePasswordRoute: import("../../../../api/lib/route").Route<"@vitnode/core", {
+    method: "post";
+    description: string;
+    path: "/change-password";
+    request: {
+        body: {
+            required: true;
+            content: {
+                "application/json": {
+                    schema: z.ZodObject<{
+                        password: z.ZodString;
+                        userId: z.ZodNumber;
+                        token: z.ZodString;
+                    }, z.core.$strip>;
+                };
+            };
+        };
+    };
+    responses: {
+        201: {
+            description: string;
+        };
+        400: {
+            description: string;
+        };
+    };
+} & {
+    path: string;
+}>;
+//# sourceMappingURL=change-password.route.d.ts.map

package/dist/src/api/modules/users/routes/change-password.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-password.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/change-password.route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,uBAAuB;;;;iBAMlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkE9B,CAAC"}