@kabyeon/nexusjs 0.6.5

package/dist/auth/index.js

@@ -0,0 +1,730 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+// src/auth/auth.ts
+import { betterAuth } from "better-auth";
+function createAuth(config = {}) {
+  const secret = config.secret ?? process.env["BETTER_AUTH_SECRET"];
+  const baseURL = config.baseUrl ?? process.env["BETTER_AUTH_URL"];
+  if (!secret) {
+    throw new Error("[nexus/auth] BETTER_AUTH_SECRET is required. " + "Generate one with `openssl rand -base64 32` and add it to .env.");
+  }
+  if (!baseURL) {
+    throw new Error("[nexus/auth] BETTER_AUTH_URL is required (e.g. http://localhost:3000).");
+  }
+  const plugins = [];
+  if (config.jwt?.enabled) {
+    const { jwt } = __require("better-auth/plugins");
+    plugins.push(jwt({
+      jwks: {
+        path: config.jwt.jwksPath ?? "/api/auth/jwks"
+      },
+      issuer: config.jwt.issuer ?? baseURL,
+      audience: config.jwt.audience ?? baseURL,
+      expiresIn: config.jwt.expiresIn ?? 60 * 15
+    }));
+  }
+  if (config.passkey?.enabled) {
+    const { passkey } = __require("better-auth/plugins");
+    plugins.push(passkey({
+      rpName: config.passkey.rpName,
+      rpID: config.passkey.rpId,
+      origin: config.passkey.origin
+    }));
+  }
+  return betterAuth({
+    secret,
+    baseURL,
+    basePath: config.basePath ?? "/api/auth",
+    emailAndPassword: {
+      enabled: config.emailAndPassword?.enabled ?? true,
+      requireEmailVerification: config.emailAndPassword?.requireEmailVerification ?? false,
+      minPasswordLength: config.emailAndPassword?.minPasswordLength ?? 8,
+      maxPasswordLength: config.emailAndPassword?.maxPasswordLength ?? 128
+    },
+    session: {
+      expiresIn: config.sessionExpiresInSeconds ?? 60 * 60 * 24 * 7
+    },
+    socialProviders: config.socialProviders,
+    advanced: {
+      cookies: {
+        sessionToken: {
+          attributes: {
+            sameSite: config.cookieSameSite ?? "lax",
+            secure: config.cookieSecure ?? process.env["NODE_ENV"] === "production",
+            ...config.cookieDomain ? { domain: config.cookieDomain } : {}
+          }
+        }
+      },
+      crossSubDomainCookies: config.crossSubDomainCookies?.enabled ? {
+        enabled: true,
+        domain: config.crossSubDomainCookies.domain
+      } : undefined
+    },
+    plugins
+  });
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/auth/auth.service.ts
+class AuthService {
+  config;
+  static TOKEN = Symbol.for("nexus:AuthService");
+  instance;
+  #sessionService = null;
+  constructor(config) {
+    this.config = config;
+    this.instance = createAuth(this.config);
+  }
+  bindSession(sessionService) {
+    this.#sessionService = sessionService;
+    return this;
+  }
+  hasSessionBinding() {
+    return this.#sessionService !== null;
+  }
+  async getSession(input) {
+    if (this.#sessionService) {
+      const cookieName = this.#sessionService.cookieName;
+      if (cookieName) {
+        const cookieHeader = input.headers.get("cookie") ?? "";
+        const value = parseCookie(cookieHeader, cookieName);
+        if (value) {
+          const decoded = this.#sessionService.decodeCookie(value);
+          if (decoded?.userId) {
+            const fromBetterAuth = await this.instance.api.getSession({
+              headers: input.headers
+            });
+            if (fromBetterAuth?.user) {
+              return fromBetterAuth;
+            }
+          }
+        }
+      }
+    }
+    const result = await this.instance.api.getSession({
+      headers: input.headers
+    });
+    return result;
+  }
+  async getRawSession(input) {
+    if (!this.#sessionService)
+      return null;
+    const cookieName = this.#sessionService.cookieName;
+    if (!cookieName)
+      return null;
+    const cookieHeader = input.headers.get("cookie") ?? "";
+    const value = parseCookie(cookieHeader, cookieName);
+    if (!value)
+      return null;
+    return this.#sessionService.decodeCookie(value);
+  }
+  async signUp(input) {
+    return this.instance.api.signUpEmail({
+      body: input
+    });
+  }
+  async signIn(input) {
+    return this.instance.api.signInEmail({
+      body: input
+    });
+  }
+  async signOut(input) {
+    return this.instance.api.signOut({
+      headers: input.headers
+    });
+  }
+  async getOAuthUrl(input) {
+    return this.instance.api.signInSocial({
+      body: input
+    });
+  }
+  async handleOAuthCallback(input) {
+    return this.instance.api.signInSocial({
+      headers: input.headers,
+      query: input.query,
+      body: {}
+    });
+  }
+  async issueJwt(input) {
+    const api = this.instance.api;
+    if (!api.signJWT) {
+      throw new Error("[nexus/auth] JWT plugin not enabled. Set `auth.jwt.enabled: true` in nx.config.ts.");
+    }
+    return api.signJWT({ body: { userId: input.userId } });
+  }
+  async registerPasskey(input) {
+    const api = this.instance.api;
+    if (!api.passkey) {
+      throw new Error("[nexus/auth] Passkey plugin not enabled. Set `auth.passkey.enabled: true` in nx.config.ts.");
+    }
+    return api.passkey.register({ headers: input.headers });
+  }
+  async authenticatePasskey(input) {
+    const api = this.instance.api;
+    if (!api.passkey) {
+      throw new Error("[nexus/auth] Passkey plugin not enabled.");
+    }
+    return api.passkey.authenticate({ headers: input.headers, body: input.body });
+  }
+  redirect(to, status = 302) {
+    return new Response(null, { status, headers: { Location: to } });
+  }
+  toContextVariables(session) {
+    if (!session)
+      return { user: null, session: null };
+    return { user: session.user, session: session.session };
+  }
+}
+AuthService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("AUTH_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof AuthConfig === "undefined" ? Object : AuthConfig
+  ])
+], AuthService);
+function parseCookie(cookieHeader, name) {
+  if (!cookieHeader)
+    return null;
+  const parts = cookieHeader.split(";");
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    if (eq < 0)
+      continue;
+    const k = part.slice(0, eq).trim();
+    if (k === name) {
+      return decodeURIComponent(part.slice(eq + 1).trim());
+    }
+  }
+  return null;
+}
+// src/auth/auth.controller.ts
+class AuthController {
+  auth;
+  constructor(auth) {
+    this.auth = auth;
+  }
+  async session(c) {
+    const session = await this.auth.getSession({
+      headers: c.req.raw.headers
+    });
+    return c.json(session ?? { user: null, session: null });
+  }
+  async signUpEmail(c, body) {
+    const result = await this.auth.signUp(body);
+    return c.json(result, 201);
+  }
+  async signInEmail(c, body) {
+    const result = await this.auth.signIn(body);
+    return c.json(result);
+  }
+  async signOut(c, _res) {
+    await this.auth.signOut({ headers: c.req.raw.headers });
+    return c.json({ ok: true });
+  }
+  async socialSignIn(c, _body) {
+    const provider = c.req.param("provider") ?? "";
+    const callbackURL = c.req.query("callbackURL") ?? "/";
+    const result = await this.auth.getOAuthUrl({ provider, callbackURL });
+    return c.json(result);
+  }
+  async oauthCallback(c) {
+    const result = await this.auth.handleOAuthCallback({
+      headers: c.req.raw.headers,
+      query: c.req.query()
+    });
+    return c.json(result);
+  }
+  async issueJwt(c) {
+    const session = await this.auth.getSession({
+      headers: c.req.raw.headers
+    });
+    if (!session)
+      return c.json({ error: "Unauthorized" }, 401);
+    const token = await this.auth.issueJwt({ userId: session.user.id });
+    return c.json(token);
+  }
+  async passkeyRegister(c) {
+    const result = await this.auth.registerPasskey({
+      headers: c.req.raw.headers
+    });
+    return c.json(result);
+  }
+  async passkeyAuthenticate(c, body) {
+    const result = await this.auth.authenticatePasskey({
+      headers: c.req.raw.headers,
+      body
+    });
+    return c.json(result);
+  }
+}
+__legacyDecorateClassTS([
+  Get("/session"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "session", null);
+__legacyDecorateClassTS([
+  Post("/sign-up/email"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Body()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "signUpEmail", null);
+__legacyDecorateClassTS([
+  Post("/sign-in/email"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Body()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "signInEmail", null);
+__legacyDecorateClassTS([
+  Post("/sign-out"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Res()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    typeof Response === "undefined" ? Object : Response
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "signOut", null);
+__legacyDecorateClassTS([
+  Get("/sign-in/:provider"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Body()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    undefined
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "socialSignIn", null);
+__legacyDecorateClassTS([
+  Get("/callback/:provider"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "oauthCallback", null);
+__legacyDecorateClassTS([
+  Post("/jwt"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "issueJwt", null);
+__legacyDecorateClassTS([
+  Post("/passkey/register"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "passkeyRegister", null);
+__legacyDecorateClassTS([
+  Post("/passkey/authenticate"),
+  __legacyDecorateParamTS(0, Req()),
+  __legacyDecorateParamTS(1, Body()),
+  __legacyMetadataTS("design:type", Function),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Context === "undefined" ? Object : Context,
+    Object
+  ]),
+  __legacyMetadataTS("design:returntype", Promise)
+], AuthController.prototype, "passkeyAuthenticate", null);
+AuthController = __legacyDecorateClassTS([
+  Controller("/api/auth"),
+  __legacyDecorateParamTS(0, Inject(AuthService.TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof AuthService === "undefined" ? Object : AuthService
+  ])
+], AuthController);
+// src/auth/auth.module.ts
+import"reflect-metadata";
+class AuthModule {
+  static forRoot(config) {
+    class ConfiguredAuthModule {
+    }
+    ConfiguredAuthModule = __legacyDecorateClassTS([
+      Module({
+        controllers: [AuthController],
+        providers: [
+          AuthService,
+          { provide: AuthService.TOKEN, useExisting: AuthService },
+          { provide: "AUTH_CONFIG", useValue: config }
+        ],
+        exports: [AuthService, AuthService.TOKEN]
+      })
+    ], ConfiguredAuthModule);
+    Object.defineProperty(ConfiguredAuthModule, "name", {
+      value: "ConfiguredAuthModule"
+    });
+    return ConfiguredAuthModule;
+  }
+}
+AuthModule = __legacyDecorateClassTS([
+  Module({
+    controllers: [AuthController],
+    providers: [
+      AuthService,
+      { provide: AuthService.TOKEN, useExisting: AuthService }
+    ],
+    exports: [AuthService, AuthService.TOKEN]
+  })
+], AuthModule);
+// src/auth/middleware.ts
+function authMiddleware(auth, options = {}) {
+  const {
+    mode = "optional",
+    scope,
+    protectedPaths,
+    ignoredPaths,
+    onUnauthenticated = defaultUnauthenticated,
+    onForbidden = defaultForbidden
+  } = options;
+  const ignored = toMatcher(ignoredPaths);
+  const protected_ = mode === "scoped" ? toMatcher(scope ?? protectedPaths ?? /^\/.+/) : null;
+  return async (c, next) => {
+    const path = c.req.path;
+    if (ignored?.test(path)) {
+      return next();
+    }
+    const session = await auth.api.getSession({
+      headers: c.req.raw.headers
+    });
+    if (session) {
+      c.set("user", session.user);
+      c.set("session", session.session);
+    } else {
+      c.set("user", null);
+      c.set("session", null);
+    }
+    if (mode === "required" || protected_?.test(path) && session === null) {
+      if (session === null)
+        return onUnauthenticated(c);
+    }
+    return next();
+  };
+}
+function toMatcher(input) {
+  if (!input)
+    return null;
+  if (Array.isArray(input)) {
+    return new RegExp(input.map((r) => `(?:${r.source})`).join("|"));
+  }
+  return input;
+}
+function defaultUnauthenticated(c) {
+  return c.json({ error: "Unauthorized", message: "Authentication required." }, 401);
+}
+function defaultForbidden(c) {
+  return c.json({ error: "Forbidden", message: "Insufficient permissions." }, 403);
+}
+function authHandler(auth) {
+  return async (c) => auth.handler(c.req.raw);
+}
+// src/auth/decorators/current-user.ts
+init_params();
+init_constants();
+import"reflect-metadata";
+function CurrentUser(options = {}) {
+  return createParamDecorator(PARAM_TYPES.USER, options);
+}
+
+class UnauthenticatedError extends Error {
+  status = 401;
+  constructor(message = "Authentication required.") {
+    super(message);
+    this.name = "UnauthenticatedError";
+  }
+}
+
+class ForbiddenError extends Error {
+  status = 403;
+  constructor(message = "Insufficient permissions.") {
+    super(message);
+    this.name = "ForbiddenError";
+  }
+}
+export {
+  createAuth,
+  authMiddleware,
+  authHandler,
+  UnauthenticatedError,
+  ForbiddenError,
+  CurrentUser,
+  AuthService,
+  AuthModule,
+  AuthController
+};
+
+//# debugId=1678BD891AB4BB6764756E2164756E21
+//# sourceMappingURL=index.js.map