@qlover/oauth-wrapper 0.2.0

package/dist/index.js

@@ -0,0 +1,977 @@
+// src/server/services/OAuthClientsService.ts
+var OAuthClientsService = class {
+  constructor(clientsRepo) {
+    this.clientsRepo = clientsRepo;
+  }
+  /**
+   * List all OAuth clients owned by a user
+   * @override
+   */
+  async listForOwner(ownerUserId) {
+    return this.clientsRepo.listClientByOwner(ownerUserId);
+  }
+  /**
+   * Get detailed information about a specific OAuth client
+   * @override
+   */
+  async getByClientId(ownerUserId, clientId) {
+    const client = await this.clientsRepo.findClientById(clientId);
+    if (!client) {
+      throw new Error("Client not found");
+    }
+    if (client.owner_user_id !== ownerUserId) {
+      throw new Error("Access denied");
+    }
+    return this.mapToDetail(client);
+  }
+  /**
+   * Create a new OAuth client
+   * @override
+   */
+  async create(ownerUserId, input) {
+    const result = await this.clientsRepo.createClient(ownerUserId, input);
+    return {
+      client_id: result.client.client_id,
+      client_secret: result.clientSecret,
+      confidential: result.client.confidential,
+      client_name: result.client.client_name,
+      client_uri: result.client.client_uri,
+      redirect_uris: result.client.redirect_uris,
+      created_at: result.client.created_at
+    };
+  }
+  /**
+   * Update an existing OAuth client
+   * @override
+   */
+  async update(ownerUserId, clientId, input) {
+    const existing = await this.clientsRepo.findClientById(clientId);
+    if (!existing) {
+      throw new Error("Client not found");
+    }
+    if (existing.owner_user_id !== ownerUserId) {
+      throw new Error("Access denied");
+    }
+    return this.clientsRepo.updateClient(ownerUserId, clientId, input);
+  }
+  /**
+   * Rotate the client secret
+   * @override
+   */
+  async rotateSecret(ownerUserId, clientId) {
+    const existing = await this.clientsRepo.findClientById(clientId);
+    if (!existing) {
+      throw new Error("Client not found");
+    }
+    if (existing.owner_user_id !== ownerUserId) {
+      throw new Error("Access denied");
+    }
+    if (!existing.confidential) {
+      throw new Error("Public clients do not have a client_secret");
+    }
+    const result = await this.clientsRepo.rotateClientSecret(
+      ownerUserId,
+      clientId
+    );
+    return {
+      client_id: clientId,
+      client_secret: result.clientSecret
+    };
+  }
+  /**
+   * Delete an OAuth client
+   * @override
+   */
+  async delete(ownerUserId, clientId) {
+    const existing = await this.clientsRepo.findClientById(clientId);
+    if (!existing) {
+      throw new Error("Client not found");
+    }
+    if (existing.owner_user_id !== ownerUserId) {
+      throw new Error("Access denied");
+    }
+    await this.clientsRepo.deleteClient(ownerUserId, clientId);
+  }
+  mapToDetail(row) {
+    return {
+      client_id: row.client_id,
+      client_name: row.client_name,
+      client_uri: row.client_uri,
+      logo_uri: row.logo_uri,
+      redirect_uris: row.redirect_uris,
+      grant_types: row.grant_types,
+      scopes: row.scopes,
+      confidential: row.confidential,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+};
+
+// src/server/services/OAuthTokenService.ts
+import { createHash as createHash2, randomBytes } from "crypto";
+
+// src/core/schema/OAuthAuthorizeSchema.ts
+import { z } from "zod";
+function isOAuthRedirectUri(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return false;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    return Boolean(parsed.protocol && parsed.protocol.endsWith(":"));
+  } catch {
+    return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed);
+  }
+}
+var oauthRedirectUriSchema = z.string().min(1).refine(isOAuthRedirectUri, { message: "Invalid redirect URI" });
+var OAuthClientRowSchema = z.object({
+  id: z.number(),
+  client_id: z.string(),
+  client_secret_hash: z.string().nullable().optional(),
+  client_name: z.string(),
+  client_uri: z.string().nullable().optional(),
+  logo_uri: z.string().nullable().optional(),
+  redirect_uris: z.array(z.string()),
+  grant_types: z.array(z.string()),
+  scopes: z.array(z.string()),
+  confidential: z.boolean(),
+  owner_user_id: z.number(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var OAuthClientListItemSchema = z.object({
+  client_id: z.string(),
+  client_name: z.string(),
+  client_uri: z.string().nullable().optional(),
+  logo_uri: z.string().nullable().optional(),
+  redirect_uris: z.array(z.string()),
+  confidential: z.boolean(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var OAuthClientDetailSchema = z.object({
+  client_id: z.string(),
+  client_name: z.string(),
+  client_uri: z.string().nullable().optional(),
+  logo_uri: z.string().nullable().optional(),
+  redirect_uris: z.array(z.string()),
+  grant_types: z.array(z.string()),
+  scopes: z.array(z.string()),
+  confidential: z.boolean(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var OAuthClientCreateSchema = z.object({
+  client_name: z.string().min(1).max(100),
+  client_uri: z.string().url().optional().or(z.literal("")),
+  redirect_uris: z.array(oauthRedirectUriSchema).min(1),
+  /** `true` = confidential (client_secret); `false` = public (PKCE required). */
+  confidential: z.boolean().default(true)
+});
+var OAuthClientUpdateSchema = z.object({
+  client_name: z.string().min(1).max(100),
+  client_uri: z.string().url().optional().or(z.literal("")),
+  redirect_uris: z.array(oauthRedirectUriSchema).min(1)
+});
+var OAuthClientCreateResponseSchema = z.object({
+  client_id: z.string(),
+  client_secret: z.string().optional(),
+  confidential: z.boolean(),
+  client_name: z.string(),
+  client_uri: z.string().nullable().optional(),
+  redirect_uris: z.array(z.string()),
+  created_at: z.string()
+});
+var OAuthClientSecretRotateResponseSchema = z.object({
+  client_id: z.string(),
+  client_secret: z.string()
+});
+var OAuthAuthorizeQuerySchema = z.object({
+  response_type: z.literal("code"),
+  client_id: z.string().min(1),
+  redirect_uri: oauthRedirectUriSchema,
+  scope: z.string().optional(),
+  state: z.string().optional(),
+  code_challenge: z.string().min(43).max(128).optional(),
+  code_challenge_method: z.literal("S256").optional()
+});
+var OAuthConsentBodySchema = z.object({
+  action: z.enum(["allow", "deny"]),
+  client_id: z.string().min(1),
+  redirect_uri: oauthRedirectUriSchema,
+  scope: z.string().optional(),
+  state: z.string().optional(),
+  trust: z.boolean().optional(),
+  code_challenge: z.string().min(43).max(128).optional(),
+  code_challenge_method: z.literal("S256").optional()
+});
+var OAuthAuthorizationCodeRowSchema = z.object({
+  code: z.string(),
+  client_id: z.string(),
+  user_id: z.number(),
+  redirect_uri: z.string(),
+  scope: z.string().nullable().optional(),
+  code_challenge: z.string().nullable().optional(),
+  code_challenge_method: z.string().nullable().optional(),
+  expires_at: z.string(),
+  used: z.boolean(),
+  created_at: z.string()
+});
+
+// src/core/schema/OAuthClientSchema.ts
+import { z as z2 } from "zod";
+var OAuthUserCredentialsSchema = z2.object({
+  user_id: z2.number(),
+  provider_refresh_token: z2.string().nullable().optional(),
+  provider_session_token: z2.string().nullable().optional(),
+  updated_at: z2.string()
+});
+var OAuthRefreshTokenSchema = z2.object({
+  id: z2.number(),
+  refresh_token: z2.string(),
+  client_id: z2.string(),
+  user_id: z2.number(),
+  expires_at: z2.string(),
+  revoked: z2.boolean(),
+  created_at: z2.string()
+});
+var OAuthTokenResponseSchema = z2.object({
+  access_token: z2.string(),
+  token_type: z2.literal("Bearer"),
+  expires_in: z2.number(),
+  refresh_token: z2.string().optional(),
+  scope: z2.string().optional()
+});
+
+// src/core/schema/OAuthUserInfoSchema.ts
+import { z as z3 } from "zod";
+var OAuthUserInfoResponseSchema = z3.object({
+  sub: z3.string(),
+  email: z3.string().email(),
+  name: z3.string(),
+  roles: z3.array(z3.string()).optional()
+});
+var OAuthUserInfoErrorResponseSchema = z3.object({
+  error: z3.literal("invalid_token"),
+  error_id: z3.string().optional()
+});
+
+// src/core/schema/OAuthTokenSchema.ts
+import { z as z4 } from "zod";
+var OAuthTokenAuthorizationCodeSchema = z4.object({
+  grant_type: z4.literal("authorization_code"),
+  code: z4.string().min(1),
+  redirect_uri: z4.string().min(1),
+  client_id: z4.string().min(1),
+  client_secret: z4.string().min(1).optional(),
+  code_verifier: z4.string().min(43).max(128).optional()
+});
+var OAuthTokenRefreshSchema = z4.object({
+  grant_type: z4.literal("refresh_token"),
+  refresh_token: z4.string().min(1),
+  client_id: z4.string().min(1),
+  client_secret: z4.string().min(1).optional()
+});
+var OAuthTokenRequestSchema = z4.discriminatedUnion("grant_type", [
+  OAuthTokenAuthorizationCodeSchema,
+  OAuthTokenRefreshSchema
+]);
+var OAuthTokenErrorResponseSchema = z4.object({
+  error: z4.string(),
+  error_id: z4.string().optional(),
+  error_description: z4.string().optional()
+});
+var OAuthTokenRevokeSchema = z4.object({
+  token: z4.string().min(1),
+  token_type_hint: z4.enum(["access_token", "refresh_token"]).optional(),
+  client_id: z4.string().min(1),
+  client_secret: z4.string().min(1).optional()
+});
+
+// src/core/config.ts
+var OAuthRfcCodes = {
+  INVALID_REQUEST: "invalid_request",
+  INVALID_CLIENT: "invalid_client",
+  INVALID_GRANT: "invalid_grant",
+  INVALID_TOKEN: "invalid_token",
+  UNAUTHORIZED_CLIENT: "unauthorized_client",
+  INVALID_SCOPE: "invalid_scope",
+  ACCESS_DENIED: "access_denied",
+  UNSUPPORTED_RESPONSE_TYPE: "unsupported_response_type",
+  UNSUPPORTED_GRANT_TYPE: "unsupported_grant_type",
+  OAUTH_ERROR: "oauth_error"
+};
+
+// src/core/utils/pkce.ts
+var PKCE_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+function generatePkceVerifier(length = 64) {
+  const size = Math.min(128, Math.max(43, length));
+  const values = new Uint8Array(size);
+  crypto.getRandomValues(values);
+  let result = "";
+  for (let i = 0; i < size; i++) {
+    result += PKCE_CHARSET[values[i] % PKCE_CHARSET.length];
+  }
+  return result;
+}
+function base64UrlEncode(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function computePkceS256Challenge(verifier) {
+  const data = new TextEncoder().encode(verifier);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return base64UrlEncode(digest);
+}
+function randomOAuthState() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/server/utils/OAuthWrapperError.ts
+import { ExecutorError } from "@qlover/fe-corekit";
+var OAuthWrapperError = class extends ExecutorError {
+  constructor(id, status, cause) {
+    super(id, cause);
+    this.status = status;
+  }
+  name = "OAuthWrapperError";
+};
+
+// src/server/utils/pkce.ts
+import { createHash, timingSafeEqual } from "crypto";
+var PKCE_VERIFIER_MIN = 43;
+var PKCE_VERIFIER_MAX = 128;
+var UNRESERVED = /^[A-Za-z0-9\-._~]+$/;
+function isValidCodeVerifier(verifier) {
+  const len = verifier.length;
+  if (len < PKCE_VERIFIER_MIN || len > PKCE_VERIFIER_MAX) {
+    return false;
+  }
+  return UNRESERVED.test(verifier);
+}
+function isValidCodeChallenge(challenge) {
+  if (challenge.length < PKCE_VERIFIER_MIN || challenge.length > PKCE_VERIFIER_MAX) {
+    return false;
+  }
+  return UNRESERVED.test(challenge);
+}
+function computeS256CodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function verifyPkceS256(verifier, challenge) {
+  if (!isValidCodeVerifier(verifier) || !isValidCodeChallenge(challenge)) {
+    return false;
+  }
+  const computed = computeS256CodeChallenge(verifier);
+  try {
+    return timingSafeEqual(Buffer.from(computed), Buffer.from(challenge));
+  } catch {
+    return false;
+  }
+}
+
+// src/server/services/OAuthTokenService.ts
+function hashOpaqueToken(token) {
+  return createHash2("sha256").update(token).digest("hex");
+}
+var OAuthTokenService = class _OAuthTokenService {
+  constructor(tokenEncryption, userAdapter, oauthRepo) {
+    this.tokenEncryption = tokenEncryption;
+    this.userAdapter = userAdapter;
+    this.oauthRepo = oauthRepo;
+  }
+  static REFRESH_TOKEN_TTL_MS = 90 * 24 * 60 * 60 * 1e3;
+  /**
+   * @override
+   */
+  async exchangeToken(rawFields) {
+    let request;
+    try {
+      request = OAuthTokenRequestSchema.parse(rawFields);
+    } catch {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_REQUEST,
+        400,
+        "Malformed token request"
+      );
+    }
+    let client;
+    try {
+      client = await this.oauthRepo.verifyClientCredentials(
+        request.client_id,
+        request.client_secret
+      );
+    } catch {
+      throw new OAuthWrapperError(OAuthRfcCodes.INVALID_CLIENT, 401);
+    }
+    if (!client.grant_types.includes(request.grant_type)) {
+      throw new OAuthWrapperError(OAuthRfcCodes.UNSUPPORTED_GRANT_TYPE, 400);
+    }
+    if (request.grant_type === "authorization_code") {
+      return await this.exchangeAuthorizationCode(request, client.client_id);
+    }
+    return await this.exchangeRefreshToken(request, client.client_id);
+  }
+  async exchangeAuthorizationCode(request, verifiedClientId) {
+    const authCode = await this.oauthRepo.consumeCode(request.code);
+    if (!authCode) {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_GRANT,
+        400,
+        "Authorization code is invalid, expired, or already used"
+      );
+    }
+    if (authCode.client_id !== verifiedClientId) {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_GRANT,
+        400,
+        "client_id mismatch"
+      );
+    }
+    if (authCode.redirect_uri !== request.redirect_uri) {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_GRANT,
+        400,
+        "redirect_uri mismatch"
+      );
+    }
+    this.assertPkceForAuthorizationCode(request, authCode);
+    const providerTokens = await this.fetchProviderAccessToken(
+      authCode.user_id
+    );
+    const middlewareRefresh = await this.issueMiddlewareRefreshToken(
+      authCode.client_id,
+      authCode.user_id
+    );
+    return {
+      access_token: providerTokens.access_token,
+      token_type: "Bearer",
+      expires_in: providerTokens.expires_in,
+      refresh_token: middlewareRefresh,
+      scope: authCode.scope ?? void 0
+    };
+  }
+  assertPkceForAuthorizationCode(request, authCode) {
+    const storedChallenge = authCode.code_challenge?.trim();
+    if (storedChallenge) {
+      const verifier = request.code_verifier?.trim();
+      if (!verifier) {
+        throw new OAuthWrapperError(
+          OAuthRfcCodes.INVALID_GRANT,
+          400,
+          "code_verifier is required"
+        );
+      }
+      if (authCode.code_challenge_method !== "S256") {
+        throw new OAuthWrapperError(
+          OAuthRfcCodes.INVALID_GRANT,
+          400,
+          "Unsupported PKCE method"
+        );
+      }
+      if (!verifyPkceS256(verifier, storedChallenge)) {
+        throw new OAuthWrapperError(
+          OAuthRfcCodes.INVALID_GRANT,
+          400,
+          "code_verifier mismatch"
+        );
+      }
+      return;
+    }
+    if (!request.client_secret?.trim()) {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_CLIENT,
+        401,
+        "client_secret is required when PKCE is not used"
+      );
+    }
+  }
+  async exchangeRefreshToken(request, verifiedClientId) {
+    const tokenHash = hashOpaqueToken(request.refresh_token);
+    const stored = await this.oauthRepo.findByTokenHash(tokenHash);
+    if (!stored || stored.revoked || stored.client_id !== verifiedClientId || new Date(stored.expires_at) <= /* @__PURE__ */ new Date()) {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_GRANT,
+        400,
+        "Refresh token is invalid"
+      );
+    }
+    const providerTokens = await this.fetchProviderAccessToken(stored.user_id);
+    await this.oauthRepo.revokeByTokenHash(tokenHash);
+    const middlewareRefresh = await this.issueMiddlewareRefreshToken(
+      stored.client_id,
+      stored.user_id
+    );
+    return {
+      access_token: providerTokens.access_token,
+      token_type: "Bearer",
+      expires_in: providerTokens.expires_in,
+      refresh_token: middlewareRefresh
+    };
+  }
+  async fetchProviderAccessToken(userId) {
+    const credentials = await this.oauthRepo.getUserCredentials(userId);
+    const sessionToken = credentials?.provider_session_token?.trim();
+    if (!sessionToken) {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_GRANT,
+        400,
+        "User credentials expired. Re-authorization required."
+      );
+    }
+    try {
+      const access = await this.userAdapter.exchangeAccessToken({
+        token: sessionToken
+      });
+      if (access.refresh_token) {
+        await this.oauthRepo.upsertUserCredentials(userId, {
+          provider_refresh_token: this.tokenEncryption.encrypt(
+            access.refresh_token
+          )
+        });
+      }
+      return {
+        access_token: access.access_token,
+        expires_in: access.expires_in
+      };
+    } catch {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_GRANT,
+        400,
+        "Failed to obtain access token from user provider"
+      );
+    }
+  }
+  async issueMiddlewareRefreshToken(clientId, userId) {
+    const plain = randomBytes(32).toString("base64url");
+    const expiresAt = new Date(
+      Date.now() + _OAuthTokenService.REFRESH_TOKEN_TTL_MS
+    ).toISOString();
+    await this.oauthRepo.createRefreshToken({
+      refresh_token: hashOpaqueToken(plain),
+      client_id: clientId,
+      user_id: userId,
+      expires_at: expiresAt
+    });
+    return plain;
+  }
+  /**
+   * @override
+   * RFC 7009 — revoke middleware refresh tokens. Idempotent: unknown tokens are ignored.
+   */
+  async revokeToken(rawFields) {
+    let request;
+    try {
+      request = OAuthTokenRevokeSchema.parse(rawFields);
+    } catch {
+      throw new OAuthWrapperError(
+        OAuthRfcCodes.INVALID_REQUEST,
+        400,
+        "Malformed revocation request"
+      );
+    }
+    try {
+      await this.oauthRepo.verifyClientCredentials(
+        request.client_id,
+        request.client_secret
+      );
+    } catch {
+      throw new OAuthWrapperError(OAuthRfcCodes.INVALID_CLIENT, 401);
+    }
+    if (request.token_type_hint && request.token_type_hint !== "refresh_token") {
+      return;
+    }
+    const tokenHash = hashOpaqueToken(request.token);
+    const stored = await this.oauthRepo.findByTokenHash(tokenHash);
+    if (!stored || stored.client_id !== request.client_id) {
+      return;
+    }
+    await this.oauthRepo.revokeByTokenHash(tokenHash);
+  }
+};
+
+// src/server/services/OAuthWrapperService.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { ExecutorError as ExecutorError2 } from "@qlover/fe-corekit";
+
+// src/server/utils/authorizeUtil.ts
+function validatePkceParams(parsed, confidential) {
+  const hasChallenge = Boolean(parsed.code_challenge?.trim());
+  const hasMethod = Boolean(parsed.code_challenge_method);
+  if (!confidential) {
+    if (!hasChallenge || parsed.code_challenge_method !== "S256") {
+      return {
+        errorKey: OAuthRfcCodes.INVALID_REQUEST,
+        message: "Public clients must send code_challenge and code_challenge_method=S256."
+      };
+    }
+    if (!isValidCodeChallenge(parsed.code_challenge)) {
+      return {
+        errorKey: OAuthRfcCodes.INVALID_REQUEST,
+        message: "Invalid code_challenge."
+      };
+    }
+    return null;
+  }
+  if (hasChallenge !== hasMethod) {
+    return {
+      errorKey: OAuthRfcCodes.INVALID_REQUEST,
+      message: "code_challenge and code_challenge_method must be sent together."
+    };
+  }
+  if (hasChallenge) {
+    if (parsed.code_challenge_method !== "S256") {
+      return {
+        errorKey: OAuthRfcCodes.INVALID_REQUEST,
+        message: "Only code_challenge_method=S256 is supported."
+      };
+    }
+    if (!isValidCodeChallenge(parsed.code_challenge)) {
+      return {
+        errorKey: OAuthRfcCodes.INVALID_REQUEST,
+        message: "Invalid code_challenge."
+      };
+    }
+  }
+  return null;
+}
+function normalizeQuery(raw) {
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (Array.isArray(value)) {
+      result[key] = value[0];
+    } else {
+      result[key] = value;
+    }
+  }
+  if (!result.response_type) {
+    result.response_type = "code";
+  }
+  return result;
+}
+function isRedirectUriAllowed(redirectUri, client) {
+  return client.redirect_uris.includes(redirectUri);
+}
+
+// src/server/utils/oauthRedirectUtils.ts
+function buildOAuthRedirectUrl(redirectUri, params) {
+  const url = new URL(redirectUri);
+  for (const [key, value] of Object.entries(params)) {
+    if (value != null && value !== "") {
+      url.searchParams.set(key, value);
+    }
+  }
+  return url.toString();
+}
+function parseScopeList(scope) {
+  if (!scope?.trim()) {
+    return ["openid", "profile", "email"];
+  }
+  return scope.trim().split(/\s+/).filter(Boolean);
+}
+
+// src/server/services/OAuthWrapperService.ts
+var AUTH_CODE_TTL_MS = 5 * 60 * 1e3;
+var OAuthWrapperService = class {
+  constructor(oauthSession, userAdapter, tokenService, oauthRepo) {
+    this.oauthSession = oauthSession;
+    this.userAdapter = userAdapter;
+    this.tokenService = tokenService;
+    this.oauthRepo = oauthRepo;
+  }
+  /**
+   * @override
+   */
+  getOAuthSession() {
+    return this.oauthSession;
+  }
+  /**
+   * @override
+   */
+  getOAuthAdapter() {
+    return this.userAdapter;
+  }
+  /**
+   * @override
+   */
+  getOAuthTokenService() {
+    return this.tokenService;
+  }
+  /**
+   * @override
+   */
+  getOAuthRepo() {
+    return this.oauthRepo;
+  }
+  isQuery(query) {
+    return OAuthAuthorizeQuerySchema.safeParse(query).success;
+  }
+  isValidateConsent(value) {
+    return OAuthConsentBodySchema.safeParse(value).success;
+  }
+  /**
+   * @override
+   */
+  async resolveAuthorizePage(rawQuery) {
+    const query = normalizeQuery(rawQuery);
+    if (!this.isQuery(query)) {
+      return {
+        ok: false,
+        error: {
+          errorKey: OAuthRfcCodes.INVALID_REQUEST,
+          message: "Missing or invalid authorization request parameters."
+        }
+      };
+    }
+    if (query.response_type !== "code") {
+      return {
+        ok: false,
+        error: {
+          errorKey: OAuthRfcCodes.UNSUPPORTED_RESPONSE_TYPE,
+          message: "Only response_type=code is supported."
+        }
+      };
+    }
+    const client = await this.oauthRepo.findClientById(query.client_id);
+    if (!client) {
+      return {
+        ok: false,
+        error: {
+          errorKey: OAuthRfcCodes.UNAUTHORIZED_CLIENT,
+          message: "Unknown client_id."
+        }
+      };
+    }
+    if (!isRedirectUriAllowed(query.redirect_uri, client)) {
+      return {
+        ok: false,
+        error: {
+          errorKey: OAuthRfcCodes.UNAUTHORIZED_CLIENT,
+          message: "redirect_uri is not registered for this client."
+        }
+      };
+    }
+    const requestedScopes = parseScopeList(query.scope);
+    const invalidScope = requestedScopes.find(
+      (scope) => !client.scopes.includes(scope)
+    );
+    if (invalidScope) {
+      return {
+        ok: false,
+        error: {
+          errorKey: OAuthRfcCodes.INVALID_SCOPE,
+          message: `Scope "${invalidScope}" is not allowed for this client.`
+        }
+      };
+    }
+    const pkceError = validatePkceParams(query, client.confidential);
+    if (pkceError) {
+      return { ok: false, error: pkceError };
+    }
+    return {
+      ok: true,
+      data: {
+        clientId: client.client_id,
+        clientName: client.client_name,
+        clientUri: client.client_uri ?? null,
+        logoUri: client.logo_uri ?? null,
+        redirectUri: query.redirect_uri,
+        scopes: requestedScopes,
+        state: query.state,
+        responseType: "code",
+        codeChallenge: query.code_challenge,
+        codeChallengeMethod: query.code_challenge_method,
+        confidential: client.confidential
+      }
+    };
+  }
+  /**
+   * @override
+   */
+  async processConsent(requestBody) {
+    if (!this.isValidateConsent(requestBody)) {
+      throw new ExecutorError2(
+        OAuthRfcCodes.INVALID_REQUEST,
+        "Invalid consent request body"
+      );
+    }
+    const session = await this.oauthSession.getSession();
+    if (!session) {
+      throw new ExecutorError2(
+        OAuthRfcCodes.ACCESS_DENIED,
+        "User session expired. Please sign in again."
+      );
+    }
+    const pageResult = await this.resolveAuthorizePage({
+      response_type: "code",
+      client_id: requestBody.client_id,
+      redirect_uri: requestBody.redirect_uri,
+      scope: requestBody.scope,
+      state: requestBody.state,
+      code_challenge: requestBody.code_challenge,
+      code_challenge_method: requestBody.code_challenge_method
+    });
+    if (!pageResult.ok) {
+      throw new ExecutorError2(
+        pageResult.error.errorKey,
+        pageResult.error.message
+      );
+    }
+    const { data } = pageResult;
+    if (requestBody.action === "deny") {
+      return {
+        redirectUrl: buildOAuthRedirectUrl(data.redirectUri, {
+          error: OAuthRfcCodes.ACCESS_DENIED,
+          error_description: "The resource owner denied the request",
+          state: data.state
+        })
+      };
+    }
+    const code = randomBytes2(32).toString("base64url");
+    const expiresAt = new Date(Date.now() + AUTH_CODE_TTL_MS).toISOString();
+    await this.oauthRepo.create({
+      code,
+      client_id: data.clientId,
+      user_id: session.userId,
+      redirect_uri: data.redirectUri,
+      scope: data.scopes.join(" ") || null,
+      code_challenge: data.codeChallenge ?? null,
+      code_challenge_method: data.codeChallengeMethod ?? null,
+      expires_at: expiresAt
+    });
+    void requestBody.trust;
+    return {
+      redirectUrl: buildOAuthRedirectUrl(data.redirectUri, {
+        code,
+        state: data.state
+      })
+    };
+  }
+  /**
+   * @override
+   */
+  async exchangeToken(rawFields) {
+    return await this.tokenService.exchangeToken(rawFields);
+  }
+  /**
+   * @override
+   */
+  async revokeToken(rawFields) {
+    return await this.tokenService.revokeToken(rawFields);
+  }
+  /**
+   * @override
+   */
+  async logoutUser(userId) {
+    await this.oauthRepo.revokeRefreshTokensByUserId(userId);
+    await this.oauthRepo.upsertUserCredentials(userId, {
+      provider_refresh_token: null,
+      provider_session_token: null
+    });
+    await this.oauthSession.clearSession();
+  }
+  /**
+   * @override
+   */
+  async getUserInfo(accessToken) {
+    try {
+      const profile = await this.userAdapter.getUserInfoByAccessToken(accessToken);
+      return this.toUserInfoResponse(profile);
+    } catch {
+      throw new OAuthWrapperError(OAuthRfcCodes.INVALID_TOKEN, 401);
+    }
+  }
+  toUserInfoResponse(profile) {
+    const sub = String(profile.id);
+    if (!sub || sub === "NaN") {
+      throw new OAuthWrapperError(OAuthRfcCodes.INVALID_TOKEN, 401);
+    }
+    const email = profile.email?.trim();
+    if (!email) {
+      throw new OAuthWrapperError(OAuthRfcCodes.INVALID_TOKEN, 401);
+    }
+    const nameFromParts = [profile.first_name, profile.last_name].filter(Boolean).join(" ");
+    const name = profile.name?.trim() || nameFromParts || email;
+    return {
+      sub,
+      email,
+      name,
+      ...profile.roles?.length ? { roles: profile.roles } : {}
+    };
+  }
+};
+
+// src/server/utils/clientSecretHash.ts
+import { randomBytes as randomBytes3, scrypt, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { promisify } from "util";
+var scryptAsync = promisify(scrypt);
+var PREFIX = "scrypt";
+var KEY_LEN = 64;
+async function hashClientSecret(secret) {
+  const salt = randomBytes3(16);
+  const derived = await scryptAsync(secret, salt, KEY_LEN);
+  return `${PREFIX}$${salt.toString("base64")}$${derived.toString("base64")}`;
+}
+async function verifyClientSecret(secret, storedHash) {
+  const parts = storedHash.split("$");
+  if (parts.length !== 3 || parts[0] !== PREFIX) {
+    return false;
+  }
+  const salt = Buffer.from(parts[1], "base64");
+  const expected = Buffer.from(parts[2], "base64");
+  const derived = await scryptAsync(secret, salt, expected.length);
+  if (derived.length !== expected.length) {
+    return false;
+  }
+  return timingSafeEqual2(derived, expected);
+}
+export {
+  OAuthAuthorizationCodeRowSchema,
+  OAuthAuthorizeQuerySchema,
+  OAuthClientCreateResponseSchema,
+  OAuthClientCreateSchema,
+  OAuthClientDetailSchema,
+  OAuthClientListItemSchema,
+  OAuthClientRowSchema,
+  OAuthClientSecretRotateResponseSchema,
+  OAuthClientUpdateSchema,
+  OAuthClientsService,
+  OAuthConsentBodySchema,
+  OAuthRefreshTokenSchema,
+  OAuthRfcCodes,
+  OAuthTokenAuthorizationCodeSchema,
+  OAuthTokenErrorResponseSchema,
+  OAuthTokenRefreshSchema,
+  OAuthTokenRequestSchema,
+  OAuthTokenResponseSchema,
+  OAuthTokenRevokeSchema,
+  OAuthTokenService,
+  OAuthUserCredentialsSchema,
+  OAuthUserInfoErrorResponseSchema,
+  OAuthUserInfoResponseSchema,
+  OAuthWrapperError,
+  OAuthWrapperService,
+  buildOAuthRedirectUrl,
+  computePkceS256Challenge,
+  computeS256CodeChallenge,
+  generatePkceVerifier,
+  hashClientSecret,
+  isOAuthRedirectUri,
+  isRedirectUriAllowed,
+  isValidCodeChallenge,
+  isValidCodeVerifier,
+  normalizeQuery,
+  parseScopeList,
+  randomOAuthState,
+  validatePkceParams,
+  verifyClientSecret,
+  verifyPkceS256
+};