@archlast/server 0.1.7 → 0.1.9

package/dist/controllers/mfa.controller.js

@@ -26,130 +26,150 @@ exports.mfaController = new elysia_1.Elysia({ prefix: "/mfa", tags: ["MFA"] })
      * POST /_auth/mfa/enroll
      * Start TOTP enrollment
      */
-    .post("/enroll", async (ctx) => {
-    const { rawDb, user } = (0, context_helper_js_1.getCtx)(ctx);
-    const { body, set } = (0, context_helper_js_1.getCtx)(ctx);
-    if (!user) {
-        set.status = 401;
-        return { error: "Unauthorized" };
-    }
-    const mfaService = (0, index_js_1.createMfaService)(rawDb);
-    const result = await mfaService.enrollTotp({
-        userId: user.id,
-        issuer: body.issuer || "Archlast",
-        accountName: user.tenantId || user.id,
-    });
-    return {
-        success: true,
-        secret: result.secret,
-        uri: result.uri,
-        qrDataUrl: result.qrDataUrl,
-    };
-}, {
-    body: EnrollSchema,
-    detail: {
-        summary: "Enroll TOTP",
-        description: "Start TOTP enrollment and get QR code",
-    },
-})
+    .post(
+        "/enroll",
+        async (ctx) => {
+            const { rawDb, user } = (0, context_helper_js_1.getCtx)(ctx);
+            const { body, set } = (0, context_helper_js_1.getCtx)(ctx);
+            if (!user) {
+                set.status = 401;
+                return { error: "Unauthorized" };
+            }
+            const mfaService = (0, index_js_1.createMfaService)(rawDb);
+            const result = await mfaService.enrollTotp({
+                userId: user.id,
+                issuer: body.issuer || "Archlast",
+                accountName: user.tenantId || user.id,
+            });
+            return {
+                success: true,
+                secret: result.secret,
+                uri: result.uri,
+                qrDataUrl: result.qrDataUrl,
+            };
+        },
+        {
+            body: EnrollSchema,
+            detail: {
+                summary: "Enroll TOTP",
+                description: "Start TOTP enrollment and get QR code",
+            },
+        }
+    )
     /**
      * POST /_auth/mfa/verify-enrollment
      * Verify TOTP enrollment with code
      */
-    .post("/verify-enrollment", async (ctx) => {
-    const { rawDb, user } = ctx;
-    const { body, set } = (0, context_helper_js_1.getCtx)(ctx);
-    if (!user) {
-        set.status = 401;
-        return { error: "Unauthorized" };
-    }
-    const mfaService = (0, index_js_1.createMfaService)(rawDb);
-    const result = await mfaService.verifyTotpEnrollment({
-        userId: user.id,
-        code: body.code,
-    });
-    if (!result.valid) {
-        return { valid: false, error: "Invalid code" };
-    }
-    // Generate backup codes after successful enrollment
-    const backupCodes = await mfaService.generateBackupCodes(user.id);
-    return {
-        valid: true,
-        backupCodes: backupCodes.codes,
-    };
-}, {
-    body: VerifyEnrollmentSchema,
-    detail: {
-        summary: "Verify TOTP enrollment",
-        description: "Complete TOTP enrollment with verification code",
-    },
-})
+    .post(
+        "/verify-enrollment",
+        async (ctx) => {
+            const { rawDb, user } = ctx;
+            const { body, set } = (0, context_helper_js_1.getCtx)(ctx);
+            if (!user) {
+                set.status = 401;
+                return { error: "Unauthorized" };
+            }
+            const mfaService = (0, index_js_1.createMfaService)(rawDb);
+            const result = await mfaService.verifyTotpEnrollment({
+                userId: user.id,
+                code: body.code,
+            });
+            if (!result.valid) {
+                return { valid: false, error: "Invalid code" };
+            }
+            // Generate backup codes after successful enrollment
+            const backupCodes = await mfaService.generateBackupCodes(user.id);
+            return {
+                valid: true,
+                backupCodes: backupCodes.codes,
+            };
+        },
+        {
+            body: VerifyEnrollmentSchema,
+            detail: {
+                summary: "Verify TOTP enrollment",
+                description: "Complete TOTP enrollment with verification code",
+            },
+        }
+    )
     /**
      * POST /_auth/mfa/challenge
      * Verify TOTP code during login
      */
-    .post("/challenge", async (ctx) => {
-    const { rawDb } = ctx;
-    const { body, set } = (0, context_helper_js_1.getCtx)(ctx);
-    const mfaService = (0, index_js_1.createMfaService)(rawDb);
-    // Try TOTP first
-    let result = await mfaService.verifyTotp({
-        userId: body.userId,
-        code: body.code,
-    });
-    // If TOTP fails, try backup code
-    if (!result.valid) {
-        result = await mfaService.verifyBackupCode({
-            userId: body.userId,
-            code: body.code,
-        });
-    }
-    return { valid: result.valid };
-}, {
-    body: ChallengeSchema,
-    detail: {
-        summary: "MFA challenge",
-        description: "Verify TOTP or backup code during login",
-    },
-})
+    .post(
+        "/challenge",
+        async (ctx) => {
+            const { rawDb } = ctx;
+            const { body, set } = (0, context_helper_js_1.getCtx)(ctx);
+            const mfaService = (0, index_js_1.createMfaService)(rawDb);
+            // Try TOTP first
+            let result = await mfaService.verifyTotp({
+                userId: body.userId,
+                code: body.code,
+            });
+            // If TOTP fails, try backup code
+            if (!result.valid) {
+                result = await mfaService.verifyBackupCode({
+                    userId: body.userId,
+                    code: body.code,
+                });
+            }
+            return { valid: result.valid };
+        },
+        {
+            body: ChallengeSchema,
+            detail: {
+                summary: "MFA challenge",
+                description: "Verify TOTP or backup code during login",
+            },
+        }
+    )
     /**
      * GET /_auth/mfa/status
      * Check if MFA is enabled
      */
-    .get("/status", async (ctx) => {
-    const { rawDb, user } = ctx;
-    const { set } = (0, context_helper_js_1.getCtx)(ctx);
-    if (!user) {
-        set.status = 401;
-        return { error: "Unauthorized" };
-    }
-    const mfaService = (0, index_js_1.createMfaService)(rawDb);
-    const hasMfa = await mfaService.hasMfaEnabled(user.id);
-    return { enabled: hasMfa };
-}, {
-    detail: {
-        summary: "MFA status",
-        description: "Check if MFA is enabled for current user",
-    },
-})
+    .get(
+        "/status",
+        async (ctx) => {
+            const { rawDb, user } = ctx;
+            const { set } = (0, context_helper_js_1.getCtx)(ctx);
+            if (!user) {
+                set.status = 401;
+                return { error: "Unauthorized" };
+            }
+            const mfaService = (0, index_js_1.createMfaService)(rawDb);
+            const hasMfa = await mfaService.hasMfaEnabled(user.id);
+            return { enabled: hasMfa };
+        },
+        {
+            detail: {
+                summary: "MFA status",
+                description: "Check if MFA is enabled for current user",
+            },
+        }
+    )
     /**
      * DELETE /_auth/mfa
      * Disable MFA for user
      */
-    .delete("/", async (ctx) => {
-    const { rawDb, user } = ctx;
-    const { set } = (0, context_helper_js_1.getCtx)(ctx);
-    if (!user) {
-        set.status = 401;
-        return { error: "Unauthorized" };
-    }
-    const mfaService = (0, index_js_1.createMfaService)(rawDb);
-    await mfaService.removeMfa(user.id);
-    return { success: true };
-}, {
-    detail: {
-        summary: "Disable MFA",
-        description: "Remove MFA from current user account",
-    },
-});
-//# sourceMappingURL=mfa.controller.js.map
+    .delete(
+        "/",
+        async (ctx) => {
+            const { rawDb, user } = ctx;
+            const { set } = (0, context_helper_js_1.getCtx)(ctx);
+            if (!user) {
+                set.status = 401;
+                return { error: "Unauthorized" };
+            }
+            const mfaService = (0, index_js_1.createMfaService)(rawDb);
+            await mfaService.removeMfa(user.id);
+            return { success: true };
+        },
+        {
+            detail: {
+                summary: "Disable MFA",
+                description: "Remove MFA from current user account",
+            },
+        }
+    );
+//# sourceMappingURL=mfa.controller.js.map

package/dist/controllers/otp.controller.d.ts

@@ -3,125 +3,59 @@
  * Handles /_auth/otp/* endpoints for magic links and email verification
  */
 import { Elysia } from "elysia";
-export declare const otpController: Elysia<"/otp", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-} & {
-    schema: {};
-    standaloneSchema: {};
-    macro: Partial<{}>;
-    macroFn: ({ onBeforeHandle }: any) => {
-        requireAuth(enabled: boolean): void;
-    };
-    parser: {};
-    response: {};
-}, {
-    otp: {};
-} & {
-    otp: {
-        send: {
-            post: {
-                body: {
-                    type?: string | undefined;
-                    email: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: {
-                        error: string;
-                    } | {
-                        code?: string | undefined;
-                        success: boolean;
-                        expiresAt: number;
-                        error?: undefined;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
+export declare const otpController: Elysia<
+    "/otp",
+    {
+        decorator: {};
+        store: {};
+        derive: {};
+        resolve: {};
+    },
+    {
+        typebox: {};
+        error: {};
+    },
+    {
+        schema: {};
+        standaloneSchema: {};
+        macro: {};
+        macroFn: {};
+        parser: {};
+        response: {};
+    } & {
+        schema: {};
+        standaloneSchema: {};
+        macro: Partial<{}>;
+        macroFn: ({ onBeforeHandle }: any) => {
+            requireAuth(enabled: boolean): void;
         };
-    };
-} & {
-    otp: {
-        verify: {
-            post: {
-                body: {
-                    type?: string | undefined;
-                    email: string;
-                    code: string;
-                };
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: {
-                        error: string;
-                        valid?: undefined;
-                        userId?: undefined;
-                    } | {
-                        valid: boolean;
-                        error: string;
-                        userId?: undefined;
-                    } | {
-                        valid: boolean;
-                        userId: string | undefined;
-                        error?: undefined;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    };
-} & {
-    otp: {
-        "magic-link": {
+        parser: {};
+        response: {};
+    },
+    {
+        otp: {};
+    } & {
+        otp: {
             send: {
                 post: {
                     body: {
-                        redirectUrl?: string | undefined;
+                        type?: string | undefined;
                         email: string;
                     };
                     params: {};
                     query: unknown;
                     headers: unknown;
                     response: {
-                        200: {
-                            error: string;
-                        } | {
-                            url?: string | undefined;
-                            success: boolean;
-                            expiresAt: number;
-                            error?: undefined;
-                        };
+                        200:
+                            | {
+                                  error: string;
+                              }
+                            | {
+                                  code?: string | undefined;
+                                  success: boolean;
+                                  expiresAt: number;
+                                  error?: undefined;
+                              };
                         422: {
                             type: "validation";
                             on: string;
@@ -135,35 +69,35 @@ export declare const otpController: Elysia<"/otp", {
                 };
             };
         };
-    };
-} & {
-    otp: {
-        "magic-link": {
+    } & {
+        otp: {
             verify: {
                 post: {
                     body: {
-                        token: string;
+                        type?: string | undefined;
+                        email: string;
+                        code: string;
                     };
                     params: {};
                     query: unknown;
                     headers: unknown;
                     response: {
-                        200: {
-                            error: string;
-                            valid?: undefined;
-                            userId?: undefined;
-                            email?: undefined;
-                        } | {
-                            valid: boolean;
-                            error: string;
-                            userId?: undefined;
-                            email?: undefined;
-                        } | {
-                            valid: boolean;
-                            userId: string | undefined;
-                            email: string | undefined;
-                            error?: undefined;
-                        };
+                        200:
+                            | {
+                                  error: string;
+                                  valid?: undefined;
+                                  userId?: undefined;
+                              }
+                            | {
+                                  valid: boolean;
+                                  error: string;
+                                  userId?: undefined;
+                              }
+                            | {
+                                  valid: boolean;
+                                  userId: string | undefined;
+                                  error?: undefined;
+                              };
                         422: {
                             type: "validation";
                             on: string;
@@ -177,44 +111,133 @@ export declare const otpController: Elysia<"/otp", {
                 };
             };
         };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-} & {
-    derive: {
-        readonly auth: null;
-        readonly user: null;
-    } | {
-        readonly auth: import("../auth/interfaces.js").AuthContext;
-        readonly user: {
-            id: string;
-            tenantId: string | null;
-            session: import("../auth/interfaces.js").AuthSession | null;
-        } | null;
-    };
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: import("elysia").ExtractErrorFromHandle<{
-        readonly auth: null;
-        readonly user: null;
-    } | {
-        readonly auth: import("../auth/interfaces.js").AuthContext;
-        readonly user: {
-            id: string;
-            tenantId: string | null;
-            session: import("../auth/interfaces.js").AuthSession | null;
-        } | null;
-    }>;
-}>;
-//# sourceMappingURL=otp.controller.d.ts.map
+    } & {
+        otp: {
+            "magic-link": {
+                send: {
+                    post: {
+                        body: {
+                            redirectUrl?: string | undefined;
+                            email: string;
+                        };
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200:
+                                | {
+                                      error: string;
+                                  }
+                                | {
+                                      url?: string | undefined;
+                                      success: boolean;
+                                      expiresAt: number;
+                                      error?: undefined;
+                                  };
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        otp: {
+            "magic-link": {
+                verify: {
+                    post: {
+                        body: {
+                            token: string;
+                        };
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200:
+                                | {
+                                      error: string;
+                                      valid?: undefined;
+                                      userId?: undefined;
+                                      email?: undefined;
+                                  }
+                                | {
+                                      valid: boolean;
+                                      error: string;
+                                      userId?: undefined;
+                                      email?: undefined;
+                                  }
+                                | {
+                                      valid: boolean;
+                                      userId: string | undefined;
+                                      email: string | undefined;
+                                      error?: undefined;
+                                  };
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    },
+    {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    },
+    {
+        derive: {};
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: {};
+    } & {
+        derive:
+            | {
+                  readonly auth: null;
+                  readonly user: null;
+              }
+            | {
+                  readonly auth: import("../auth/interfaces.js").AuthContext;
+                  readonly user: {
+                      id: string;
+                      tenantId: string | null;
+                      session: import("../auth/interfaces.js").AuthSession | null;
+                  } | null;
+              };
+        resolve: {};
+        schema: {};
+        standaloneSchema: {};
+        response: import("elysia").ExtractErrorFromHandle<
+            | {
+                  readonly auth: null;
+                  readonly user: null;
+              }
+            | {
+                  readonly auth: import("../auth/interfaces.js").AuthContext;
+                  readonly user: {
+                      id: string;
+                      tenantId: string | null;
+                      session: import("../auth/interfaces.js").AuthSession | null;
+                  } | null;
+              }
+        >;
+    }
+>;
+//# sourceMappingURL=otp.controller.d.ts.map