@maronn-openid-connect/cli 0.7.0 → 0.8.0

package/dist/frameworks/hono/views.js

@@ -0,0 +1,458 @@
+import { DEFAULT_FEATURES } from '../../features.js';
+import { GOOGLE_LOGIN_PACKAGE, viewParamTypesTemplate, viewsInterfaceTemplate, } from './templates.js';
+export function honoViewsTemplate(features = DEFAULT_FEATURES) {
+    const googleViewsImport = features.googleLogin
+        ? `// EXTENSION (google-login): the GIS configuration type and the script URL.
+// The package generates no UI; the three elements GIS needs are written out in
+// defaultLoginPage below.
+import {
+  GOOGLE_GSI_CLIENT_SCRIPT_URL,
+  type GoogleSignInAttributes,
+} from '${GOOGLE_LOGIN_PACKAGE}/sign-in';
+`
+        : '';
+    const googleSignInMarkup = features.googleLogin
+        ? `      {/*
+        EXTENSION (google-login): the three elements GIS needs for redirect
+        mode — its client script, #g_id_onload carrying the configuration
+        (spread as attributes, which JSX escapes), and .g_id_signin, which GIS
+        replaces with the button. Style the button through the GIS button
+        attributes (data-theme, data-size, data-text, ...) on .g_id_signin.
+        hono/jsx hoists the async script into <head>.
+      */}
+      {params.googleSignIn ? (
+        <>
+          <hr />
+          <section aria-label="Sign in with Google">
+            <script src={GOOGLE_GSI_CLIENT_SCRIPT_URL} async></script>
+            <div {...params.googleSignIn}></div>
+            <div class="g_id_signin" data-type="standard"></div>
+          </section>
+        </>
+      ) : null}
+`
+        : '';
+    const deviceDefaultViews = features.deviceAuthorizationGrant
+        ? `function defaultDeviceVerificationPage(params: DeviceVerificationPageParams): JSX.Element {
+  return (
+    <Layout title="Device Activation">
+      <h1>Device Activation</h1>
+      <p>Enter the code shown on your device.</p>
+      <FormError error={params.error} />
+      <form method="post" action="/device">
+        <div>
+          <label for="user_code">Code:</label>
+          <input type="text" id="user_code" name="user_code" value={params.userCode ?? ''} required />
+        </div>
+        <button type="submit">Continue</button>
+      </form>
+    </Layout>
+  );
+}
+
+function defaultDeviceLoginPage(params: DeviceLoginPageParams): JSX.Element {
+  return (
+    <Layout title="Login">
+      <h1>Login</h1>
+      <p>Activating device code <strong>{params.userCode}</strong></p>
+      <FormError error={params.error} remainingAttempts={params.remainingAttempts} />
+      <form method="post" action="/device/login">
+        <input type="hidden" name="user_code" value={params.userCode} />
+        <input type="hidden" name="csrf_token" value={params.csrfToken} />
+        <CredentialFields />
+        <button type="submit">Login</button>
+      </form>
+    </Layout>
+  );
+}
+
+function defaultDeviceApprovalPage(params: DeviceApprovalPageParams): JSX.Element {
+  // RFC 8628 §5.4: the code is repeated here on purpose. Ask the user to check it
+  // against the device in front of them before approving.
+  return (
+    <Layout title="Authorize Device">
+      <h1>Authorize Device</h1>
+      <p>Confirm that your device is showing this code: <strong>{params.userCode}</strong></p>
+      <p>Do not continue if the code does not match.</p>
+      <p>Client <strong>{params.clientId}</strong> is requesting access to the following scopes:</p>
+      <ScopeList scopes={params.scopes} />
+      <form method="post" action="/device/approve">
+        <input type="hidden" name="user_code" value={params.userCode} />
+        <input type="hidden" name="csrf_token" value={params.csrfToken} />
+        <button type="submit" name="decision" value="approve">Approve</button>
+        <button type="submit" name="decision" value="deny">Deny</button>
+      </form>
+    </Layout>
+  );
+}
+
+function defaultDeviceCompletedPage(params: DeviceCompletedPageParams): JSX.Element {
+  return (
+    <Layout title="Device Activation">
+      <h1>Device Activation</h1>
+      <DecisionOutcome approved={params.approved} clientId={params.clientId} />
+      <p>You can close this page and go back to your device.</p>
+    </Layout>
+  );
+}
+
+`
+        : '';
+    const deviceDefaultViewsEntries = features.deviceAuthorizationGrant
+        ? `  deviceVerificationPage: defaultDeviceVerificationPage,
+  deviceLoginPage: defaultDeviceLoginPage,
+  deviceApprovalPage: defaultDeviceApprovalPage,
+  deviceCompletedPage: defaultDeviceCompletedPage,
+`
+        : '';
+    const cibaDefaultViews = features.ciba
+        ? `function defaultCibaLoginPage(params: CibaLoginPageParams): JSX.Element {
+  return (
+    <Layout title="Sign in">
+      <h1>Sign in</h1>
+      <p>Sign in to review sign-in requests sent to you.</p>
+      <FormError error={params.error} remainingAttempts={params.remainingAttempts} />
+      <form method="post" action="/ciba/login">
+        <input type="hidden" name="login_transaction_id" value={params.loginTransactionId} />
+        <input type="hidden" name="csrf_token" value={params.csrfToken} />
+        <CredentialFields />
+        <button type="submit">Login</button>
+      </form>
+    </Layout>
+  );
+}
+
+function defaultCibaPendingRequestsPage(params: CibaPendingRequestsPageParams): JSX.Element {
+  if (params.requests.length === 0) {
+    return (
+      <Layout title="Sign-in Requests">
+        <h1>Sign-in Requests</h1>
+        <p>No pending sign-in requests.</p>
+      </Layout>
+    );
+  }
+
+  // CIBA Core 1.0 §7.1: the binding_message is repeated here on purpose. Ask
+  // the user to check it against the device that started the request before
+  // approving. The Deny button is rendered with the same prominence as Approve.
+  return (
+    <Layout title="Sign-in Requests">
+      <h1>Sign-in Requests</h1>
+      <p>Only approve a request you started yourself on another device.</p>
+      {params.requests.map((request) => (
+        <section>
+          <p>Client <strong>{request.clientId}</strong> is requesting access to the following scopes:</p>
+          <ScopeList scopes={request.scopes} />
+          {request.bindingMessage ? (
+            <p>Confirm that your device is showing this message: <strong>{request.bindingMessage}</strong></p>
+          ) : null}
+          <p>This request expires in {request.expiresInSeconds} seconds.</p>
+          <form method="post" action="/ciba/approve">
+            <input type="hidden" name="auth_req_id" value={request.authReqId} />
+            <input type="hidden" name="csrf_token" value={request.csrfToken} />
+            <button type="submit" name="decision" value="approve">Approve</button>
+            <button type="submit" name="decision" value="deny">Deny</button>
+          </form>
+        </section>
+      ))}
+    </Layout>
+  );
+}
+
+function defaultCibaCompletedPage(params: CibaCompletedPageParams): JSX.Element {
+  return (
+    <Layout title="Sign-in Requests">
+      <h1>Sign-in Requests</h1>
+      <DecisionOutcome approved={params.approved} clientId={params.clientId} />
+      <p>You can close this page and go back to your device.</p>
+    </Layout>
+  );
+}
+
+`
+        : '';
+    const cibaDefaultViewsEntries = features.ciba
+        ? `  cibaLoginPage: defaultCibaLoginPage,
+  cibaPendingRequestsPage: defaultCibaPendingRequestsPage,
+  cibaCompletedPage: defaultCibaCompletedPage,
+`
+        : '';
+    const rpInitiatedLogoutDefaultViews = features.rpInitiatedLogout
+        ? `// RP-Initiated Logout 1.0 §2: the wording is fixed for every path into this
+// screen (no hint, an invalid or expired hint, another user's session, no
+// session at all), so the page cannot be used as an oracle for session state
+// or for why the hint failed.
+function defaultLogoutConfirmationPage(params: LogoutConfirmationPageParams): JSX.Element {
+  return (
+    <Layout title="Log out">
+      <h1>Log out</h1>
+      <p>Do you want to log out of the OpenID Provider?</p>
+      <p>If you did not request this, close this page.</p>
+      <form method="post" action="/logout/approve">
+        <input type="hidden" name="csrf_token" value={params.csrfToken} />
+        <button type="submit">Log out</button>
+      </form>
+    </Layout>
+  );
+}
+
+function defaultLogoutCompletedPage(_params: LogoutCompletedPageParams): JSX.Element {
+  return (
+    <Layout title="Logged out">
+      <h1>Logged out</h1>
+      <p>You have been logged out.</p>
+      <p>You can close this page.</p>
+    </Layout>
+  );
+}
+
+`
+        : '';
+    const rpInitiatedLogoutDefaultViewsEntries = features.rpInitiatedLogout
+        ? `  logoutConfirmationPage: defaultLogoutConfirmationPage,
+  logoutCompletedPage: defaultLogoutCompletedPage,
+`
+        : '';
+    const decisionOutcomeComponent = features.deviceAuthorizationGrant || features.ciba
+        ? `
+/** The approve / deny result shown once the user decided. */
+function DecisionOutcome(props: { approved: boolean; clientId: string }): JSX.Element {
+  return props.approved ? (
+    <p>You approved <strong>{props.clientId}</strong>.</p>
+  ) : (
+    <p>You denied <strong>{props.clientId}</strong>.</p>
+  );
+}
+`
+        : '';
+    return `/** @jsxImportSource hono/jsx */
+/**
+ * UI Views for OpenID Connect Provider (hono/jsx).
+ *
+ * This file contains the default markup of every user-facing screen, written
+ * as JSX. The screen routes in pages/ deliver these views (pages/login.ts
+ * renders <views.loginPage {...params} />, and so on); the logic in routes/
+ * never renders anything — it returns outcomes the pages turn into HTTP.
+ * Customize these components to match your application's design, or change
+ * how a screen is delivered in its pages/ module.
+ *
+ * Every view is a hono/jsx component: it receives typed parameters as its
+ * props and returns a JSX element (ViewResult), which renderView turns into
+ * the Response the page sends. To control the Response itself (status,
+ * headers, a body from another renderer), change the render*Page() helper of
+ * the screen in pages/ instead.
+ *
+ * JSX escapes every value interpolated with {...}, in text and in attributes,
+ * so untrusted input (login_hint, error_description, binding_message, ...) is
+ * rendered safely without manual escaping. Never hand such a value to raw()
+ * or dangerouslySetInnerHTML.
+ *
+ * Compiling this file needs JSX enabled in tsconfig.json:
+ *   "jsx": "react-jsx", "jsxImportSource": "hono/jsx"
+ */
+import type { Child } from 'hono/jsx';
+import type { JSX } from 'hono/jsx/jsx-runtime';
+import { raw } from 'hono/html';
+${googleViewsImport}
+// ============================================================
+// View Parameter Types
+// ============================================================
+
+${viewParamTypesTemplate(features)}
+// ============================================================
+// Views Interface
+// ============================================================
+
+/**
+ * What a view returns: a JSX element. A component may be async, and markup
+ * built elsewhere can be returned through hono/html — html\`...\` escapes its
+ * interpolations, raw() trusts its string as is, so only hand it HTML that is
+ * already escaped.
+ */
+export type ViewResult = JSX.Element;
+
+${viewsInterfaceTemplate(features)}
+/** Options applied when renderView turns a view into a Response. */
+export interface RenderViewInit {
+  /** HTTP status code for the generated Response (defaults to 200). */
+  status?: number;
+}
+
+/**
+ * Turn a rendered view into the text/html Response a page sends.
+ *
+ * The element is serialized to HTML here. One that contains an async component
+ * serializes to a Promise; its HTML is streamed once it resolves, so the
+ * Response (and the cookies a page attaches to it) is still built
+ * synchronously.
+ */
+export function renderView(view: ViewResult, init?: RenderViewInit): Response {
+  const html = serializeView(view);
+  return new Response(typeof html === 'string' ? html : streamWhenResolved(html), {
+    status: init?.status ?? 200,
+    headers: { 'Content-Type': 'text/html; charset=UTF-8' },
+  });
+}
+
+/**
+ * HTML of a view. JSX.Element is typed as a string, but at runtime a hono/jsx
+ * element is an object that serializes through toString(), and an async
+ * view is a Promise of one.
+ */
+function serializeView(view: ViewResult): string | Promise<string> {
+  if (view instanceof Promise) {
+    return view.then(serializeView);
+  }
+  return (view as { toString(): string | Promise<string> }).toString();
+}
+
+function streamWhenResolved(html: Promise<string>): ReadableStream<Uint8Array> {
+  return new ReadableStream({
+    async start(controller) {
+      controller.enqueue(new TextEncoder().encode(await html));
+      controller.close();
+    },
+  });
+}
+
+// ============================================================
+// Default Views Implementation
+// Replace the components below to customize the UI.
+// ============================================================
+
+/**
+ * The HTML document every default view renders into. JSX has no syntax for the
+ * doctype, so it is written with raw() — a fixed literal, never user input.
+ */
+function Layout(props: { title: string; children?: Child }): JSX.Element {
+  return (
+    <>
+      {raw('<!DOCTYPE html>')}
+      <html>
+        <head>
+          <title>{props.title}</title>
+        </head>
+        <body>{props.children}</body>
+      </html>
+    </>
+  );
+}
+
+/** The failure message of a form, with the attempts left when known. */
+function FormError(props: { error?: string; remainingAttempts?: number }): JSX.Element | null {
+  if (!props.error) return null;
+  return (
+    <p style="color: red;">
+      {props.error}
+      {props.remainingAttempts !== undefined ? <>. Attempts remaining: {props.remainingAttempts}</> : null}
+    </p>
+  );
+}
+
+/** Username / password inputs shared by every sign-in form. */
+function CredentialFields(props: { username?: string }): JSX.Element {
+  return (
+    <>
+      <div>
+        <label for="username">Username:</label>
+        <input type="text" id="username" name="username" value={props.username} required />
+      </div>
+      <div>
+        <label for="password">Password:</label>
+        <input type="password" id="password" name="password" required />
+      </div>
+    </>
+  );
+}
+
+/** The scopes a client asked for, one list item each. */
+function ScopeList(props: { scopes: string[] }): JSX.Element {
+  return (
+    <ul>
+      {props.scopes.map((scope) => (
+        <li>{scope}</li>
+      ))}
+    </ul>
+  );
+}
+${decisionOutcomeComponent}
+function defaultLoginPage(params: LoginPageParams): JSX.Element {
+  // OIDC Core 1.0 §3.1.2.1: login_hint pre-fills the username. It is
+  // unauthenticated input; the JSX attribute escapes it.
+  return (
+    <Layout title="Login">
+      <h1>Login</h1>
+      <FormError error={params.error} remainingAttempts={params.remainingAttempts} />
+      <form method="post" action="/login">
+        <input type="hidden" name="transaction_id" value={params.transactionId} />
+        <input type="hidden" name="csrf_token" value={params.csrfToken} />
+        <CredentialFields username={params.loginHint ?? ''} />
+        <button type="submit">Login</button>
+      </form>
+${googleSignInMarkup}    </Layout>
+  );
+}
+
+// The submit buttons below carry the authorization decision (OIDC Core 1.0
+// Section 3.1.2.4). The consent handler accepts exactly two values — 'approve'
+// and 'deny' — and rejects everything else with 400, so customizing this markup
+// must keep both button values as they are: renaming 'approve' makes every
+// approval fail, and renaming 'deny' makes the Deny button rejected as well.
+// See routes/consent.ts.
+function defaultConsentPage(params: ConsentPageParams): JSX.Element {
+  return (
+    <Layout title="Consent">
+      <h1>Authorize Application</h1>
+      <p>Client <strong>{params.clientId}</strong> is requesting access to the following scopes:</p>
+      <ScopeList scopes={params.scopes} />
+      <form method="post" action="/consent">
+        <input type="hidden" name="transaction_id" value={params.transactionId} />
+        <input type="hidden" name="csrf_token" value={params.csrfToken} />
+        <button type="submit" name="action" value="approve">Approve</button>
+        <button type="submit" name="action" value="deny">Deny</button>
+      </form>
+    </Layout>
+  );
+}
+
+function defaultErrorPage(params: ErrorPageParams): JSX.Element {
+  return (
+    <Layout title="Error">
+      <h1>Error</h1>
+      <p>{params.error}</p>
+      {params.errorDescription ? <p>{params.errorDescription}</p> : null}
+    </Layout>
+  );
+}
+
+${deviceDefaultViews}${cibaDefaultViews}${rpInitiatedLogoutDefaultViews}/**
+ * Default Views used when no custom views are injected.
+ * These render minimal, unstyled HTML so the flow works out of the box.
+ */
+export const defaultViews: Views = {
+  loginPage: defaultLoginPage,
+  consentPage: defaultConsentPage,
+  errorPage: defaultErrorPage,
+${deviceDefaultViewsEntries}${cibaDefaultViewsEntries}${rpInitiatedLogoutDefaultViewsEntries}};
+
+/**
+ * Build a Views instance, overriding any subset of the default views with your
+ * own implementation. Inject the result through the provider options instead of
+ * editing this file:
+ *
+ * @example
+ * // Provide your own login UI while keeping the default consent/error pages.
+ * createApp({
+ *   signingKeyProvider,
+ *   views: {
+ *     loginPage: (params) => <MyLoginPage {...params} />,
+ *   },
+ * });
+ */
+export function createViews(overrides?: Partial<Views>): Views {
+  if (!overrides) return defaultViews;
+  return { ...defaultViews, ...overrides };
+}
+`;
+}
+//# sourceMappingURL=views.js.map

package/dist/frameworks/hono/views.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.js","sourceRoot":"","sources":["../../../src/frameworks/hono/views.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAMxB,MAAM,UAAU,iBAAiB,CAC/B,QAAQ,GAAsB,gBAAgB;IAE9C,MAAM,iBAAiB,GAAG,QAAQ,CAAC,WAAW;QAC5C,CAAC,CAAC;;;;;;UAMI,oBAAoB;CAC7B;QACG,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,kBAAkB,GAAG,QAAQ,CAAC,WAAW;QAC7C,CAAC,CAAC;;;;;;;;;;;;;;;;;;CAkBL;QACG,CAAC,CAAC,EAAE,CAAC;IAEP,MAAM,kBAAkB,GAAG,QAAQ,CAAC,wBAAwB;QAC1D,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DL;QACG,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,yBAAyB,GAAG,QAAQ,CAAC,wBAAwB;QACjE,CAAC,CAAC;;;;CAIL;QACG,CAAC,CAAC,EAAE,CAAC;IAEP,MAAM,gBAAgB,GAAG,QAAQ,CAAC,IAAI;QACpC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DL;QACG,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,uBAAuB,GAAG,QAAQ,CAAC,IAAI;QAC3C,CAAC,CAAC;;;CAGL;QACG,CAAC,CAAC,EAAE,CAAC;IAEP,MAAM,6BAA6B,GAAG,QAAQ,CAAC,iBAAiB;QAC9D,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BL;QACG,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,oCAAoC,GAAG,QAAQ,CAAC,iBAAiB;QACrE,CAAC,CAAC;;CAEL;QACG,CAAC,CAAC,EAAE,CAAC;IAIP,MAAM,wBAAwB,GAAG,QAAQ,CAAC,wBAAwB,IAAI,QAAQ,CAAC,IAAI;QACjF,CAAC,CAAC;;;;;;;;;CASL;QACG,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BP,iBAAiB;;;;;EAKjB,sBAAsB,CAAC,QAAQ,CAAC;;;;;;;;;;;;;EAahC,sBAAsB,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwGhC,wBAAwB;;;;;;;;;;;;;;EAcxB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoClB,kBAAkB,GAAG,gBAAgB,GAAG,6BAA6B;;;;;;;;EAQrE,yBAAyB,GAAG,uBAAuB,GAAG,oCAAoC;;;;;;;;;;;;;;;;;;;;CAoB3F,CAAC;AACF,CAAC"}

package/dist/frameworks/nextjs/authorize.d.ts

@@ -0,0 +1,3 @@
+import type { OidcFeatureConfig } from '../../features.js';
+export declare function nextJsAuthorizeRouteTemplate(corePkg: string, features?: OidcFeatureConfig, scopes?: string[]): string;
+//# sourceMappingURL=authorize.d.ts.map

package/dist/frameworks/nextjs/authorize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorize.d.ts","sourceRoot":"","sources":["../../../src/frameworks/nextjs/authorize.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAI3D,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,iBAAoC,EAC9C,MAAM,GAAE,MAAM,EAAO,GACpB,MAAM,CAwwBR"}