@vitnode/core 1.2.0-canary.76 → 1.2.0-canary.78

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":"AAIA,eAAO,MAAM,sBAAsB,gDA+BjC,CAAC"}

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

@@ -0,0 +1 @@
+import{buildQueueTask}from"../../../lib/queue.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);await search.clear(itemType);for(const indexer of indexers){for(let page=0;;page++){const docs=await indexer.load(c,page*PAGE_SIZE,PAGE_SIZE);if(docs.length===0)break;await search.bulkIndex(docs)}}}});

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

@@ -1,5 +1,2 @@
-//#region src/api/modules/users/avatar-color.d.ts
-declare const generateAvatarColor: (name: string) => string;
-//#endregion
-export { generateAvatarColor };
+export declare const generateAvatarColor: (name: string) => string;
 //# sourceMappingURL=avatar-color.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"avatar-color.d.ts","names":[],"sources":["../../../../../src/api/modules/users/avatar-color.ts"],"mappings":";cA6Ba,sBAAuB"}
+{"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

@@ -1,2 +1 @@
-import{convertColor as e}from"../../../lib/colors.js";const t=e=>{let t=0;for(let n=0;n<e.length;n++)t=e.charCodeAt(n)+((t<<5)-t);return t=Math.abs(t),t},n=(e,t,n)=>Math.floor(e%(n-t)+t),r=e=>{let r=[0,360],i=[25,60],a=[50,75],o=t(e);return[n(o,r[0],r[1]),n(o,a[0],a[1]),n(o,i[0],i[1])]},i=t=>{let n=r(t);return e.hslToHex({h:n[0],s:n[1],l:n[2]})};export{i as generateAvatarColor};
-//# sourceMappingURL=avatar-color.js.map
+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

@@ -1,129 +1,124 @@
-import { Route } from "../../../lib/route.js";
-import { BaseBuildModuleReturn, BuildModuleReturn } from "../../../lib/module.js";
-//#region src/api/modules/users/files/files.module.d.ts
-declare const userFilesModule: BuildModuleReturn<"@vitnode/core", "files", [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<{
-        asc: "asc";
-        desc: "desc";
-      }>>;
-      orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
-        name: "name";
-        createdAt: "createdAt";
-        size: "size";
-      }>>;
-      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").ZodNumber>;
-              endCursor: import("zod").ZodNullable<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>;
-          }, import("zod/v4/core").$strip>;
-        };
-      };
-      description: string;
-    };
-    401: {
-      description: string;
+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<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+            orderBy: import("zod").ZodOptional<import("zod").ZodEnum<{
+                name: "name";
+                createdAt: "createdAt";
+                size: "size";
+            }>>;
+            search: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
     };
-  };
-} & {
-  path: string;
-}>, 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;
+    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").ZodNumber>;
+                            endCursor: import("zod").ZodNullable<import("zod").ZodNumber>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                };
+            };
+            description: string;
+        };
+        401: {
+            description: string;
         };
-      };
-      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>;
     };
-    404: {
-      content: {
-        "application/json": {
-          schema: import("zod").ZodObject<{
-            error: 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;
         };
-      };
-      description: string;
     };
-  };
 } & {
-  path: string;
-}>, Route<"@vitnode/core", {
-  method: "delete";
-  description: string;
-  path: "/{id}";
-  request: {
-    params: import("zod").ZodObject<{
-      id: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>;
-  };
-  responses: {
-    200: {
-      description: string;
-    };
-    401: {
-      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>;
     };
-    404: {
-      content: {
-        "application/json": {
-          schema: import("zod").ZodObject<{
-            error: import("zod").ZodString;
-          }, 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;
         };
-      };
-      description: string;
     };
-  };
 } & {
-  path: string;
-}>], BaseBuildModuleReturn<"@vitnode/core", string, Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig>[]>[]>;
-//#endregion
-export { userFilesModule };
+    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

@@ -1 +1 @@
-{"version":3,"file":"files.module.d.ts","names":[],"sources":["../../../../../../src/api/modules/users/files/files.module.ts"],"mappings":";;;cAOa,8DAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAe"}
+{"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

@@ -1,2 +1 @@
-import{CONFIG_PLUGIN as e}from"../../../../config.js";import{buildModule as t}from"../../../lib/module.js";import{deleteUserFileRoute as n}from"./routes/delete.route.js";import{downloadUserFileRoute as r}from"./routes/download.route.js";import{listUserFilesRoute as i}from"./routes/list.route.js";const a=t({pluginId:e.pluginId,name:`files`,routes:[i,r,n]});export{a as userFilesModule};
-//# sourceMappingURL=files.module.js.map
+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

@@ -1,36 +1,32 @@
-import { Route } from "../../../../lib/route.js";
 import { z } from "@hono/zod-openapi";
-//#region src/api/modules/users/files/routes/delete.route.d.ts
-declare const deleteUserFileRoute: Route<"@vitnode/core", {
-  method: "delete";
-  description: string;
-  path: "/{id}";
-  request: {
-    params: z.ZodObject<{
-      id: z.ZodString;
-    }, z.core.$strip>;
-  };
-  responses: {
-    200: {
-      description: string;
+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>;
     };
-    401: {
-      description: string;
-    };
-    404: {
-      content: {
-        "application/json": {
-          schema: z.ZodObject<{
-            error: z.ZodString;
-          }, 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;
         };
-      };
-      description: string;
     };
-  };
 } & {
-  path: string;
+    path: string;
 }>;
-//#endregion
-export { deleteUserFileRoute };
 //# sourceMappingURL=delete.route.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"delete.route.d.ts","names":[],"sources":["../../../../../../../src/api/modules/users/files/routes/delete.route.ts"],"mappings":";;;cAMa"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C9B,CAAC"}

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

@@ -1,2 +1 @@
-import{CONFIG_PLUGIN as e}from"../../../../../config.js";import{buildRoute as t}from"../../../../lib/route.js";import{HTTPException as n}from"hono/http-exception";import{z as r}from"@hono/zod-openapi";const i=t({pluginId:e.pluginId,route:{method:`delete`,description:`Delete one of the current user's files.`,path:`/{id}`,request:{params:r.object({id:r.string().openapi({example:`1`})})},responses:{200:{description:`File deleted`},401:{description:`Not signed in`},404:{content:{"application/json":{schema:r.object({error:r.string()})}},description:`File not found`}}},handler:async e=>{let t=e.get(`user`);if(!t)throw new n(401,{message:`Unauthorized`});let{id:r}=e.req.valid(`param`),i=Number(r);return Number.isInteger(i)?(await e.get(`storage`).deleteFile(i,t.id),e.body(null,200)):e.json({error:`File not found`},404)}});export{i as deleteUserFileRoute};
-//# sourceMappingURL=delete.route.js.map
+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"})})},responses:{200:{description:"File deleted"},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)}await c.get("storage").deleteFile(fileId,user.id);return c.body(null,200)}});

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

@@ -1,41 +1,37 @@
-import { Route } from "../../../../lib/route.js";
 import { z } from "@hono/zod-openapi";
-//#region src/api/modules/users/files/routes/download.route.d.ts
-declare const downloadUserFileRoute: 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;
+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>;
     };
-    404: {
-      content: {
-        "application/json": {
-          schema: z.ZodObject<{
-            error: 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;
         };
-      };
-      description: string;
     };
-  };
 } & {
-  path: string;
+    path: string;
 }>;
-//#endregion
-export { downloadUserFileRoute };
 //# sourceMappingURL=download.route.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"download.route.d.ts","names":[],"sources":["../../../../../../../src/api/modules/users/files/routes/download.route.ts"],"mappings":";;;cAQa"}
+{"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

@@ -1,2 +1 @@
-import{CONFIG_PLUGIN as e}from"../../../../../config.js";import{buildRoute as t}from"../../../../lib/route.js";import{core_files as n}from"../../../../../database/files.js";import{HTTPException as r}from"hono/http-exception";import{z as i}from"@hono/zod-openapi";import{and as a,eq as o}from"drizzle-orm";const s=t({pluginId:e.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:i.object({id:i.string().openapi({example:`1`})})},responses:{200:{content:{"application/octet-stream":{schema:i.string().openapi({format:`binary`,type:`string`})}},description:`File contents`},401:{description:`Not signed in`},404:{content:{"application/json":{schema:i.object({error:i.string()})}},description:`File not found`}}},handler:async e=>{let t=e.get(`user`);if(!t)throw new r(401,{message:`Unauthorized`});let{id:i}=e.req.valid(`param`),s=Number(i);if(!Number.isInteger(s))return e.json({error:`File not found`},404);let[c]=await e.get(`db`).select({name:n.name,key:n.key,mimeType:n.mimeType}).from(n).where(a(o(n.id,s),o(n.userId,t.id))).limit(1);if(!c||!e.get(`core`).storage?.adapter)return e.json({error:`File not found`},404);let l=await fetch(e.get(`storage`).getUrl(c.key));if(!l.ok||!l.body)return e.json({error:`File not found`},404);e.header(`Content-Type`,c.mimeType??`application/octet-stream`),e.header(`Content-Disposition`,`attachment; filename*=UTF-8''${encodeURIComponent(c.name)}`);let u=l.headers.get(`content-length`);return u&&e.header(`Content-Length`,u),e.body(l.body,200)}});export{s as downloadUserFileRoute};
-//# sourceMappingURL=download.route.js.map
+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)}});