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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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