@vitnode/core 1.2.0-canary.10

package/dist/src/api/modules/middleware/route.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const routeMiddleware: {
+    handler: (c: import("hono").Context<import("../../middlewares/global/global").EnvVitNode, "/", {}>) => Response & import("hono").TypedResponse<{
+        isEmail: boolean;
+        sso: {
+            id: string;
+            name: string;
+        }[];
+    }, 200, "json">;
+    pluginId: "@vitnode/core";
+    route: {
+        path: "/";
+        method: "get";
+        description: string;
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            sso: z.ZodArray<z.ZodObject<{
+                                id: z.ZodString;
+                                name: z.ZodString;
+                            }, "strip", z.ZodTypeAny, {
+                                id: string;
+                                name: string;
+                            }, {
+                                id: string;
+                                name: string;
+                            }>, "many">;
+                            isEmail: z.ZodBoolean;
+                        }, "strip", z.ZodTypeAny, {
+                            sso: {
+                                id: string;
+                                name: string;
+                            }[];
+                            isEmail: boolean;
+                        }, {
+                            sso: {
+                                id: string;
+                                name: string;
+                            }[];
+                            isEmail: boolean;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/";
+    };
+};
+//# sourceMappingURL=route.d.ts.map

package/dist/src/api/modules/middleware/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/middleware/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B1B,CAAC"}

package/dist/src/api/modules/middleware/route.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { buildRoute } from "../../lib/route";
+import { EmailModel } from "../../models/email";
+import { CONFIG_PLUGIN } from "../../../config";
+export const routeMiddleware = buildRoute({
+    ...CONFIG_PLUGIN,
+    route: {
+        path: '/',
+        method: 'get',
+        description: 'Middleware route with user authentication',
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            sso: z.array(z.object({
+                                id: z.string(),
+                                name: z.string()
+                            })),
+                            isEmail: z.boolean()
+                        })
+                    }
+                },
+                description: 'Middleware route'
+            }
+        }
+    },
+    handler: (c)=>{
+        const sso = c.get('core').authorization.ssoPlugins;
+        const email = new EmailModel(c);
+        return c.json({
+            isEmail: email.isAvailable(),
+            sso: sso.map((s)=>({
+                    id: s.id,
+                    name: s.name
+                }))
+        });
+    }
+});

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,43 @@
+import { convertColor } from "../../../lib/colors";
+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/routes/session.route.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+export declare const sessionRoute: {
+    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: z.ZodObject<{
+                            user: z.ZodNullable<z.ZodObject<{
+                                id: z.ZodNumber;
+                                email: z.ZodString;
+                                name: z.ZodString;
+                                nameCode: z.ZodString;
+                                createdAt: z.ZodDate;
+                                newsletter: z.ZodBoolean;
+                                avatarColor: z.ZodString;
+                                emailVerified: z.ZodBoolean;
+                                roleId: z.ZodNumber;
+                                birthday: z.ZodNullable<z.ZodDate>;
+                                isAdmin: z.ZodBoolean;
+                            }, "strip", z.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", z.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";
+    };
+};
+//# sourceMappingURL=session.route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/session.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}

package/dist/src/api/modules/users/routes/session.route.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { buildRoute } from "../../../lib/route";
+import { SessionAdminModel } from "../../../models/session-admin";
+import { CONFIG_PLUGIN } from "../../../../config";
+export const sessionRoute = buildRoute({
+    ...CONFIG_PLUGIN,
+    route: {
+        method: 'get',
+        description: 'Verify session',
+        path: '/session',
+        responses: {
+            200: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            user: z.object({
+                                id: z.number(),
+                                email: z.string(),
+                                name: z.string(),
+                                nameCode: z.string(),
+                                createdAt: z.date(),
+                                newsletter: z.boolean(),
+                                avatarColor: z.string(),
+                                emailVerified: z.boolean(),
+                                roleId: z.number(),
+                                birthday: z.date().nullable(),
+                                isAdmin: z.boolean()
+                            }).nullable()
+                        })
+                    }
+                },
+                description: 'User'
+            }
+        }
+    },
+    handler: async (c)=>{
+        const user = c.get('user');
+        const admin = new SessionAdminModel(c);
+        return c.json({
+            user: user ? {
+                ...user,
+                isAdmin: await admin.checkIfUserIsAdmin(user.id)
+            } : null
+        });
+    }
+});

package/dist/src/api/modules/users/routes/sign-in.route.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const zodSignInSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    isAdmin: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    isAdmin?: boolean | undefined;
+}, {
+    email: string;
+    password: string;
+    isAdmin?: boolean | undefined;
+}>;
+export declare const signInRoute: {
+    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: z.ZodObject<{
+                            email: z.ZodString;
+                            password: z.ZodString;
+                            isAdmin: z.ZodOptional<z.ZodBoolean>;
+                        }, "strip", z.ZodTypeAny, {
+                            email: string;
+                            password: string;
+                            isAdmin?: boolean | undefined;
+                        }, {
+                            email: string;
+                            password: string;
+                            isAdmin?: boolean | undefined;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            403: {
+                description: string;
+            };
+            201: {
+                content: {
+                    'application/json': {
+                        schema: z.ZodObject<{
+                            id: z.ZodNumber;
+                            token: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            id: number;
+                            token: string;
+                        }, {
+                            id: number;
+                            token: string;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/sign_in";
+    };
+};
+//# sourceMappingURL=sign-in.route.d.ts.map

package/dist/src/api/modules/users/routes/sign-in.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-in.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/sign-in.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,eAAe;;;;;;;;;;;;EAU1B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDtB,CAAC"}

package/dist/src/api/modules/users/routes/sign-in.route.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { buildRoute } from "../../../lib/route";
+import { SessionModel } from "../../../models/session";
+import { SessionAdminModel } from "../../../models/session-admin";
+import { UserModel } from "../../../models/user";
+import { CONFIG_PLUGIN } from "../../../../config";
+export const zodSignInSchema = z.object({
+    email: z.string().email().toLowerCase().openapi({
+        example: 'test@test.com'
+    }),
+    password: z.string().openapi({
+        example: 'Test123!'
+    }),
+    isAdmin: z.boolean().optional().openapi({
+        example: false
+    })
+});
+export const signInRoute = buildRoute({
+    ...CONFIG_PLUGIN,
+    route: {
+        method: 'post',
+        description: 'Sign in with email and password',
+        path: '/sign_in',
+        request: {
+            body: {
+                required: true,
+                content: {
+                    'application/json': {
+                        schema: zodSignInSchema
+                    }
+                }
+            }
+        },
+        responses: {
+            403: {
+                description: 'Access Denied'
+            },
+            201: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            id: z.number(),
+                            token: z.string()
+                        })
+                    }
+                },
+                description: 'User signed in'
+            }
+        }
+    },
+    handler: async (c)=>{
+        const { password, isAdmin, email } = c.req.valid('json');
+        const data = await new UserModel().signInWithPassword({
+            password,
+            email,
+            c
+        });
+        if (isAdmin) {
+            const { token } = await new SessionAdminModel(c).createSessionByUserId(data.id);
+            return c.json({
+                id: data.id,
+                token
+            }, 201);
+        }
+        const { token } = await new SessionModel(c).createSessionByUserId(data.id);
+        return c.json({
+            id: data.id,
+            token
+        }, 201);
+    }
+});

package/dist/src/api/modules/users/routes/sign-out.route.d.ts

@@ -0,0 +1,47 @@
+import { z } from '@hono/zod-openapi';
+export declare const signOutRoute: {
+    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: z.ZodObject<{
+                            isAdmin: z.ZodOptional<z.ZodBoolean>;
+                        }, "strip", z.ZodTypeAny, {
+                            isAdmin?: boolean | undefined;
+                        }, {
+                            isAdmin?: boolean | undefined;
+                        }>;
+                    };
+                };
+            };
+        };
+        responses: {
+            200: {
+                description: string;
+            };
+            403: {
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/sign_out";
+    };
+};
+//# sourceMappingURL=sign-out.route.d.ts.map

package/dist/src/api/modules/users/routes/sign-out.route.d.ts.map

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

package/dist/src/api/modules/users/routes/sign-out.route.js

@@ -0,0 +1,43 @@
+import { z } from "@hono/zod-openapi";
+import { buildRoute } from "../../../lib/route";
+import { SessionModel } from "../../../models/session";
+import { SessionAdminModel } from "../../../models/session-admin";
+import { CONFIG_PLUGIN } from "../../../../config";
+export const signOutRoute = buildRoute({
+    ...CONFIG_PLUGIN,
+    route: {
+        method: 'delete',
+        description: 'Sign out the current admin',
+        path: '/sign_out',
+        request: {
+            body: {
+                content: {
+                    'application/json': {
+                        schema: z.object({
+                            isAdmin: z.boolean().optional().openapi({
+                                example: false
+                            })
+                        })
+                    }
+                }
+            }
+        },
+        responses: {
+            200: {
+                description: 'User signed out'
+            },
+            403: {
+                description: 'Access Denied'
+            }
+        }
+    },
+    handler: async (c)=>{
+        const { isAdmin } = c.req.valid('json');
+        if (isAdmin) {
+            await new SessionAdminModel(c).deleteSession();
+            return c.json({});
+        }
+        await new SessionModel(c).deleteSession();
+        return c.json({});
+    }
+});

package/dist/src/api/modules/users/routes/sign-up.route.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export declare const zodSignUpSchema: z.ZodObject<{
+    email: z.ZodString;
+    name: z.ZodEffects<z.ZodString, string, string>;
+    password: z.ZodString;
+    newsletter: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    email: string;
+    password: string;
+    newsletter?: boolean | undefined;
+}, {
+    name: string;
+    email: string;
+    password: string;
+    newsletter?: boolean | undefined;
+}>;
+export declare const signUpRoute: {
+    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: z.ZodObject<{
+                            email: z.ZodString;
+                            name: z.ZodEffects<z.ZodString, string, string>;
+                            password: z.ZodString;
+                            newsletter: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                        }, "strip", z.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: z.ZodObject<{
+                            id: z.ZodNumber;
+                        }, "strip", z.ZodTypeAny, {
+                            id: number;
+                        }, {
+                            id: number;
+                        }>;
+                    };
+                };
+                description: string;
+            };
+        };
+    } & {
+        getRoutingPath: () => "/sign_up";
+    };
+};
+//# sourceMappingURL=sign-up.route.d.ts.map

package/dist/src/api/modules/users/routes/sign-up.route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-up.route.d.ts","sourceRoot":"","sources":["../../../../../../src/api/modules/users/routes/sign-up.route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;EAe1B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCtB,CAAC"}