@vitnode/core 1.2.0-canary.10 → 1.2.0-canary.11

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

@@ -1,189 +0,0 @@
-export declare const usersAdminModule: import("../../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "users", [{
-    handler: (c: import("hono").Context<import("../../../middlewares/global/global").EnvVitNode, "/list", {
-        in: {
-            query: {
-                orderBy?: "name" | "createdAt" | undefined;
-                cursor?: string | undefined;
-                order?: "asc" | "desc" | undefined;
-                first?: string | undefined;
-                last?: string | undefined;
-            };
-        };
-        out: {
-            query: {
-                orderBy?: "name" | "createdAt" | undefined;
-                cursor?: string | undefined;
-                order?: "asc" | "desc" | undefined;
-                first?: string | undefined;
-                last?: string | undefined;
-            };
-        };
-    }>) => Promise<Response & import("hono").TypedResponse<{
-        edges: {
-            id: number;
-            name: string;
-            email: string;
-            nameCode: string;
-            createdAt: string;
-            newsletter: boolean;
-            avatarColor: string;
-            emailVerified: boolean;
-            roleId: number;
-            birthday: string | null;
-            language: string;
-        }[];
-        pageInfo: {
-            count: number;
-            endCursor: null | number;
-            hasNextPage: boolean;
-            hasPreviousPage: boolean;
-            startCursor: null | number;
-            totalCount: number;
-        };
-    }, 200, "json">>;
-    pluginId: "@vitnode/core";
-    route: {
-        method: "get";
-        description: string;
-        path: "/list";
-        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", "desc"]>>;
-                orderBy: import("zod").ZodOptional<import("zod").ZodEnum<["name", "createdAt"]>>;
-            }, "strip", import("zod").ZodTypeAny, {
-                orderBy?: "name" | "createdAt" | undefined;
-                cursor?: string | undefined;
-                order?: "asc" | "desc" | undefined;
-                first?: string | undefined;
-                last?: string | undefined;
-            }, {
-                orderBy?: "name" | "createdAt" | undefined;
-                cursor?: string | undefined;
-                order?: "asc" | "desc" | undefined;
-                first?: string | undefined;
-                last?: string | undefined;
-            }>;
-        };
-        responses: {
-            200: {
-                content: {
-                    'application/json': {
-                        schema: import("zod").ZodObject<{
-                            edges: import("zod").ZodArray<import("zod").ZodObject<{
-                                id: import("zod").ZodNumber;
-                                name: import("zod").ZodString;
-                                email: 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>;
-                                language: import("zod").ZodString;
-                            }, "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;
-                                language: string;
-                            }, {
-                                id: number;
-                                name: string;
-                                nameCode: string;
-                                email: string;
-                                createdAt: Date;
-                                newsletter: boolean;
-                                avatarColor: string;
-                                emailVerified: boolean;
-                                roleId: number;
-                                birthday: Date | null;
-                                language: string;
-                            }>, "many">;
-                            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>;
-                            }, "strip", import("zod").ZodTypeAny, {
-                                count: number;
-                                totalCount: number;
-                                hasNextPage: boolean;
-                                hasPreviousPage: boolean;
-                                startCursor: number | null;
-                                endCursor: number | null;
-                            }, {
-                                count: number;
-                                totalCount: number;
-                                hasNextPage: boolean;
-                                hasPreviousPage: boolean;
-                                startCursor: number | null;
-                                endCursor: number | null;
-                            }>;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            edges: {
-                                id: number;
-                                name: string;
-                                nameCode: string;
-                                email: string;
-                                createdAt: Date;
-                                newsletter: boolean;
-                                avatarColor: string;
-                                emailVerified: boolean;
-                                roleId: number;
-                                birthday: Date | null;
-                                language: string;
-                            }[];
-                            pageInfo: {
-                                count: number;
-                                totalCount: number;
-                                hasNextPage: boolean;
-                                hasPreviousPage: boolean;
-                                startCursor: number | null;
-                                endCursor: number | null;
-                            };
-                        }, {
-                            edges: {
-                                id: number;
-                                name: string;
-                                nameCode: string;
-                                email: string;
-                                createdAt: Date;
-                                newsletter: boolean;
-                                avatarColor: string;
-                                emailVerified: boolean;
-                                roleId: number;
-                                birthday: Date | null;
-                                language: string;
-                            }[];
-                            pageInfo: {
-                                count: number;
-                                totalCount: number;
-                                hasNextPage: boolean;
-                                hasPreviousPage: boolean;
-                                startCursor: number | null;
-                                endCursor: number | null;
-                            };
-                        }>;
-                    };
-                };
-                description: string;
-            };
-        };
-    } & {
-        getRoutingPath: () => "/list";
-    };
-}], 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.admin.module.d.ts.map

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

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

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

@@ -1,10 +0,0 @@
-import { buildModule } from "../../../lib/module";
-import { CONFIG_PLUGIN } from "../../../../config";
-import { listUsersAdminRoute } from "./routes/list.route";
-export const usersAdminModule = buildModule({
-    ...CONFIG_PLUGIN,
-    name: 'users',
-    routes: [
-        listUsersAdminRoute
-    ]
-});

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

@@ -1,52 +0,0 @@
-export declare const middlewareModule: import("../../../api/lib/module").BuildModuleReturn<"@vitnode/core", "middleware", [{
-    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: import("zod").ZodObject<{
-                            sso: import("zod").ZodArray<import("zod").ZodObject<{
-                                id: import("zod").ZodString;
-                                name: import("zod").ZodString;
-                            }, "strip", import("zod").ZodTypeAny, {
-                                id: string;
-                                name: string;
-                            }, {
-                                id: string;
-                                name: string;
-                            }>, "many">;
-                            isEmail: import("zod").ZodBoolean;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            sso: {
-                                id: string;
-                                name: string;
-                            }[];
-                            isEmail: boolean;
-                        }, {
-                            sso: {
-                                id: string;
-                                name: string;
-                            }[];
-                            isEmail: boolean;
-                        }>;
-                    };
-                };
-                description: string;
-            };
-        };
-    } & {
-        getRoutingPath: () => "/";
-    };
-}], 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=middleware.module.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"middleware.module.d.ts","sourceRoot":"","sources":["../../../../../src/api/modules/middleware/middleware.module.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gQAI3B,CAAC"}

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

@@ -1,10 +0,0 @@
-import { buildModule } from "../../lib/module";
-import { CONFIG_PLUGIN } from "../../../config";
-import { routeMiddleware } from "./route";
-export const middlewareModule = buildModule({
-    ...CONFIG_PLUGIN,
-    name: 'middleware',
-    routes: [
-        routeMiddleware
-    ]
-});

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

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

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

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

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

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

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

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

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

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