@tinyrack/tinyauth-server 0.0.7

package/dist/routes/api/user/index.d.ts

@@ -0,0 +1,334 @@
+import type { AppEnv } from '../../../lib/app-env.ts';
+export declare const userRoutes: import("hono/hono-base").HonoBase<AppEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/user": {
+        $delete: {
+            input: {};
+            output: {
+                ok: true;
+                deleted_at: string;
+                permanent_deletion_at: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/session": {
+        $get: {
+            input: {};
+            output: {
+                user: null;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {};
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/password": {
+        $post: {
+            input: {
+                json: {
+                    password: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/password": {
+        $put: {
+            input: {
+                json: {
+                    current_password: string;
+                    new_password: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/password": {
+        $delete: {
+            input: {
+                json: {
+                    current_password: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/oauth-accounts": {
+        $get: {
+            input: {};
+            output: {
+                accounts: {
+                    provider_name: string;
+                    linked_at: string;
+                }[];
+                available_providers: {
+                    id: string;
+                    display_name: string;
+                    icon_url: string | undefined;
+                    linked: boolean;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/totp/setup": {
+        $post: {
+            input: {};
+            output: {
+                secret: string;
+                otpauth_url: string;
+                qr_code: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/totp/verify": {
+        $post: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                recovery_codes: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/totp/confirm": {
+        $post: {
+            input: {
+                json?: Record<string, never> | null | undefined;
+            };
+            output: {
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/totp/recovery/regenerate": {
+        $post: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                recovery_codes: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/totp": {
+        $delete: {
+            input: {
+                json: {
+                    code: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/passkeys": {
+        $get: {
+            input: {};
+            output: {
+                passkeys: {
+                    id: string;
+                    credential_id: string;
+                    name: string | null;
+                    device_type: "singleDevice" | "multiDevice";
+                    backed_up: boolean;
+                    created_at: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    name: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/register/options": {
+        $post: {
+            input: {};
+            output: {
+                options: {
+                    rp: {
+                        id?: string | undefined;
+                        name: string;
+                    };
+                    user: {
+                        id: string;
+                        name: string;
+                        displayName: string;
+                    };
+                    challenge: import("@simplewebauthn/server").Base64URLString;
+                    pubKeyCredParams: {
+                        alg: import("@simplewebauthn/server").COSEAlgorithmIdentifier;
+                        type: import("@simplewebauthn/server").PublicKeyCredentialType;
+                    }[];
+                    timeout?: number | undefined;
+                    excludeCredentials?: {
+                        id: import("@simplewebauthn/server").Base64URLString;
+                        type: import("@simplewebauthn/server").PublicKeyCredentialType;
+                        transports?: import("@simplewebauthn/server").AuthenticatorTransportFuture[] | undefined;
+                    }[] | undefined;
+                    authenticatorSelection?: {
+                        authenticatorAttachment?: import("@simplewebauthn/server").AuthenticatorAttachment | undefined;
+                        requireResidentKey?: boolean | undefined;
+                        residentKey?: import("@simplewebauthn/server").ResidentKeyRequirement | undefined;
+                        userVerification?: import("@simplewebauthn/server").UserVerificationRequirement | undefined;
+                    } | undefined;
+                    hints?: import("@simplewebauthn/server").PublicKeyCredentialHint[] | undefined;
+                    attestation?: import("@simplewebauthn/server").AttestationConveyancePreference | undefined;
+                    attestationFormats?: import("@simplewebauthn/server").AttestationFormat[] | undefined;
+                    extensions?: {
+                        appid?: string | undefined;
+                        credProps?: boolean | undefined;
+                        hmacCreateSecret?: boolean | undefined;
+                        minPinLength?: boolean | undefined;
+                    } | undefined;
+                };
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/user/passkeys/register/verify": {
+        $post: {
+            input: {
+                json: {
+                    response: Record<string, any>;
+                    name?: string | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                user: {
+                    managed_by: "database" | "config";
+                    sub: string;
+                    email: string;
+                    email_verified: boolean;
+                    email_verification_required: boolean;
+                    has_password: boolean;
+                    totp_registered: boolean;
+                    totp_recovery_codes_missing: boolean;
+                    second_factor_required: boolean;
+                    passkey_count: number;
+                };
+                second_factor_setup_completed: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        } | {
+            input: {
+                json: {
+                    response: Record<string, any>;
+                    name?: string | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                second_factor_setup_completed: false;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/", "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/routes/api/user/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/routes/api/user/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAkBtD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgBqB,CAAC"}

package/dist/routes/api/user/index.js

@@ -0,0 +1,35 @@
+import { Hono } from 'hono';
+import { userDelete } from "./delete.js";
+import { userOauthAccountsGet } from "./oauth-accounts/get.js";
+import { userPasskeyIdDelete } from "./passkeys/_id/delete.js";
+import { userPasskeyIdPatch } from "./passkeys/_id/patch.js";
+import { userPasskeysGet } from "./passkeys/get.js";
+import { userPasskeyRegisterOptionsPost } from "./passkeys/register/options/post.js";
+import { userPasskeyRegisterVerifyPost } from "./passkeys/register/verify/post.js";
+import { userPasswordDelete } from "./password/delete.js";
+import { userPasswordPost } from "./password/post.js";
+import { userPasswordPut } from "./password/put.js";
+import { userSessionGet } from "./session/get.js";
+import { userTotpConfirmPost } from "./totp/confirm/post.js";
+import { userTotpDelete } from "./totp/delete.js";
+import { userTotpRecoveryRegeneratePost } from "./totp/recovery/regenerate/post.js";
+import { userTotpSetupPost } from "./totp/setup/post.js";
+import { userTotpVerifyPost } from "./totp/verify/post.js";
+export const userRoutes = new Hono()
+    .route('/', userDelete)
+    .route('/', userSessionGet)
+    .route('/', userPasswordPost)
+    .route('/', userPasswordPut)
+    .route('/', userPasswordDelete)
+    .route('/', userOauthAccountsGet)
+    .route('/', userTotpSetupPost)
+    .route('/', userTotpVerifyPost)
+    .route('/', userTotpConfirmPost)
+    .route('/', userTotpRecoveryRegeneratePost)
+    .route('/', userTotpDelete)
+    .route('/', userPasskeysGet)
+    .route('/', userPasskeyIdDelete)
+    .route('/', userPasskeyIdPatch)
+    .route('/', userPasskeyRegisterOptionsPost)
+    .route('/', userPasskeyRegisterVerifyPost);
+//# sourceMappingURL=index.js.map

package/dist/routes/api/user/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/routes/api/user/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,IAAI,EAAU;KACzC,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC;KACtB,KAAK,CAAC,GAAG,EAAE,cAAc,CAAC;KAC1B,KAAK,CAAC,GAAG,EAAE,gBAAgB,CAAC;KAC5B,KAAK,CAAC,GAAG,EAAE,eAAe,CAAC;KAC3B,KAAK,CAAC,GAAG,EAAE,kBAAkB,CAAC;KAC9B,KAAK,CAAC,GAAG,EAAE,oBAAoB,CAAC;KAChC,KAAK,CAAC,GAAG,EAAE,iBAAiB,CAAC;KAC7B,KAAK,CAAC,GAAG,EAAE,kBAAkB,CAAC;KAC9B,KAAK,CAAC,GAAG,EAAE,mBAAmB,CAAC;KAC/B,KAAK,CAAC,GAAG,EAAE,8BAA8B,CAAC;KAC1C,KAAK,CAAC,GAAG,EAAE,cAAc,CAAC;KAC1B,KAAK,CAAC,GAAG,EAAE,eAAe,CAAC;KAC3B,KAAK,CAAC,GAAG,EAAE,mBAAmB,CAAC;KAC/B,KAAK,CAAC,GAAG,EAAE,kBAAkB,CAAC;KAC9B,KAAK,CAAC,GAAG,EAAE,8BAA8B,CAAC;KAC1C,KAAK,CAAC,GAAG,EAAE,6BAA6B,CAAC,CAAC"}

package/dist/routes/api/user/oauth-accounts/get.d.ts

@@ -0,0 +1,23 @@
+import type { AppEnv } from '../../../../lib/app-env.ts';
+export declare const userOauthAccountsGet: import("hono/hono-base").HonoBase<AppEnv, {
+    "/user/oauth-accounts": {
+        $get: {
+            input: {};
+            output: {
+                accounts: {
+                    provider_name: string;
+                    linked_at: string;
+                }[];
+                available_providers: {
+                    id: string;
+                    display_name: string;
+                    icon_url: string | undefined;
+                    linked: boolean;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/user/oauth-accounts">;
+//# sourceMappingURL=get.d.ts.map

package/dist/routes/api/user/oauth-accounts/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../../src/routes/api/user/oauth-accounts/get.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAOzD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;+BA+DhC,CAAC"}

package/dist/routes/api/user/oauth-accounts/get.js

@@ -0,0 +1,58 @@
+import { Hono } from 'hono';
+import { describeRoute, resolver } from 'hono-openapi';
+import { OPENAPI_SECURITY } from "../../../../lib/openapi.js";
+import { TAGS } from "../../../../lib/swagger-tags.js";
+import { verifyAuth } from "../../../../middleware/auth.js";
+import { e } from "../../../../schemas/error.js";
+import { r } from "../../../../schemas/response.js";
+export const userOauthAccountsGet = new Hono().get('/user/oauth-accounts', describeRoute({
+    tags: [TAGS.USER],
+    security: OPENAPI_SECURITY.cookieSession,
+    summary: 'List Linked OAuth Accounts',
+    description: 'Returns all OAuth accounts linked to the current user',
+    responses: {
+        200: {
+            content: {
+                'application/json': {
+                    schema: resolver(r.LinkedAccountsResponse),
+                },
+            },
+            description: 'Success',
+        },
+        401: {
+            content: {
+                'application/json': {
+                    schema: resolver(e.Unauthorized.Schema),
+                },
+            },
+            description: 'Unauthorized',
+        },
+        404: {
+            content: {
+                'application/json': {
+                    schema: resolver(e.UserNotFound.Schema),
+                },
+            },
+            description: 'User not found',
+        },
+    },
+}), verifyAuth(), async (c) => {
+    const { user: userEntity } = c.var.verifiedUser;
+    const { oauthConnectService } = c.var.services;
+    // Get linked accounts
+    const accounts = await oauthConnectService.getLinkedAccounts(userEntity.sub);
+    // Get all available providers and mark linked ones
+    const enabledProviders = oauthConnectService.getEnabledProviders();
+    const linkedProviderNames = new Set(accounts.map((a) => a.provider_name));
+    const availableProviders = enabledProviders.map((provider) => ({
+        id: provider.id,
+        display_name: provider.display_name,
+        icon_url: provider.icon_url,
+        linked: linkedProviderNames.has(provider.id),
+    }));
+    return c.json({
+        accounts,
+        available_providers: availableProviders,
+    }, 200);
+});
+//# sourceMappingURL=get.js.map

package/dist/routes/api/user/oauth-accounts/get.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../../../src/routes/api/user/oauth-accounts/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,8BAA8B,CAAC;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,iCAAiC,CAAC;AAEpD,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,IAAI,EAAU,CAAC,GAAG,CACxD,sBAAsB,EACtB,aAAa,CAAC;IACZ,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;IACjB,QAAQ,EAAE,gBAAgB,CAAC,aAAa;IACxC,OAAO,EAAE,4BAA4B;IACrC,WAAW,EAAE,uDAAuD;IACpE,SAAS,EAAE;QACT,GAAG,EAAE;YACH,OAAO,EAAE;gBACP,kBAAkB,EAAE;oBAClB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,sBAAsB,CAAC;iBAC3C;aACF;YACD,WAAW,EAAE,SAAS;SACvB;QACD,GAAG,EAAE;YACH,OAAO,EAAE;gBACP,kBAAkB,EAAE;oBAClB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC;iBACxC;aACF;YACD,WAAW,EAAE,cAAc;SAC5B;QACD,GAAG,EAAE;YACH,OAAO,EAAE;gBACP,kBAAkB,EAAE;oBAClB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC;iBACxC;aACF;YACD,WAAW,EAAE,gBAAgB;SAC9B;KACF;CACF,CAAC,EACF,UAAU,EAAE,EACZ,KAAK,EAAE,CAAC,EAAE,EAAE;IACV,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC;IAChD,MAAM,EAAE,mBAAmB,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;IAE/C,sBAAsB;IACtB,MAAM,QAAQ,GAAG,MAAM,mBAAmB,CAAC,iBAAiB,CAC1D,UAAU,CAAC,GAAG,CACf,CAAC;IAEF,mDAAmD;IACnD,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,mBAAmB,EAAE,CAAC;IACnE,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAE1E,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAC7D,EAAE,EAAE,QAAQ,CAAC,EAAE;QACf,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,QAAQ,EAAE,QAAQ,CAAC,QAAQ;QAC3B,MAAM,EAAE,mBAAmB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;KAC7C,CAAC,CAAC,CAAC;IAEJ,OAAO,CAAC,CAAC,IAAI,CACX;QACE,QAAQ;QACR,mBAAmB,EAAE,kBAAkB;KACxC,EACD,GAAG,CACJ,CAAC;AACJ,CAAC,CACF,CAAC"}

package/dist/routes/api/user/passkeys/_id/delete.d.ts

@@ -0,0 +1,18 @@
+import type { AppEnv } from '../../../../../lib/app-env.ts';
+export declare const userPasskeyIdDelete: import("hono/hono-base").HonoBase<AppEnv, {
+    "/user/passkeys/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/user/passkeys/:id">;
+//# sourceMappingURL=delete.d.ts.map

package/dist/routes/api/user/passkeys/_id/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../../../../src/routes/api/user/passkeys/_id/delete.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAQ5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;6BA+F/B,CAAC"}

package/dist/routes/api/user/passkeys/_id/delete.js

@@ -0,0 +1,87 @@
+import { Hono } from 'hono';
+import { describeRoute, resolver, validator } from 'hono-openapi';
+import { z } from 'zod';
+import { OPENAPI_SECURITY } from "../../../../../lib/openapi.js";
+import { TAGS } from "../../../../../lib/swagger-tags.js";
+import { verifyAuth } from "../../../../../middleware/auth.js";
+import { e } from "../../../../../schemas/error.js";
+import { f } from "../../../../../schemas/field.js";
+import { r } from "../../../../../schemas/response.js";
+export const userPasskeyIdDelete = new Hono().delete('/user/passkeys/:id', describeRoute({
+    tags: [TAGS.USER],
+    security: OPENAPI_SECURITY.cookieSession,
+    summary: 'Delete Passkey',
+    description: 'Delete a passkey by ID',
+    responses: {
+        200: {
+            content: {
+                'application/json': { schema: resolver(r.OkResponse) },
+            },
+            description: 'Success',
+        },
+        400: {
+            content: {
+                'application/json': {
+                    schema: resolver(e.PasskeyNotEnabled.Schema),
+                },
+            },
+            description: 'Passkey not enabled, cannot remove last passkey, or cannot remove last second factor',
+        },
+        401: {
+            content: {
+                'application/json': {
+                    schema: resolver(e.Unauthorized.Schema),
+                },
+            },
+            description: 'Unauthorized',
+        },
+        403: {
+            content: {
+                'application/json': {
+                    schema: resolver(e.SecondFactorNotAllowedForConfigUser.Schema),
+                },
+            },
+            description: 'Second factor not allowed for config user',
+        },
+        404: {
+            content: {
+                'application/json': {
+                    schema: resolver(e.PasskeyNotFound.Schema),
+                },
+            },
+            description: 'Passkey not found',
+        },
+    },
+}), validator('param', z.object({
+    id: f.uuid,
+})), verifyAuth(), async (c) => {
+    const config = c.var.services.config;
+    if (!config.auth.passkey.enabled) {
+        throw new e.PasskeyNotEnabled.Error();
+    }
+    const params = c.req.valid('param');
+    const { user: userEntity } = c.var.verifiedUser;
+    const { mikro, passkeyService } = c.var.services;
+    // Config users cannot manage 2FA
+    if (userEntity.managed_by === 'config') {
+        throw new e.SecondFactorNotAllowedForConfigUser.Error();
+    }
+    // Load password_hash to check auth methods
+    await mikro.em.populate(userEntity, ['password_hash']);
+    const hasLinkedOAuth = (await mikro.userOAuth.count({
+        user: { sub: userEntity.sub },
+    })) > 0;
+    const hasOtherAuthMethods = userEntity.hasPassword() || hasLinkedOAuth;
+    // Check if 2FA is required
+    const secondFactorRequired = config.auth.password.two_factor.enrollment_required;
+    // Check if user has other 2FA method (TOTP)
+    const totpEnabled = await mikro.userTotp.isRegistered(userEntity.sub);
+    // Delete passkey
+    await passkeyService.deletePasskey(userEntity.sub, params.id, {
+        hasOtherAuthMethods,
+        secondFactorRequired,
+        hasOtherSecondFactor: totpEnabled,
+    });
+    return c.json({ ok: true }, 200);
+});
+//# sourceMappingURL=delete.js.map

package/dist/routes/api/user/passkeys/_id/delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.js","sourceRoot":"","sources":["../../../../../../src/routes/api/user/passkeys/_id/delete.ts"],"names":[],"mappings":"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"}

package/dist/routes/api/user/passkeys/_id/patch.d.ts

@@ -0,0 +1,22 @@
+import type { AppEnv } from '../../../../../lib/app-env.ts';
+export declare const userPasskeyIdPatch: import("hono/hono-base").HonoBase<AppEnv, {
+    "/user/passkeys/:id": {
+        $patch: {
+            input: {
+                param: {
+                    id: string;
+                };
+            } & {
+                json: {
+                    name: string;
+                };
+            };
+            output: {
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/user/passkeys/:id">;
+//# sourceMappingURL=patch.d.ts.map

package/dist/routes/api/user/passkeys/_id/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../../../../../src/routes/api/user/passkeys/_id/patch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAQ5D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;6BAqE9B,CAAC"}