@adonisjs/auth 10.0.0-next.1 → 10.0.0-next.3

package/build/auth_manager-BMz_OJXq.js

@@ -0,0 +1,129 @@
+import { n as E_UNAUTHORIZED_ACCESS } from "./errors-BQxhZmkE.js";
+import { t as debug_default } from "./debug-Ckko95-M.js";
+import { RuntimeException } from "@adonisjs/core/exceptions";
+import { HttpContextFactory } from "@adonisjs/core/factories/http";
+var Authenticator = class {
+	#config;
+	#guardsCache = {};
+	#authenticationAttemptedViaGuard;
+	#authenticatedViaGuard;
+	#ctx;
+	get defaultGuard() {
+		return this.#config.default;
+	}
+	get authenticatedViaGuard() {
+		return this.#authenticatedViaGuard;
+	}
+	get isAuthenticated() {
+		if (!this.#authenticationAttemptedViaGuard) return false;
+		return this.use(this.#authenticationAttemptedViaGuard).isAuthenticated;
+	}
+	get user() {
+		if (!this.#authenticationAttemptedViaGuard) return;
+		return this.use(this.#authenticationAttemptedViaGuard).user;
+	}
+	get authenticationAttempted() {
+		if (!this.#authenticationAttemptedViaGuard) return false;
+		return this.use(this.#authenticationAttemptedViaGuard).authenticationAttempted;
+	}
+	constructor(ctx, config) {
+		this.#ctx = ctx;
+		this.#config = config;
+		debug_default("creating authenticator. config %O", this.#config);
+	}
+	getUserOrFail() {
+		if (!this.#authenticationAttemptedViaGuard) throw new RuntimeException("Cannot access authenticated user. Please call \"auth.authenticate\" method first.");
+		return this.use(this.#authenticationAttemptedViaGuard).getUserOrFail();
+	}
+	use(guard) {
+		const guardToUse = guard || this.#config.default;
+		const cachedGuard = this.#guardsCache[guardToUse];
+		if (cachedGuard) {
+			debug_default("authenticator: using guard from cache. name: \"%s\"", guardToUse);
+			return cachedGuard;
+		}
+		const guardFactory = this.#config.guards[guardToUse];
+		debug_default("authenticator: creating guard. name: \"%s\"", guardToUse);
+		const guardInstance = guardFactory(this.#ctx);
+		this.#guardsCache[guardToUse] = guardInstance;
+		return guardInstance;
+	}
+	async authenticate() {
+		await this.authenticateUsing();
+		return this.getUserOrFail();
+	}
+	async check() {
+		this.#authenticationAttemptedViaGuard = this.defaultGuard;
+		const isAuthenticated = await this.use().check();
+		if (isAuthenticated) this.#authenticatedViaGuard = this.defaultGuard;
+		return isAuthenticated;
+	}
+	async authenticateUsing(guards, options) {
+		const guardsToUse = guards || [this.defaultGuard];
+		let lastUsedDriver;
+		for (let guardName of guardsToUse) {
+			debug_default("attempting to authenticate using guard \"%s\"", guardName);
+			this.#authenticationAttemptedViaGuard = guardName;
+			const guard = this.use(guardName);
+			lastUsedDriver = guard.driverName;
+			if (await guard.check()) {
+				this.#authenticatedViaGuard = guardName;
+				return this.getUserOrFail();
+			}
+		}
+		throw new E_UNAUTHORIZED_ACCESS("Unauthorized access", {
+			guardDriverName: lastUsedDriver,
+			redirectTo: options?.loginRoute
+		});
+	}
+	async checkUsing(guards = [this.defaultGuard]) {
+		for (const name of guards) {
+			this.#authenticationAttemptedViaGuard = name;
+			if (await this.use(name).check()) {
+				this.#authenticatedViaGuard = name;
+				return true;
+			}
+		}
+		return false;
+	}
+};
+var AuthenticatorClient = class {
+	#config;
+	#guardsCache = {};
+	get defaultGuard() {
+		return this.#config.default;
+	}
+	constructor(config) {
+		this.#config = config;
+		debug_default("creating authenticator client. config %O", this.#config);
+	}
+	use(guard) {
+		const guardToUse = guard || this.#config.default;
+		const cachedGuard = this.#guardsCache[guardToUse];
+		if (cachedGuard) {
+			debug_default("authenticator client: using guard from cache. name: \"%s\"", guardToUse);
+			return cachedGuard;
+		}
+		const guardFactory = this.#config.guards[guardToUse];
+		debug_default("authenticator client: creating guard. name: \"%s\"", guardToUse);
+		const guardInstance = guardFactory(new HttpContextFactory().create());
+		this.#guardsCache[guardToUse] = guardInstance;
+		return guardInstance;
+	}
+};
+var AuthManager = class {
+	get defaultGuard() {
+		return this.config.default;
+	}
+	constructor(config) {
+		this.config = config;
+		this.config = config;
+	}
+	createAuthenticator(ctx) {
+		return new Authenticator(ctx, this.config);
+	}
+	createAuthenticatorClient() {
+		return new AuthenticatorClient(this.config);
+	}
+};
+export { AuthenticatorClient as n, Authenticator as r, AuthManager as t };

package/build/debug-Ckko95-M.js

@@ -0,0 +1,3 @@
+import { debuglog } from "node:util";
+var debug_default = debuglog("adonisjs:auth");
+export { debug_default as t };

package/build/errors-BQxhZmkE.js

@@ -0,0 +1,128 @@
+import "node:module";
+import { Exception } from "@adonisjs/core/exceptions";
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var errors_exports = /* @__PURE__ */ __export({
+	E_INVALID_CREDENTIALS: () => E_INVALID_CREDENTIALS,
+	E_UNAUTHORIZED_ACCESS: () => E_UNAUTHORIZED_ACCESS
+});
+const E_UNAUTHORIZED_ACCESS = class extends Exception {
+	static status = 401;
+	static code = "E_UNAUTHORIZED_ACCESS";
+	redirectTo;
+	identifier = "errors.E_UNAUTHORIZED_ACCESS";
+	guardDriverName;
+	renderers = {
+		session: (message, error, ctx) => {
+			switch (ctx.request.accepts([
+				"html",
+				"application/vnd.api+json",
+				"json"
+			])) {
+				case "html":
+				case null:
+					ctx.session.flashExcept(["_csrf"]);
+					ctx.session.flashErrors({ [error.code]: message });
+					ctx.response.redirect(error.redirectTo || "/", true);
+					break;
+				case "json":
+					ctx.response.status(error.status).send({ errors: [{ message }] });
+					break;
+				case "application/vnd.api+json":
+					ctx.response.status(error.status).send({ errors: [{
+						code: error.code,
+						title: message
+					}] });
+					break;
+			}
+		},
+		basic_auth: (message, _, ctx) => {
+			ctx.response.status(this.status).header("WWW-Authenticate", `Basic realm="Authenticate", charset="UTF-8"`).send(message);
+		},
+		access_tokens: (message, error, ctx) => {
+			switch (ctx.request.accepts([
+				"html",
+				"application/vnd.api+json",
+				"json"
+			])) {
+				case "html":
+				case null:
+					ctx.response.status(error.status).send(message);
+					break;
+				case "json":
+					ctx.response.status(error.status).send({ errors: [{ message }] });
+					break;
+				case "application/vnd.api+json":
+					ctx.response.status(error.status).send({ errors: [{
+						code: error.code,
+						title: message
+					}] });
+					break;
+			}
+		}
+	};
+	getResponseMessage(error, ctx) {
+		if ("i18n" in ctx) return ctx.i18n.t(error.identifier, {}, error.message);
+		return error.message;
+	}
+	constructor(message, options) {
+		super(message, {});
+		this.guardDriverName = options.guardDriverName;
+		this.redirectTo = options.redirectTo;
+	}
+	async handle(error, ctx) {
+		const renderer = this.renderers[this.guardDriverName];
+		const message = error.getResponseMessage(error, ctx);
+		if (!renderer) return ctx.response.status(error.status).send(message);
+		return renderer(message, error, ctx);
+	}
+};
+const E_INVALID_CREDENTIALS = class extends Exception {
+	static status = 400;
+	static code = "E_INVALID_CREDENTIALS";
+	identifier = "errors.E_INVALID_CREDENTIALS";
+	getResponseMessage(error, ctx) {
+		if ("i18n" in ctx) return ctx.i18n.t(error.identifier, {}, error.message);
+		return error.message;
+	}
+	async handle(error, ctx) {
+		const message = this.getResponseMessage(error, ctx);
+		switch (ctx.request.accepts([
+			"html",
+			"application/vnd.api+json",
+			"json"
+		])) {
+			case "html":
+			case null:
+				if (ctx.session) {
+					ctx.session.flashExcept([
+						"_csrf",
+						"_method",
+						"password",
+						"password_confirmation"
+					]);
+					ctx.session.flashErrors({ [error.code]: message });
+					ctx.response.redirect("back", true);
+				} else ctx.response.status(error.status).send(message);
+				break;
+			case "json":
+				ctx.response.status(error.status).send({ errors: [{ message }] });
+				break;
+			case "application/vnd.api+json":
+				ctx.response.status(error.status).send({ errors: [{
+					code: error.code,
+					title: message
+				}] });
+				break;
+		}
+	}
+};
+export { __export as i, E_UNAUTHORIZED_ACCESS as n, errors_exports as r, E_INVALID_CREDENTIALS as t };

package/build/index.js

@@ -1,109 +1,68 @@
-import {
-  AuthManager,
-  Authenticator,
-  AuthenticatorClient
-} from "./chunk-MSPAYMZE.js";
-import "./chunk-2VRS2VHB.js";
-import {
-  errors_exports
-} from "./chunk-S5G5RTJX.js";
-import {
-  __export
-} from "./chunk-UXA4FHST.js";
-
-// configure.ts
+import { r as errors_exports } from "./errors-BQxhZmkE.js";
+import { t as symbols_exports } from "./symbols-Ct253Khf.js";
+import "./debug-Ckko95-M.js";
+import { n as AuthenticatorClient, r as Authenticator, t as AuthManager } from "./auth_manager-BMz_OJXq.js";
 import { presetAuth } from "@adonisjs/presets/auth";
+import { configProvider } from "@adonisjs/core";
 async function configure(command) {
-  const codemods = await command.createCodemods();
-  let guard = command.parsedFlags.guard;
-  if (guard === void 0) {
-    guard = await command.prompt.choice(
-      "Select the auth guard you want to use",
-      [
-        {
-          name: "session",
-          message: "Session"
-        },
-        {
-          name: "access_tokens",
-          message: "Opaque access tokens"
-        },
-        {
-          name: "basic_auth",
-          message: "Basic Auth"
-        }
-      ],
-      {
-        validate(value) {
-          return !!value;
-        }
-      }
-    );
-  }
-  if (!["session", "access_tokens", "basic_auth"].includes(guard)) {
-    command.logger.error(
-      `The selected guard "${guard}" is invalid. Select one from: session, access_tokens, basic_auth`
-    );
-    command.exitCode = 1;
-    return;
-  }
-  await presetAuth(codemods, command.app, {
-    guard,
-    userProvider: "lucid"
-  });
+	const codemods = await command.createCodemods();
+	let guard = command.parsedFlags.guard;
+	if (guard === void 0) guard = await command.prompt.choice("Select the auth guard you want to use", [
+		{
+			name: "session",
+			message: "Session"
+		},
+		{
+			name: "access_tokens",
+			message: "Opaque access tokens"
+		},
+		{
+			name: "basic_auth",
+			message: "Basic Auth"
+		}
+	], { validate(value) {
+		return !!value;
+	} });
+	if (![
+		"session",
+		"access_tokens",
+		"basic_auth"
+	].includes(guard)) {
+		command.logger.error(`The selected guard "${guard}" is invalid. Select one from: session, access_tokens, basic_auth`);
+		command.exitCode = 1;
+		return;
+	}
+	await presetAuth(codemods, command.app, {
+		guard,
+		userProvider: "lucid"
+	});
 }
-
-// src/symbols.ts
-var symbols_exports = {};
-__export(symbols_exports, {
-  GUARD_KNOWN_EVENTS: () => GUARD_KNOWN_EVENTS,
-  PROVIDER_REAL_USER: () => PROVIDER_REAL_USER
-});
-var PROVIDER_REAL_USER = Symbol.for("PROVIDER_REAL_USER");
-var GUARD_KNOWN_EVENTS = Symbol.for("GUARD_KNOWN_EVENTS");
-
-// src/define_config.ts
-import { configProvider } from "@adonisjs/core";
 function defineConfig(config) {
-  return configProvider.create(async (app) => {
-    const guardsList = Object.keys(config.guards);
-    const guards = {};
-    for (let guardName of guardsList) {
-      const guard = config.guards[guardName];
-      if (typeof guard === "function") {
-        guards[guardName] = guard;
-      } else {
-        guards[guardName] = await guard.resolver(guardName, app);
-      }
-    }
-    return {
-      default: config.default,
-      guards
-    };
-  });
+	return configProvider.create(async (app) => {
+		const guardsList = Object.keys(config.guards);
+		const guards = {};
+		for (let guardName of guardsList) {
+			const guard = config.guards[guardName];
+			if (typeof guard === "function") guards[guardName] = guard;
+			else guards[guardName] = await guard.resolver(guardName, app);
+		}
+		return {
+			default: config.default,
+			guards
+		};
+	});
 }
-
-// index.ts
 function isModuleInstalled(moduleName) {
-  try {
-    import.meta.resolve(moduleName);
-    return true;
-  } catch (e) {
-    return false;
-  }
+	try {
+		import.meta.resolve(moduleName);
+		return true;
+	} catch (e) {
+		return false;
+	}
 }
-var withAuthFinder;
+let withAuthFinder;
 if (isModuleInstalled("@adonisjs/lucid")) {
-  const { withAuthFinder: withAuthFinderFn } = await import("./src/mixins/lucid.js");
-  withAuthFinder = withAuthFinderFn;
+	const { withAuthFinder: withAuthFinderFn } = await import("./src/mixins/lucid.js");
+	withAuthFinder = withAuthFinderFn;
 }
-export {
-  AuthManager,
-  Authenticator,
-  AuthenticatorClient,
-  configure,
-  defineConfig,
-  errors_exports as errors,
-  symbols_exports as symbols,
-  withAuthFinder
-};
+export { AuthManager, Authenticator, AuthenticatorClient, configure, defineConfig, errors_exports as errors, symbols_exports as symbols, withAuthFinder };