@tinyrack/tinyauth-server 0.0.7

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAGsB,CAAC"}

package/dist/routes/index.js

@@ -0,0 +1,9 @@
+import { Hono } from 'hono';
+import { wellKnownRoutes } from "./.well-known/index.js";
+import { apiRoutes } from "./api/index.js";
+import { oauthApplicationRoutes } from "./oauth/index.js";
+export const routes = new Hono()
+    .route('/api', apiRoutes)
+    .route('/oauth', oauthApplicationRoutes)
+    .route('/.well-known', wellKnownRoutes);
+//# sourceMappingURL=index.js.map

package/dist/routes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,IAAI,EAAU;KACrC,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC;KACxB,KAAK,CAAC,QAAQ,EAAE,sBAAsB,CAAC;KACvC,KAAK,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC"}

package/dist/routes/oauth/.well-known/jwks/get.d.ts

@@ -0,0 +1,24 @@
+import type { AppEnv } from '#server/lib/app-env.js';
+export declare const jwksGet: import("hono/hono-base").HonoBase<AppEnv, {
+    "/.well-known/jwks": {
+        $get: {
+            input: {};
+            output: {
+                keys: {
+                    kty: string;
+                    use: string;
+                    kid: string;
+                    alg: string;
+                    n?: string | undefined | undefined;
+                    e?: string | undefined | undefined;
+                    x?: string | undefined | undefined;
+                    y?: string | undefined | undefined;
+                    crv?: string | undefined | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/.well-known/jwks">;
+//# sourceMappingURL=get.d.ts.map

package/dist/routes/oauth/.well-known/jwks/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../../src/routes/oauth/.well-known/jwks/get.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGrD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;4BAiDnB,CAAC"}

package/dist/routes/oauth/.well-known/jwks/get.js

@@ -0,0 +1,41 @@
+import { Hono } from 'hono';
+import { describeRoute, resolver } from 'hono-openapi';
+import { z } from 'zod';
+import { TAGS } from '#server/lib/swagger-tags.js';
+export const jwksGet = new Hono().get('/.well-known/jwks', describeRoute({
+    tags: [TAGS.OPENID],
+    summary: 'JWKS',
+    description: 'JSON Web Key Set (JWKS) endpoint - Returns RSA public keys used for verifying tokens (RFC 7517). Supports automatic key rotation with multiple active keys.',
+    responses: {
+        200: {
+            content: {
+                'application/json': {
+                    schema: resolver(z.object({
+                        keys: z
+                            .array(z.object({
+                            kty: z.string().describe('Key Type'),
+                            use: z.string().describe('Public Key Use'),
+                            kid: z.string().describe('Key ID'),
+                            alg: z.string().describe('Algorithm'),
+                            n: z.string().optional().describe('RSA modulus'),
+                            e: z.string().optional().describe('RSA exponent'),
+                            x: z.string().optional().describe('EC x coordinate'),
+                            y: z.string().optional().describe('EC y coordinate'),
+                            crv: z.string().optional().describe('EC curve name'),
+                        }))
+                            .describe('Array of JWK objects representing public keys for token verification'),
+                    })),
+                },
+            },
+            description: 'JWKS response',
+        },
+    },
+}), async (c) => {
+    const { jwtService } = c.var.services;
+    // Get JWKS from JwtService
+    const jwks = await jwtService.getJWKS();
+    // Set cache headers
+    c.header('Cache-Control', 'public, max-age=3600');
+    return c.json(jwks, 200);
+});
+//# sourceMappingURL=get.js.map

package/dist/routes/oauth/.well-known/jwks/get.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../../../src/routes/oauth/.well-known/jwks/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAC;AAEnD,MAAM,CAAC,MAAM,OAAO,GAAG,IAAI,IAAI,EAAU,CAAC,GAAG,CAC3C,mBAAmB,EACnB,aAAa,CAAC;IACZ,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM;IACf,WAAW,EACT,6JAA6J;IAC/J,SAAS,EAAE;QACT,GAAG,EAAE;YACH,OAAO,EAAE;gBACP,kBAAkB,EAAE;oBAClB,MAAM,EAAE,QAAQ,CACd,CAAC,CAAC,MAAM,CAAC;wBACP,IAAI,EAAE,CAAC;6BACJ,KAAK,CACJ,CAAC,CAAC,MAAM,CAAC;4BACP,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC;4BACpC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,gBAAgB,CAAC;4BAC1C,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC;4BAClC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC;4BACrC,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC;4BAChD,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC;4BACjD,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,iBAAiB,CAAC;4BACpD,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,iBAAiB,CAAC;4BACpD,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC;yBACrD,CAAC,CACH;6BACA,QAAQ,CACP,sEAAsE,CACvE;qBACJ,CAAC,CACH;iBACF;aACF;YACD,WAAW,EAAE,eAAe;SAC7B;KACF;CACF,CAAC,EACF,KAAK,EAAE,CAAC,EAAE,EAAE;IACV,MAAM,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC;IAEtC,2BAA2B;IAC3B,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;IAExC,oBAAoB;IACpB,CAAC,CAAC,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAAC;IAElD,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAC3B,CAAC,CACF,CAAC"}

package/dist/routes/oauth/.well-known/openid-configuration/get.d.ts

@@ -0,0 +1,29 @@
+import type { AppEnv } from '#server/lib/app-env.js';
+export declare const oidcConfigGet: import("hono/hono-base").HonoBase<AppEnv, {
+    "/.well-known/openid-configuration": {
+        $get: {
+            input: {};
+            output: {
+                issuer: string;
+                authorization_endpoint: string;
+                token_endpoint: string;
+                jwks_uri: string;
+                response_types_supported: string[];
+                subject_types_supported: string[];
+                id_token_signing_alg_values_supported: string[];
+                userinfo_endpoint: string;
+                scopes_supported: string[];
+                claims_supported: string[];
+                grant_types_supported: string[];
+                token_endpoint_auth_methods_supported: string[];
+                code_challenge_methods_supported: string[];
+                introspection_endpoint: string;
+                revocation_endpoint: string;
+                ui_locales_supported: ("en" | "ko" | "ja")[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/", "/.well-known/openid-configuration">;
+//# sourceMappingURL=get.d.ts.map

package/dist/routes/oauth/.well-known/openid-configuration/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../../src/routes/oauth/.well-known/openid-configuration/get.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGrD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;4CAmJzB,CAAC"}

package/dist/routes/oauth/.well-known/openid-configuration/get.js

@@ -0,0 +1,119 @@
+import { Hono } from 'hono';
+import { describeRoute, resolver } from 'hono-openapi';
+import { z } from 'zod';
+import { TAGS } from '#server/lib/swagger-tags.js';
+export const oidcConfigGet = new Hono().get('/.well-known/openid-configuration', describeRoute({
+    tags: [TAGS.OPENID],
+    summary: 'OpenID Provider Configuration',
+    description: 'Returns OpenID Provider Configuration Information (OpenID Connect Discovery 1.0)',
+    responses: {
+        200: {
+            content: {
+                'application/json': {
+                    schema: resolver(z.object({
+                        issuer: z
+                            .string()
+                            .describe('URL using the https scheme with no query or fragment component'),
+                        authorization_endpoint: z
+                            .string()
+                            .describe("URL of the OP's OAuth 2.0 Authorization Endpoint"),
+                        token_endpoint: z
+                            .string()
+                            .describe("URL of the OP's OAuth 2.0 Token Endpoint"),
+                        jwks_uri: z
+                            .string()
+                            .describe("URL of the OP's JSON Web Key Set document"),
+                        response_types_supported: z
+                            .array(z.string())
+                            .describe('JSON array containing a list of the OAuth 2.0 response_type values'),
+                        subject_types_supported: z
+                            .array(z.string())
+                            .describe('JSON array containing a list of the Subject Identifier types'),
+                        id_token_signing_alg_values_supported: z
+                            .array(z.string())
+                            .describe('JSON array containing a list of the JWS signing algorithms supported'),
+                        userinfo_endpoint: z
+                            .string()
+                            .optional()
+                            .describe("URL of the OP's UserInfo Endpoint"),
+                        scopes_supported: z
+                            .array(z.string())
+                            .optional()
+                            .describe('JSON array containing a list of the OAuth 2.0 scope values'),
+                        claims_supported: z
+                            .array(z.string())
+                            .optional()
+                            .describe('JSON array containing a list of the Claim Names'),
+                        grant_types_supported: z
+                            .array(z.string())
+                            .optional()
+                            .describe('JSON array containing a list of the OAuth 2.0 Grant Type values'),
+                        token_endpoint_auth_methods_supported: z
+                            .array(z.string())
+                            .optional()
+                            .describe('JSON array containing a list of Client Authentication methods'),
+                        code_challenge_methods_supported: z
+                            .array(z.string())
+                            .optional()
+                            .describe('JSON array containing a list of PKCE code challenge methods'),
+                        introspection_endpoint: z
+                            .string()
+                            .optional()
+                            .describe("URL of the OP's OAuth 2.0 Token Introspection Endpoint"),
+                        revocation_endpoint: z
+                            .string()
+                            .optional()
+                            .describe("URL of the OP's OAuth 2.0 Token Revocation Endpoint"),
+                        service_documentation: z
+                            .string()
+                            .optional()
+                            .describe('URL of a page containing human-readable information'),
+                        ui_locales_supported: z
+                            .array(z.string())
+                            .optional()
+                            .describe('Languages and scripts supported for the user interface'),
+                    })),
+                },
+            },
+            description: 'OpenID Configuration',
+        },
+    },
+}), async (c) => {
+    const { config } = c.var.services;
+    const baseUrl = config.server.public_origin;
+    const configuration = {
+        issuer: baseUrl,
+        authorization_endpoint: `${baseUrl}/oauth/authorize`,
+        token_endpoint: `${baseUrl}/oauth/token`,
+        jwks_uri: `${baseUrl}/oauth/jwks`,
+        response_types_supported: ['code'],
+        subject_types_supported: ['public'],
+        id_token_signing_alg_values_supported: ['RS256'],
+        userinfo_endpoint: `${baseUrl}/oauth/userinfo`,
+        scopes_supported: ['openid', 'profile', 'email', 'offline_access'],
+        claims_supported: [
+            'sub',
+            'iss',
+            'aud',
+            'exp',
+            'iat',
+            'nonce',
+            'email',
+            'email_verified',
+            'name',
+        ],
+        grant_types_supported: ['authorization_code', 'refresh_token'],
+        token_endpoint_auth_methods_supported: [
+            'client_secret_basic',
+            'client_secret_post',
+        ],
+        code_challenge_methods_supported: ['S256', 'plain'],
+        introspection_endpoint: `${baseUrl}/oauth/introspect`,
+        revocation_endpoint: `${baseUrl}/oauth/revoke`,
+        ui_locales_supported: config.i18n.supported_languages,
+    };
+    // Set Cache-Control header
+    c.header('Cache-Control', 'public, max-age=3600');
+    return c.json(configuration, 200);
+});
+//# sourceMappingURL=get.js.map

package/dist/routes/oauth/.well-known/openid-configuration/get.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../../../src/routes/oauth/.well-known/openid-configuration/get.ts"],"names":[],"mappings":"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"}

package/dist/routes/oauth/authorize/get.d.ts

@@ -0,0 +1,48 @@
+import type { AppEnv } from '../../../lib/app-env.ts';
+export declare const authorizeGet: import("hono/hono-base").HonoBase<AppEnv, {
+    "/authorize": {
+        $get: {
+            input: {
+                query: {
+                    response_type: string | string[];
+                    redirect_uri: string | string[];
+                    client_id: string | string[];
+                    state?: string | string[];
+                    code_challenge?: string | string[];
+                    code_challenge_method?: string | string[];
+                    scope?: string | string[];
+                    nonce?: string | string[];
+                    prompt?: string | string[];
+                    max_age?: string | string[];
+                    display?: string | string[];
+                };
+            };
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        } | {
+            input: {
+                query: {
+                    response_type: string | string[];
+                    redirect_uri: string | string[];
+                    client_id: string | string[];
+                    state?: string | string[];
+                    code_challenge?: string | string[];
+                    code_challenge_method?: string | string[];
+                    scope?: string | string[];
+                    nonce?: string | string[];
+                    prompt?: string | string[];
+                    max_age?: string | string[];
+                    display?: string | string[];
+                };
+            };
+            output: {
+                error: string;
+                error_description: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/", "/authorize">;
+//# sourceMappingURL=get.d.ts.map

package/dist/routes/oauth/authorize/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../../src/routes/oauth/authorize/get.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAStD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsJxB,CAAC"}

package/dist/routes/oauth/authorize/get.js

@@ -0,0 +1,102 @@
+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 authorizeGet = new Hono().get('/authorize', describeRoute({
+    tags: [TAGS.OPENID],
+    security: OPENAPI_SECURITY.optionalCookieSession,
+    summary: 'Authorize',
+    description: 'OAuth2 Authorization Endpoint',
+    responses: {
+        302: {
+            description: 'Redirect',
+        },
+        400: {
+            content: {
+                'application/json': {
+                    schema: resolver(r.OAuthError),
+                },
+            },
+            description: 'OAuth error',
+        },
+    },
+}), validator('query', z.object({
+    response_type: f.responseType,
+    redirect_uri: f.redirectUri,
+    state: f.state.optional(),
+    client_id: f.clientId,
+    code_challenge: f.codeChallenge.optional(),
+    code_challenge_method: f.codeChallengeMethod.default('S256'),
+    scope: f.scope.optional(),
+    nonce: f.nonce.optional(),
+    prompt: f.prompt.optional(),
+    max_age: f.maxAge.optional(),
+    display: f.display.optional(),
+})), verifyAuth({ optional: true }), async (c) => {
+    const query = c.req.valid('query');
+    const { oauthAuthorizeService } = c.var.services;
+    // Helper function to redirect with error
+    const redirectWithError = (error, errorDescription, redirectUri) => {
+        if (!redirectUri) {
+            return c.json({
+                error,
+                error_description: errorDescription,
+            }, 400);
+        }
+        const url = new URL(redirectUri);
+        url.searchParams.set('error', error);
+        url.searchParams.set('error_description', errorDescription);
+        if (query.state) {
+            url.searchParams.set('state', query.state);
+        }
+        return c.redirect(url.toString());
+    };
+    try {
+        const verifiedUser = c.var.verifiedUser;
+        // Call authorize service
+        const authorizeParams = {
+            query: query,
+        };
+        if (verifiedUser) {
+            authorizeParams.userSession = {
+                sub: verifiedUser.user.sub,
+                authenticated_at: verifiedUser.authenticatedAt,
+            };
+        }
+        const result = await oauthAuthorizeService.authorize(authorizeParams);
+        // Redirect based on result
+        return c.redirect(result.url);
+    }
+    catch (error) {
+        // RFC 6749 §4.1.2.1: If client_id is invalid or redirect_uri validation fails,
+        // do NOT redirect to the provided redirect_uri
+        if (error instanceof e.OAuthClientNotFound.Error) {
+            return redirectWithError('unauthorized_client', error.message, undefined);
+        }
+        if (error instanceof e.OAuthClientDisabled.Error) {
+            return redirectWithError('unauthorized_client', error.message, undefined);
+        }
+        if (error instanceof e.InvalidRedirectUri.Error) {
+            return redirectWithError('invalid_request', error.message, undefined);
+        }
+        // Only redirect errors that occur AFTER successful client + redirect_uri validation
+        if (error instanceof e.UnsupportedResponseType.Error) {
+            return redirectWithError('unsupported_response_type', error.message, query.redirect_uri);
+        }
+        if (error instanceof e.InvalidScope.Error) {
+            return redirectWithError('invalid_scope', error.message, query.redirect_uri);
+        }
+        if (error instanceof e.InvalidCodeChallengeMethod.Error) {
+            return redirectWithError('invalid_request', error.message, query.redirect_uri);
+        }
+        // Log unexpected errors
+        c.var.logger.error({ err: error }, 'Unexpected authorize error');
+        return redirectWithError('server_error', 'An unexpected error occurred', query.redirect_uri);
+    }
+});
+//# sourceMappingURL=get.js.map

package/dist/routes/oauth/authorize/get.js.map

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

package/dist/routes/oauth/index.d.ts

@@ -0,0 +1,182 @@
+import type { AppEnv } from '../../lib/app-env.ts';
+export declare const oauthApplicationRoutes: import("hono/hono-base").HonoBase<AppEnv, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/authorize": {
+        $get: {
+            input: {
+                query: {
+                    response_type: string | string[];
+                    redirect_uri: string | string[];
+                    client_id: string | string[];
+                    state?: string | string[];
+                    code_challenge?: string | string[];
+                    code_challenge_method?: string | string[];
+                    scope?: string | string[];
+                    nonce?: string | string[];
+                    prompt?: string | string[];
+                    max_age?: string | string[];
+                    display?: string | string[];
+                };
+            };
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        } | {
+            input: {
+                query: {
+                    response_type: string | string[];
+                    redirect_uri: string | string[];
+                    client_id: string | string[];
+                    state?: string | string[];
+                    code_challenge?: string | string[];
+                    code_challenge_method?: string | string[];
+                    scope?: string | string[];
+                    nonce?: string | string[];
+                    prompt?: string | string[];
+                    max_age?: string | string[];
+                    display?: string | string[];
+                };
+            };
+            output: {
+                error: string;
+                error_description: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/token": {
+        $post: {
+            input: {
+                form: {
+                    grant_type: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    client_id: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    code?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    redirect_uri?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    client_secret?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    code_verifier?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    refresh_token?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                };
+            };
+            output: {
+                access_token: string;
+                token_type: "Bearer";
+                expires_in: number;
+                refresh_token: string;
+                id_token?: string | undefined | undefined;
+                scope: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/introspect": {
+        $post: {
+            input: {
+                form: {
+                    token: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    token_type_hint?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    client_id?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    client_secret?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                };
+            };
+            output: {
+                active: boolean;
+                scope?: string | undefined | undefined;
+                client_id?: string | undefined | undefined;
+                token_type?: "Bearer" | undefined | undefined;
+                exp?: number | undefined | undefined;
+                iat?: number | undefined | undefined;
+                sub?: string | undefined | undefined;
+                iss?: string | undefined | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/revoke": {
+        $post: {
+            input: {
+                form: {
+                    token: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    token_type_hint?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    client_id?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                    client_secret?: import("hono/types").ParsedFormValue | import("hono/types").ParsedFormValue[];
+                };
+            };
+            output: {};
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/userinfo": {
+        $get: {
+            input: {
+                header: {
+                    authorization?: string;
+                };
+            };
+            output: {
+                sub: string;
+                email?: string | undefined;
+                email_verified?: boolean | undefined;
+                name?: string | undefined;
+                picture?: string | undefined;
+                preferred_username?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/.well-known/jwks": {
+        $get: {
+            input: {};
+            output: {
+                keys: {
+                    kty: string;
+                    use: string;
+                    kid: string;
+                    alg: string;
+                    n?: string | undefined | undefined;
+                    e?: string | undefined | undefined;
+                    x?: string | undefined | undefined;
+                    y?: string | undefined | undefined;
+                    crv?: string | undefined | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/"> | import("hono/types").MergeSchemaPath<{
+    "/.well-known/openid-configuration": {
+        $get: {
+            input: {};
+            output: {
+                issuer: string;
+                authorization_endpoint: string;
+                token_endpoint: string;
+                jwks_uri: string;
+                response_types_supported: string[];
+                subject_types_supported: string[];
+                id_token_signing_alg_values_supported: string[];
+                userinfo_endpoint: string;
+                scopes_supported: string[];
+                claims_supported: string[];
+                grant_types_supported: string[];
+                token_endpoint_auth_methods_supported: string[];
+                code_challenge_methods_supported: string[];
+                introspection_endpoint: string;
+                revocation_endpoint: string;
+                ui_locales_supported: ("en" | "ko" | "ja")[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/">, "/", "/">;
+//# sourceMappingURL=index.d.ts.map

package/dist/routes/oauth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routes/oauth/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AASnD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOP,CAAC"}

package/dist/routes/oauth/index.js

@@ -0,0 +1,17 @@
+import { Hono } from 'hono';
+import { jwksGet } from "./.well-known/jwks/get.js";
+import { oidcConfigGet } from "./.well-known/openid-configuration/get.js";
+import { authorizeGet } from "./authorize/get.js";
+import { introspectPost } from "./introspect/post.js";
+import { revokePost } from "./revoke/post.js";
+import { tokenPost } from "./token/post.js";
+import { userinfoGet } from "./userinfo/get.js";
+export const oauthApplicationRoutes = new Hono()
+    .route('/', authorizeGet)
+    .route('/', tokenPost)
+    .route('/', introspectPost)
+    .route('/', revokePost)
+    .route('/', userinfoGet)
+    .route('/', jwksGet)
+    .route('/', oidcConfigGet);
+//# sourceMappingURL=index.js.map

package/dist/routes/oauth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/routes/oauth/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,IAAI,EAAU;KACrD,KAAK,CAAC,GAAG,EAAE,YAAY,CAAC;KACxB,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;KACrB,KAAK,CAAC,GAAG,EAAE,cAAc,CAAC;KAC1B,KAAK,CAAC,GAAG,EAAE,UAAU,CAAC;KACtB,KAAK,CAAC,GAAG,EAAE,WAAW,CAAC;KACvB,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC;KACnB,KAAK,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC"}