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

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

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

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

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

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

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

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

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

@@ -1,60 +0,0 @@
-import { z } from "zod";
-import { buildRoute } from "../../../lib/route";
-import { PasswordModel } from "../../../models/password";
-import { UserModel } from "../../../models/user";
-import { CONFIG_PLUGIN } from "../../../../config";
-const nameRegex = /^(?!.* {2})[\p{L}\p{N}._@ -]*$/u;
-export const zodSignUpSchema = z.object({
-    email: z.string().email().toLowerCase().openapi({
-        example: 'test@test.com'
-    }),
-    name: z.string().openapi({
-        example: 'test'
-    }).min(3).refine((val)=>nameRegex.test(val), {
-        message: 'Invalid name'
-    }),
-    password: z.string().min(8).openapi({
-        example: 'Test123!'
-    }),
-    newsletter: z.boolean().default(false).optional()
-});
-export const signUpRoute = buildRoute({
-    ...CONFIG_PLUGIN,
-    route: {
-        method: 'post',
-        description: 'Create a new user',
-        path: '/sign_up',
-        request: {
-            body: {
-                required: true,
-                content: {
-                    'application/json': {
-                        schema: zodSignUpSchema
-                    }
-                }
-            }
-        },
-        responses: {
-            200: {
-                content: {
-                    'application/json': {
-                        schema: z.object({
-                            id: z.number()
-                        })
-                    }
-                },
-                description: 'User created'
-            }
-        }
-    },
-    handler: async (c)=>{
-        const hashedPassword = await new PasswordModel().encryptPassword(c.req.valid('json').password);
-        const data = await new UserModel().signUp({
-            ...c.req.valid('json'),
-            hashedPassword
-        }, c);
-        return c.json({
-            id: data.id
-        });
-    }
-});

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

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-export declare const testRoute: {
-    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: z.ZodString;
-                    };
-                };
-                description: string;
-            };
-            201: {
-                content: {
-                    'text/plain': {
-                        schema: z.ZodString;
-                    };
-                };
-                description: string;
-            };
-        };
-    } & {
-        getRoutingPath: () => "/test";
-    };
-};
-//# sourceMappingURL=test.route.d.ts.map

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

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

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

@@ -1,32 +0,0 @@
-import { z } from "zod";
-import { buildRoute } from "../../../lib/route";
-import { CONFIG_PLUGIN } from "../../../../config";
-export const testRoute = buildRoute({
-    ...CONFIG_PLUGIN,
-    route: {
-        method: 'get',
-        description: 'Test route',
-        path: '/test',
-        responses: {
-            200: {
-                content: {
-                    'text/plain': {
-                        schema: z.string()
-                    }
-                },
-                description: 'User'
-            },
-            201: {
-                content: {
-                    'text/plain': {
-                        schema: z.string()
-                    }
-                },
-                description: 'User'
-            }
-        }
-    },
-    handler: (c)=>{
-        return c.text('test');
-    }
-});

package/dist/src/api/modules/users/sso/routes/callback.route.d.ts

@@ -1,78 +0,0 @@
-import { z } from 'zod';
-export declare const callbackRoute: {
-    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: z.ZodObject<{
-                providerId: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                providerId: string;
-            }, {
-                providerId: string;
-            }>;
-            query: z.ZodObject<{
-                code: z.ZodString;
-                state: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                code: string;
-                state: string;
-            }, {
-                code: string;
-                state: string;
-            }>;
-        };
-        responses: {
-            200: {
-                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: () => "/:providerId/callback";
-    };
-};
-//# sourceMappingURL=callback.route.d.ts.map

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

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

package/dist/src/api/modules/users/sso/routes/callback.route.js

@@ -1,49 +0,0 @@
-import { z } from "zod";
-import { buildRoute } from "../../../../lib/route";
-import { SessionModel } from "../../../../models/session";
-import { SSOModel } from "../../../../models/sso";
-import { CONFIG_PLUGIN } from "../../../../../config";
-export const callbackRoute = buildRoute({
-    ...CONFIG_PLUGIN,
-    route: {
-        method: 'get',
-        description: 'SSO Callback',
-        path: '/{providerId}/callback',
-        request: {
-            params: z.object({
-                providerId: z.string()
-            }),
-            query: z.object({
-                code: z.string(),
-                state: z.string()
-            })
-        },
-        responses: {
-            200: {
-                content: {
-                    'application/json': {
-                        schema: z.object({
-                            id: z.number(),
-                            token: z.string()
-                        })
-                    }
-                },
-                description: 'URL'
-            }
-        }
-    },
-    handler: async (c)=>{
-        const { providerId } = c.req.valid('param');
-        const { code, state } = c.req.valid('query');
-        const sso = await new SSOModel(c).callback({
-            providerId,
-            code,
-            state
-        });
-        const { token } = await new SessionModel(c).createSessionByUserId(sso.userId);
-        return c.json({
-            id: sso.userId,
-            token
-        });
-    }
-});

package/dist/src/api/modules/users/sso/routes/create-url.route.d.ts

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-export declare const createUrlRoute: {
-    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: z.ZodObject<{
-                providerId: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                providerId: string;
-            }, {
-                providerId: string;
-            }>;
-        };
-        responses: {
-            200: {
-                content: {
-                    'application/json': {
-                        schema: z.ZodObject<{
-                            url: z.ZodString;
-                        }, "strip", z.ZodTypeAny, {
-                            url: string;
-                        }, {
-                            url: string;
-                        }>;
-                    };
-                };
-                description: string;
-            };
-        };
-    } & {
-        getRoutingPath: () => "/:providerId";
-    };
-};
-//# sourceMappingURL=create-url.route.d.ts.map

package/dist/src/api/modules/users/sso/routes/create-url.route.d.ts.map

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

package/dist/src/api/modules/users/sso/routes/create-url.route.js

@@ -1,36 +0,0 @@
-import { z } from "zod";
-import { buildRoute } from "../../../../lib/route";
-import { SSOModel } from "../../../../models/sso";
-import { CONFIG_PLUGIN } from "../../../../../config";
-export const createUrlRoute = buildRoute({
-    ...CONFIG_PLUGIN,
-    route: {
-        method: 'post',
-        description: 'Generate SSO URL',
-        path: '/{providerId}',
-        request: {
-            params: z.object({
-                providerId: z.string()
-            })
-        },
-        responses: {
-            200: {
-                content: {
-                    'application/json': {
-                        schema: z.object({
-                            url: z.string()
-                        })
-                    }
-                },
-                description: 'URL'
-            }
-        }
-    },
-    handler: async (c)=>{
-        const { providerId } = c.req.valid('param');
-        const url = await new SSOModel(c).getUrl(providerId);
-        return c.json({
-            url
-        });
-    }
-});