@vitnode/core 1.2.0-canary.10

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

@@ -0,0 +1,439 @@
+export declare const usersModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "users", [{
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/session", {}>) => Promise<Response & import("hono").TypedResponse<{
+        user: {
+            isAdmin: boolean;
+            avatarColor: string;
+            birthday: string | null;
+            createdAt: string;
+            email: string;
+            emailVerified: boolean;
+            id: number;
+            name: string;
+            nameCode: string;
+            newsletter: boolean;
+            roleId: number;
+        } | null;
+    }, 200, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "get";
+        description: string;
+        path: "/session";
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            user: import("zod").ZodNullable<import("zod").ZodObject<{
+                                id: import("zod").ZodNumber;
+                                email: import("zod").ZodString;
+                                name: import("zod").ZodString;
+                                nameCode: import("zod").ZodString;
+                                createdAt: import("zod").ZodDate;
+                                newsletter: import("zod").ZodBoolean;
+                                avatarColor: import("zod").ZodString;
+                                emailVerified: import("zod").ZodBoolean;
+                                roleId: import("zod").ZodNumber;
+                                birthday: import("zod").ZodNullable<import("zod").ZodDate>;
+                                isAdmin: import("zod").ZodBoolean;
+                            }, "strip", import("zod").ZodTypeAny, {
+                                id: number;
+                                name: string;
+                                nameCode: string;
+                                email: string;
+                                createdAt: Date;
+                                newsletter: boolean;
+                                avatarColor: string;
+                                emailVerified: boolean;
+                                roleId: number;
+                                birthday: Date | null;
+                                isAdmin: boolean;
+                            }, {
+                                id: number;
+                                name: string;
+                                nameCode: string;
+                                email: string;
+                                createdAt: Date;
+                                newsletter: boolean;
+                                avatarColor: string;
+                                emailVerified: boolean;
+                                roleId: number;
+                                birthday: Date | null;
+                                isAdmin: boolean;
+                            }>>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            user: {
+                                id: number;
+                                name: string;
+                                nameCode: string;
+                                email: string;
+                                createdAt: Date;
+                                newsletter: boolean;
+                                avatarColor: string;
+                                emailVerified: boolean;
+                                roleId: number;
+                                birthday: Date | null;
+                                isAdmin: boolean;
+                            } | null;
+                        }, {
+                            user: {
+                                id: number;
+                                name: string;
+                                nameCode: string;
+                                email: string;
+                                createdAt: Date;
+                                newsletter: boolean;
+                                avatarColor: string;
+                                emailVerified: boolean;
+                                roleId: number;
+                                birthday: Date | null;
+                                isAdmin: boolean;
+                            } | null;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/session";
+    };
+}, {
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/sign_in", {
+        in: {
+            json: {
+                email: string;
+                password: string;
+                isAdmin?: boolean | undefined;
+            };
+        };
+        out: {
+            json: {
+                email: string;
+                password: string;
+                isAdmin?: boolean | undefined;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        id: number;
+        token: string;
+    }, 201, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/sign_in";
+        request: {
+            body: {
+                required: true;
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            password: import("zod").ZodString;
+                            isAdmin: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            email: string;
+                            password: string;
+                            isAdmin?: boolean | undefined;
+                        }, {
+                            email: string;
+                            password: string;
+                            isAdmin?: boolean | undefined;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            403: {
+                description: string;
+            };
+            201: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            token: import("zod").ZodString;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            id: number;
+                            token: string;
+                        }, {
+                            id: number;
+                            token: string;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/sign_in";
+    };
+}, {
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/sign_out", {
+        in: {
+            json: {
+                isAdmin?: boolean | undefined;
+            };
+        };
+        out: {
+            json: {
+                isAdmin?: boolean | undefined;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{}, 200 | 403, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "delete";
+        description: string;
+        path: "/sign_out";
+        request: {
+            body: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            isAdmin: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            isAdmin?: boolean | undefined;
+                        }, {
+                            isAdmin?: boolean | undefined;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            200: {
+                description: string;
+            };
+            403: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/sign_out";
+    };
+}, {
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/sign_up", {
+        in: {
+            json: {
+                name: string;
+                email: string;
+                password: string;
+                newsletter?: boolean | undefined;
+            };
+        };
+        out: {
+            json: {
+                name: string;
+                email: string;
+                password: string;
+                newsletter?: boolean | undefined;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        id: number;
+    }, 200, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/sign_up";
+        request: {
+            body: {
+                required: true;
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            email: import("zod").ZodString;
+                            name: import("zod").ZodEffects<import("zod").ZodString, string, string>;
+                            password: import("zod").ZodString;
+                            newsletter: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            name: string;
+                            email: string;
+                            password: string;
+                            newsletter?: boolean | undefined;
+                        }, {
+                            name: string;
+                            email: string;
+                            password: string;
+                            newsletter?: boolean | undefined;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            id: number;
+                        }, {
+                            id: number;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/sign_up";
+    };
+}, {
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/test", {}>) => Response & import("hono").TypedResponse<"test", 200 | 201, "text">;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "get";
+        description: string;
+        path: "/test";
+        responses: {
+            200: {
+                content: {
+                    'text/plain': {
+                        schema: import("zod").ZodString;
+                    };
+                };
+                description: string;
+            };
+            201: {
+                content: {
+                    'text/plain': {
+                        schema: import("zod").ZodString;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/test";
+    };
+}], import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "sso", [{
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/:providerId/callback", {
+        in: {
+            param: {
+                providerId: string;
+            };
+        };
+        out: {
+            param: {
+                providerId: string;
+            };
+        };
+    } & {
+        in: {
+            query: {
+                code: string;
+                state: string;
+            };
+        };
+        out: {
+            query: {
+                code: string;
+                state: string;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        id: number;
+        token: string;
+    }, 200, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "get";
+        description: string;
+        path: "/{providerId}/callback";
+        request: {
+            params: import("zod").ZodObject<{
+                providerId: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                providerId: string;
+            }, {
+                providerId: string;
+            }>;
+            query: import("zod").ZodObject<{
+                code: import("zod").ZodString;
+                state: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                code: string;
+                state: string;
+            }, {
+                code: string;
+                state: string;
+            }>;
+        };
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            id: import("zod").ZodNumber;
+                            token: import("zod").ZodString;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            id: number;
+                            token: string;
+                        }, {
+                            id: number;
+                            token: string;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:providerId/callback";
+    };
+}, {
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/:providerId", {
+        in: {
+            param: {
+                providerId: string;
+            };
+        };
+        out: {
+            param: {
+                providerId: string;
+            };
+        };
+    }>) => Promise<Response & import("hono").TypedResponse<{
+        url: string;
+    }, 200, "json">>;
+    pluginId: "@vitnode/core";
+    route: {
+        method: "post";
+        description: string;
+        path: "/{providerId}";
+        request: {
+            params: import("zod").ZodObject<{
+                providerId: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                providerId: string;
+            }, {
+                providerId: string;
+            }>;
+        };
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: import("zod").ZodObject<{
+                            url: import("zod").ZodString;
+                        }, "strip", import("zod").ZodTypeAny, {
+                            url: string;
+                        }, {
+                            url: string;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/:providerId";
+    };
+}], import("../../../api/lib/module").BaseBuildModuleReturn<"@vitnode/core", string, import("../../lib/route").Route<"@vitnode/core", import("@hono/zod-openapi").RouteConfig, import("@hono/zod-openapi").RouteHandler<import("@hono/zod-openapi").RouteConfig>>[]>[]>[]>;
+//# sourceMappingURL=users.module.d.ts.map

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

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

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

@@ -0,0 +1,22 @@
+import { buildModule } from "../../lib/module";
+import { CONFIG_PLUGIN } from "../../../config";
+import { sessionRoute } from "./routes/session.route";
+import { signInRoute } from "./routes/sign-in.route";
+import { signOutRoute } from "./routes/sign-out.route";
+import { signUpRoute } from "./routes/sign-up.route";
+import { testRoute } from "./routes/test.route";
+import { ssoUserModule } from "./sso/sso.module";
+export const usersModule = buildModule({
+    ...CONFIG_PLUGIN,
+    name: 'users',
+    routes: [
+        sessionRoute,
+        signInRoute,
+        signOutRoute,
+        signUpRoute,
+        testRoute
+    ],
+    modules: [
+        ssoUserModule
+    ]
+});

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

@@ -0,0 +1,2 @@
+export declare const newBuildPluginApiCore: import("./lib/plugin").BuildPluginApiReturn;
+//# sourceMappingURL=plugin.d.ts.map

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

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

package/dist/src/api/plugin.js

@@ -0,0 +1,13 @@
+import { CONFIG_PLUGIN } from "../config";
+import { buildApiPlugin } from "./lib/plugin";
+import { adminModule } from "./modules/admin/admin.module";
+import { middlewareModule } from "./modules/middleware/middleware.module";
+import { usersModule } from "./modules/users/users.module";
+export const newBuildPluginApiCore = buildApiPlugin({
+    ...CONFIG_PLUGIN,
+    modules: [
+        middlewareModule,
+        usersModule,
+        adminModule
+    ]
+});

package/dist/src/api/plugins/email/nodemailer.d.ts

@@ -0,0 +1,10 @@
+import type { EmailApiPlugin } from '../../../api/models/email';
+export declare const NodemailerEmailPlugin: ({ host, port, secure, user, password, from, }: {
+    from: string | undefined;
+    host: string | undefined;
+    password: string | undefined;
+    port?: number;
+    secure?: boolean;
+    user: string | undefined;
+}) => EmailApiPlugin;
+//# sourceMappingURL=nodemailer.d.ts.map

package/dist/src/api/plugins/email/nodemailer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodemailer.d.ts","sourceRoot":"","sources":["../../../../../src/api/plugins/email/nodemailer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,eAAO,MAAM,qBAAqB,GAAI,+CAOnC;IACD,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,KAAG,cAiCH,CAAC"}

package/dist/src/api/plugins/email/nodemailer.js

@@ -0,0 +1,30 @@
+import { createTransport } from "nodemailer";
+export const NodemailerEmailPlugin = ({ host = '', port = 587, secure = false, user = '', password = '', from = '' })=>{
+    return {
+        sendEmail: async ({ metadata, to, subject, html, replyTo })=>{
+            if (!host || !user || !password || !from) {
+                throw new Error('Missing nodemailer configuration');
+            }
+            const transporter = createTransport({
+                host,
+                port,
+                secure,
+                auth: {
+                    user,
+                    pass: password
+                }
+            }, {
+                from: {
+                    name: metadata.shortTitle ?? metadata.title,
+                    address: from
+                },
+                replyTo
+            });
+            await transporter.sendMail({
+                to,
+                subject,
+                html
+            });
+        }
+    };
+};

package/dist/src/api/plugins/email/resend.d.ts

@@ -0,0 +1,6 @@
+import type { EmailApiPlugin } from '../../../api/models/email';
+export declare const ResendEmailPlugin: ({ apiKey, from, }: {
+    apiKey: string | undefined;
+    from: string | undefined;
+}) => EmailApiPlugin;
+//# sourceMappingURL=resend.d.ts.map

package/dist/src/api/plugins/email/resend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resend.d.ts","sourceRoot":"","sources":["../../../../../src/api/plugins/email/resend.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,eAAO,MAAM,iBAAiB,GAAI,mBAG/B;IACD,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,KAAG,cAqBH,CAAC"}

package/dist/src/api/plugins/email/resend.js

@@ -0,0 +1,21 @@
+import { Resend } from "resend";
+export const ResendEmailPlugin = ({ apiKey, from })=>{
+    return {
+        sendEmail: async ({ to, subject, replyTo, metadata, html })=>{
+            if (!apiKey || !from) {
+                throw new Error('Missing Resend configuration');
+            }
+            const resend = new Resend(apiKey);
+            const { error } = await resend.emails.send({
+                from: `${metadata.shortTitle ?? metadata.title} <${from}>`,
+                to,
+                subject,
+                replyTo,
+                html
+            });
+            if (error) {
+                throw new Error(`[${error.name}]: ${error.message}`);
+            }
+        }
+    };
+};

package/dist/src/api/plugins/sso/discord.d.ts

@@ -0,0 +1,6 @@
+import type { SSOApiPlugin } from '../../../api/models/sso';
+export declare const DiscordSSOApiPlugin: ({ clientId, clientSecret, }: {
+    clientId: string | undefined;
+    clientSecret: string | undefined;
+}) => SSOApiPlugin;
+//# sourceMappingURL=discord.d.ts.map

package/dist/src/api/plugins/sso/discord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord.d.ts","sourceRoot":"","sources":["../../../../../src/api/plugins/sso/discord.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIrD,eAAO,MAAM,mBAAmB,GAAI,6BAGjC;IACD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC,KAAG,YAoFH,CAAC"}

package/dist/src/api/plugins/sso/discord.js

@@ -0,0 +1,77 @@
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { getRedirectUri } from "../../models/sso";
+export const DiscordSSOApiPlugin = ({ clientId = '', clientSecret = '' })=>{
+    const id = 'discord';
+    const redirectUri = getRedirectUri(id);
+    const userSchema = z.object({
+        id: z.string(),
+        email: z.string(),
+        username: z.string()
+    });
+    const tokenSchema = z.object({
+        access_token: z.string(),
+        token_type: z.string()
+    });
+    return {
+        fetchToken: async (code)=>{
+            if (!clientId || !clientSecret) {
+                throw new Error('Missing Discord client ID or secret');
+            }
+            const res = await fetch('https://discord.com/api/oauth2/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json'
+                },
+                body: new URLSearchParams({
+                    code,
+                    redirect_uri: redirectUri,
+                    grant_type: 'authorization_code',
+                    client_id: clientId,
+                    client_secret: clientSecret
+                })
+            });
+            if (!res.ok) {
+                throw new HTTPException(+res.status.toString(), {
+                    message: 'Internal error requesting token'
+                });
+            }
+            const { data, error } = tokenSchema.safeParse(await res.json());
+            if (error || !data) {
+                throw new HTTPException(400, {
+                    message: 'Invalid token response'
+                });
+            }
+            return data;
+        },
+        fetchUser: async ({ token_type, access_token })=>{
+            const res = await fetch('https://discord.com/api/users/@me', {
+                headers: {
+                    Authorization: `${token_type} ${access_token}`
+                }
+            });
+            const { data, error } = userSchema.safeParse(await res.json());
+            if (error || !data) {
+                throw new HTTPException(400, {
+                    message: 'Invalid user response'
+                });
+            }
+            return data;
+        },
+        getUrl: ({ state })=>{
+            if (!clientId) {
+                throw new Error('Missing Discord client ID');
+            }
+            const url = new URL('https://discord.com/oauth2/authorize');
+            url.searchParams.set('client_id', clientId);
+            url.searchParams.set('redirect_uri', redirectUri);
+            url.searchParams.set('response_type', 'code');
+            url.searchParams.set('scope', 'identify email');
+            url.searchParams.set('state', state);
+            return url.toString();
+        },
+        id,
+        name: 'Discord'
+    };
+};

package/dist/src/api/plugins/sso/facebook.d.ts

@@ -0,0 +1,6 @@
+import type { SSOApiPlugin } from '../../../api/models/sso';
+export declare const FacebookSSOApiPlugin: ({ clientId, clientSecret, }: {
+    clientId: string | undefined;
+    clientSecret: string | undefined;
+}) => SSOApiPlugin;
+//# sourceMappingURL=facebook.d.ts.map

package/dist/src/api/plugins/sso/facebook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facebook.d.ts","sourceRoot":"","sources":["../../../../../src/api/plugins/sso/facebook.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIrD,eAAO,MAAM,oBAAoB,GAAI,6BAGlC;IACD,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC,KAAG,YAwFH,CAAC"}