@vitnode/core 1.2.0-canary.10

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+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
+        });
+    }
+});

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

@@ -0,0 +1,125 @@
+export declare const ssoUserModule: 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=sso.module.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+import { buildModule } from "../../../lib/module";
+import { CONFIG_PLUGIN } from "../../../../config";
+import { callbackRoute } from "./routes/callback.route";
+import { createUrlRoute } from "./routes/create-url.route";
+export const ssoUserModule = buildModule({
+    ...CONFIG_PLUGIN,
+    name: 'sso',
+    routes: [
+        callbackRoute,
+        createUrlRoute
+    ]
+});