@adonisjs/auth 9.0.3 → 9.1.1

package/build/modules/basic_auth_guard/define_config.d.ts

@@ -0,0 +1,17 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ConfigProvider } from '@adonisjs/core/types';
+import { BasicAuthGuard } from './guard.js';
+import type { GuardConfigProvider } from '../../src/types.js';
+import { BasicAuthLucidUserProvider } from './user_providers/lucid.js';
+import type { LucidAuthenticatable, BasicAuthUserProviderContract, BasicAuthLucidUserProviderOptions } from './types.js';
+/**
+ * Configures basic auth guard for authentication
+ */
+export declare function basicAuthGuard<UserProvider extends BasicAuthUserProviderContract<unknown>>(config: {
+    provider: UserProvider | ConfigProvider<UserProvider>;
+}): GuardConfigProvider<(ctx: HttpContext) => BasicAuthGuard<UserProvider>>;
+/**
+ * Configures user provider that uses Lucid models to authenticate
+ * users using basic auth
+ */
+export declare function basicAuthUserProvider<Model extends LucidAuthenticatable>(config: BasicAuthLucidUserProviderOptions<Model>): BasicAuthLucidUserProvider<Model>;

package/build/modules/basic_auth_guard/guard.d.ts

@@ -0,0 +1,66 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { EmitterLike } from '@adonisjs/core/types/events';
+import type { AuthClientResponse, GuardContract } from '../../src/types.js';
+import { GUARD_KNOWN_EVENTS, PROVIDER_REAL_USER } from '../../src/symbols.js';
+import type { BasicAuthGuardEvents, BasicAuthUserProviderContract } from './types.js';
+/**
+ * BasicAuth guard implements the HTTP Authentication protocol
+ */
+export declare class BasicAuthGuard<UserProvider extends BasicAuthUserProviderContract<unknown>> implements GuardContract<UserProvider[typeof PROVIDER_REAL_USER]> {
+    #private;
+    /**
+     * Events emitted by the guard
+     */
+    [GUARD_KNOWN_EVENTS]: BasicAuthGuardEvents<UserProvider[typeof PROVIDER_REAL_USER]>;
+    /**
+     * Driver name of the guard
+     */
+    driverName: 'basic_auth';
+    /**
+     * Whether or not the authentication has been attempted
+     * during the current request.
+     */
+    authenticationAttempted: boolean;
+    /**
+     * A boolean to know if the current request has
+     * been authenticated
+     */
+    isAuthenticated: boolean;
+    /**
+     * Reference to an instance of the authenticated user.
+     * The value only exists after calling one of the
+     * following methods.
+     *
+     * - authenticate
+     * - check
+     *
+     * You can use the "getUserOrFail" method to throw an exception if
+     * the request is not authenticated.
+     */
+    user?: UserProvider[typeof PROVIDER_REAL_USER];
+    constructor(name: string, ctx: HttpContext, emitter: EmitterLike<BasicAuthGuardEvents<UserProvider[typeof PROVIDER_REAL_USER]>>, userProvider: UserProvider);
+    /**
+     * Returns an instance of the authenticated user. Or throws
+     * an exception if the request is not authenticated.
+     */
+    getUserOrFail(): UserProvider[typeof PROVIDER_REAL_USER];
+    /**
+     * Authenticates the incoming HTTP request by looking for BasicAuth
+     * credentials inside the request authorization header.
+     *
+     * Returns the authenticated user or throws an exception.
+     */
+    authenticate(): Promise<UserProvider[typeof PROVIDER_REAL_USER]>;
+    /**
+     * Silently attempt to authenticate the user.
+     *
+     * The method returns a boolean indicating if the authentication
+     * succeeded or failed.
+     */
+    check(): Promise<boolean>;
+    /**
+     * Does not support authenticating as client. Instead use "basicAuth"
+     * helper on Japa APIClient
+     */
+    authenticateAsClient(uid: string, password: string): Promise<AuthClientResponse>;
+}

package/build/modules/basic_auth_guard/main.d.ts

@@ -0,0 +1,3 @@
+export { BasicAuthGuard } from './guard.js';
+export { basicAuthGuard, basicAuthUserProvider } from './define_config.js';
+export { BasicAuthLucidUserProvider } from './user_providers/lucid.js';

package/build/modules/basic_auth_guard/main.js

@@ -0,0 +1,236 @@
+import {
+  E_UNAUTHORIZED_ACCESS
+} from "../../chunk-UGHJLKDI.js";
+import "../../chunk-CZCFTIBB.js";
+
+// modules/basic_auth_guard/guard.ts
+import auth from "basic-auth";
+import { base64 } from "@adonisjs/core/helpers";
+var BasicAuthGuard = class {
+  /**
+   * A unique name for the guard.
+   */
+  #name;
+  /**
+   * Reference to the current HTTP context
+   */
+  #ctx;
+  /**
+   * Provider to lookup user details
+   */
+  #userProvider;
+  /**
+   * Emitter to emit events
+   */
+  #emitter;
+  /**
+   * Driver name of the guard
+   */
+  driverName = "basic_auth";
+  /**
+   * Whether or not the authentication has been attempted
+   * during the current request.
+   */
+  authenticationAttempted = false;
+  /**
+   * A boolean to know if the current request has
+   * been authenticated
+   */
+  isAuthenticated = false;
+  /**
+   * Reference to an instance of the authenticated user.
+   * The value only exists after calling one of the
+   * following methods.
+   *
+   * - authenticate
+   * - check
+   *
+   * You can use the "getUserOrFail" method to throw an exception if
+   * the request is not authenticated.
+   */
+  user;
+  constructor(name, ctx, emitter, userProvider) {
+    this.#name = name;
+    this.#ctx = ctx;
+    this.#emitter = emitter;
+    this.#userProvider = userProvider;
+  }
+  /**
+   * Emits authentication failure, updates the local state,
+   * and returns an exception to end the authentication
+   * cycle.
+   */
+  #authenticationFailed() {
+    this.isAuthenticated = false;
+    this.user = void 0;
+    const error = new E_UNAUTHORIZED_ACCESS("Invalid basic auth credentials", {
+      guardDriverName: this.driverName
+    });
+    this.#emitter.emit("basic_auth:authentication_failed", {
+      ctx: this.#ctx,
+      guardName: this.#name,
+      error
+    });
+    return error;
+  }
+  /**
+   * Emits the authentication succeeded event and updates
+   * the local state to reflect successful authentication
+   */
+  #authenticationSucceeded(user) {
+    this.isAuthenticated = true;
+    this.user = user;
+    this.#emitter.emit("basic_auth:authentication_succeeded", {
+      ctx: this.#ctx,
+      guardName: this.#name,
+      user
+    });
+  }
+  /**
+   * Returns an instance of the authenticated user. Or throws
+   * an exception if the request is not authenticated.
+   */
+  getUserOrFail() {
+    if (!this.user) {
+      throw new E_UNAUTHORIZED_ACCESS("Invalid basic auth credentials", {
+        guardDriverName: this.driverName
+      });
+    }
+    return this.user;
+  }
+  /**
+   * Authenticates the incoming HTTP request by looking for BasicAuth
+   * credentials inside the request authorization header.
+   *
+   * Returns the authenticated user or throws an exception.
+   */
+  async authenticate() {
+    if (this.authenticationAttempted) {
+      return this.getUserOrFail();
+    }
+    this.authenticationAttempted = true;
+    this.#emitter.emit("basic_auth:authentication_attempted", {
+      ctx: this.#ctx,
+      guardName: this.#name
+    });
+    const credentials = auth(this.#ctx.request.request);
+    if (!credentials) {
+      throw this.#authenticationFailed();
+    }
+    const user = await this.#userProvider.verifyCredentials(credentials.name, credentials.pass);
+    if (!user) {
+      throw this.#authenticationFailed();
+    }
+    this.#authenticationSucceeded(user.getOriginal());
+    return this.getUserOrFail();
+  }
+  /**
+   * Silently attempt to authenticate the user.
+   *
+   * The method returns a boolean indicating if the authentication
+   * succeeded or failed.
+   */
+  async check() {
+    try {
+      await this.authenticate();
+      return true;
+    } catch (error) {
+      if (error instanceof E_UNAUTHORIZED_ACCESS) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Does not support authenticating as client. Instead use "basicAuth"
+   * helper on Japa APIClient
+   */
+  async authenticateAsClient(uid, password) {
+    return {
+      headers: {
+        authorization: `Basic ${base64.encode(`${uid}:${password}`)}`
+      }
+    };
+  }
+};
+
+// modules/basic_auth_guard/user_providers/lucid.ts
+import { RuntimeException } from "@adonisjs/core/exceptions";
+var BasicAuthLucidUserProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Reference to the lazily imported model
+   */
+  model;
+  /**
+   * Imports the model from the provider, returns and caches it
+   * for further operations.
+   */
+  async getModel() {
+    if (this.model) {
+      return this.model;
+    }
+    const importedModel = await this.options.model();
+    this.model = importedModel.default;
+    return this.model;
+  }
+  /**
+   * Creates an adapter user for the guard
+   */
+  async createUserForGuard(user) {
+    const model = await this.getModel();
+    if (user instanceof model === false) {
+      throw new RuntimeException(
+        `Invalid user object. It must be an instance of the "${model.name}" model`
+      );
+    }
+    return {
+      getId() {
+        if (!user.$primaryKeyValue) {
+          throw new RuntimeException(
+            `Cannot use "${model.name}" model for authentication. The value of column "${model.primaryKey}" is undefined or null`
+          );
+        }
+        return user.$primaryKeyValue;
+      },
+      getOriginal() {
+        return user;
+      }
+    };
+  }
+  /**
+   * Verifies credentials using the underlying model
+   */
+  async verifyCredentials(uid, password) {
+    const model = await this.getModel();
+    try {
+      const user = await model.verifyCredentials(uid, password);
+      return this.createUserForGuard(user);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// modules/basic_auth_guard/define_config.ts
+function basicAuthGuard(config) {
+  return {
+    async resolver(name, app) {
+      const emitter = await app.container.make("emitter");
+      const provider = "resolver" in config.provider ? await config.provider.resolver(app) : config.provider;
+      return (ctx) => new BasicAuthGuard(name, ctx, emitter, provider);
+    }
+  };
+}
+function basicAuthUserProvider(config) {
+  return new BasicAuthLucidUserProvider(config);
+}
+export {
+  BasicAuthGuard,
+  BasicAuthLucidUserProvider,
+  basicAuthGuard,
+  basicAuthUserProvider
+};
+//# sourceMappingURL=main.js.map

package/build/modules/basic_auth_guard/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../modules/basic_auth_guard/guard.ts","../../../modules/basic_auth_guard/user_providers/lucid.ts","../../../modules/basic_auth_guard/define_config.ts"],"sourcesContent":["/*\n * @adonisjs/auth\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport auth from 'basic-auth'\nimport { base64 } from '@adonisjs/core/helpers'\nimport type { HttpContext } from '@adonisjs/core/http'\nimport type { EmitterLike } from '@adonisjs/core/types/events'\n\nimport { E_UNAUTHORIZED_ACCESS } from '../../src/errors.js'\nimport type { AuthClientResponse, GuardContract } from '../../src/types.js'\nimport { GUARD_KNOWN_EVENTS, PROVIDER_REAL_USER } from '../../src/symbols.js'\nimport type { BasicAuthGuardEvents, BasicAuthUserProviderContract } from './types.js'\n\n/**\n * BasicAuth guard implements the HTTP Authentication protocol\n */\nexport class BasicAuthGuard<UserProvider extends BasicAuthUserProviderContract<unknown>>\n  implements GuardContract<UserProvider[typeof PROVIDER_REAL_USER]>\n{\n  /**\n   * Events emitted by the guard\n   */\n  declare [GUARD_KNOWN_EVENTS]: BasicAuthGuardEvents<UserProvider[typeof PROVIDER_REAL_USER]>\n\n  /**\n   * A unique name for the guard.\n   */\n  #name: string\n\n  /**\n   * Reference to the current HTTP context\n   */\n  #ctx: HttpContext\n\n  /**\n   * Provider to lookup user details\n   */\n  #userProvider: UserProvider\n\n  /**\n   * Emitter to emit events\n   */\n  #emitter: EmitterLike<BasicAuthGuardEvents<UserProvider[typeof PROVIDER_REAL_USER]>>\n\n  /**\n   * Driver name of the guard\n   */\n  driverName: 'basic_auth' = 'basic_auth'\n\n  /**\n   * Whether or not the authentication has been attempted\n   * during the current request.\n   */\n  authenticationAttempted = false\n\n  /**\n   * A boolean to know if the current request has\n   * been authenticated\n   */\n  isAuthenticated = false\n\n  /**\n   * Reference to an instance of the authenticated user.\n   * The value only exists after calling one of the\n   * following methods.\n   *\n   * - authenticate\n   * - check\n   *\n   * You can use the \"getUserOrFail\" method to throw an exception if\n   * the request is not authenticated.\n   */\n  user?: UserProvider[typeof PROVIDER_REAL_USER]\n\n  constructor(\n    name: string,\n    ctx: HttpContext,\n    emitter: EmitterLike<BasicAuthGuardEvents<UserProvider[typeof PROVIDER_REAL_USER]>>,\n    userProvider: UserProvider\n  ) {\n    this.#name = name\n    this.#ctx = ctx\n    this.#emitter = emitter\n    this.#userProvider = userProvider\n  }\n\n  /**\n   * Emits authentication failure, updates the local state,\n   * and returns an exception to end the authentication\n   * cycle.\n   */\n  #authenticationFailed() {\n    this.isAuthenticated = false\n    this.user = undefined\n\n    const error = new E_UNAUTHORIZED_ACCESS('Invalid basic auth credentials', {\n      guardDriverName: this.driverName,\n    })\n\n    this.#emitter.emit('basic_auth:authentication_failed', {\n      ctx: this.#ctx,\n      guardName: this.#name,\n      error,\n    })\n\n    return error\n  }\n\n  /**\n   * Emits the authentication succeeded event and updates\n   * the local state to reflect successful authentication\n   */\n  #authenticationSucceeded(user: UserProvider[typeof PROVIDER_REAL_USER]) {\n    this.isAuthenticated = true\n    this.user = user\n\n    this.#emitter.emit('basic_auth:authentication_succeeded', {\n      ctx: this.#ctx,\n      guardName: this.#name,\n      user,\n    })\n  }\n\n  /**\n   * Returns an instance of the authenticated user. Or throws\n   * an exception if the request is not authenticated.\n   */\n  getUserOrFail(): UserProvider[typeof PROVIDER_REAL_USER] {\n    if (!this.user) {\n      throw new E_UNAUTHORIZED_ACCESS('Invalid basic auth credentials', {\n        guardDriverName: this.driverName,\n      })\n    }\n\n    return this.user\n  }\n\n  /**\n   * Authenticates the incoming HTTP request by looking for BasicAuth\n   * credentials inside the request authorization header.\n   *\n   * Returns the authenticated user or throws an exception.\n   */\n  async authenticate(): Promise<UserProvider[typeof PROVIDER_REAL_USER]> {\n    /**\n     * Avoid re-authenticating when already authenticated\n     */\n    if (this.authenticationAttempted) {\n      return this.getUserOrFail()\n    }\n\n    /**\n     * Beginning authentication attempt\n     */\n    this.authenticationAttempted = true\n    this.#emitter.emit('basic_auth:authentication_attempted', {\n      ctx: this.#ctx,\n      guardName: this.#name,\n    })\n\n    /**\n     * Fetch credentials from the header or fail\n     */\n    const credentials = auth(this.#ctx.request.request)\n    if (!credentials) {\n      throw this.#authenticationFailed()\n    }\n\n    /**\n     * Verify user credentials or fail\n     */\n    const user = await this.#userProvider.verifyCredentials(credentials.name, credentials.pass)\n    if (!user) {\n      throw this.#authenticationFailed()\n    }\n\n    /**\n     * Mark user as authenticated\n     */\n    this.#authenticationSucceeded(user.getOriginal())\n    return this.getUserOrFail()\n  }\n\n  /**\n   * Silently attempt to authenticate the user.\n   *\n   * The method returns a boolean indicating if the authentication\n   * succeeded or failed.\n   */\n  async check(): Promise<boolean> {\n    try {\n      await this.authenticate()\n      return true\n    } catch (error) {\n      if (error instanceof E_UNAUTHORIZED_ACCESS) {\n        return false\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Does not support authenticating as client. Instead use \"basicAuth\"\n   * helper on Japa APIClient\n   */\n  async authenticateAsClient(uid: string, password: string): Promise<AuthClientResponse> {\n    return {\n      headers: {\n        authorization: `Basic ${base64.encode(`${uid}:${password}`)}`,\n      },\n    }\n  }\n}\n","/*\n * @adonisjs/auth\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { RuntimeException } from '@adonisjs/core/exceptions'\nimport { PROVIDER_REAL_USER } from '../../../src/symbols.js'\nimport type {\n  BasicAuthGuardUser,\n  LucidAuthenticatable,\n  BasicAuthUserProviderContract,\n  BasicAuthLucidUserProviderOptions,\n} from '../types.js'\n\n/**\n * Uses a Lucid model to verify access tokens and find a user during\n * authentication\n */\nexport class BasicAuthLucidUserProvider<UserModel extends LucidAuthenticatable>\n  implements BasicAuthUserProviderContract<InstanceType<UserModel>>\n{\n  declare [PROVIDER_REAL_USER]: InstanceType<UserModel>\n\n  /**\n   * Reference to the lazily imported model\n   */\n  protected model?: UserModel\n\n  constructor(\n    /**\n     * Lucid provider options\n     */\n    protected options: BasicAuthLucidUserProviderOptions<UserModel>\n  ) {}\n\n  /**\n   * Imports the model from the provider, returns and caches it\n   * for further operations.\n   */\n  protected async getModel() {\n    if (this.model) {\n      return this.model\n    }\n\n    const importedModel = await this.options.model()\n    this.model = importedModel.default\n    return this.model\n  }\n\n  /**\n   * Creates an adapter user for the guard\n   */\n  async createUserForGuard(\n    user: InstanceType<UserModel>\n  ): Promise<BasicAuthGuardUser<InstanceType<UserModel>>> {\n    const model = await this.getModel()\n    if (user instanceof model === false) {\n      throw new RuntimeException(\n        `Invalid user object. It must be an instance of the \"${model.name}\" model`\n      )\n    }\n\n    return {\n      getId() {\n        /**\n         * Ensure user has a primary key\n         */\n        if (!user.$primaryKeyValue) {\n          throw new RuntimeException(\n            `Cannot use \"${model.name}\" model for authentication. The value of column \"${model.primaryKey}\" is undefined or null`\n          )\n        }\n\n        return user.$primaryKeyValue\n      },\n      getOriginal() {\n        return user\n      },\n    }\n  }\n\n  /**\n   * Verifies credentials using the underlying model\n   */\n  async verifyCredentials(\n    uid: string,\n    password: string\n  ): Promise<BasicAuthGuardUser<InstanceType<UserModel>> | null> {\n    const model = await this.getModel()\n    try {\n      const user = await model.verifyCredentials(uid, password)\n      return this.createUserForGuard(user as InstanceType<UserModel>)\n    } catch {\n      return null\n    }\n  }\n}\n","/*\n * @adonisjs/auth\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport type { HttpContext } from '@adonisjs/core/http'\nimport type { ConfigProvider } from '@adonisjs/core/types'\n\nimport { BasicAuthGuard } from './guard.js'\nimport type { GuardConfigProvider } from '../../src/types.js'\nimport { BasicAuthLucidUserProvider } from './user_providers/lucid.js'\nimport type {\n  LucidAuthenticatable,\n  BasicAuthUserProviderContract,\n  BasicAuthLucidUserProviderOptions,\n} from './types.js'\n\n/**\n * Configures basic auth guard for authentication\n */\nexport function basicAuthGuard<\n  UserProvider extends BasicAuthUserProviderContract<unknown>,\n>(config: {\n  provider: UserProvider | ConfigProvider<UserProvider>\n}): GuardConfigProvider<(ctx: HttpContext) => BasicAuthGuard<UserProvider>> {\n  return {\n    async resolver(name, app) {\n      const emitter = await app.container.make('emitter')\n      const provider =\n        'resolver' in config.provider ? await config.provider.resolver(app) : config.provider\n      return (ctx) => new BasicAuthGuard(name, ctx, emitter as any, provider)\n    },\n  }\n}\n\n/**\n * Configures user provider that uses Lucid models to authenticate\n * users using basic auth\n */\nexport function basicAuthUserProvider<Model extends LucidAuthenticatable>(\n  config: BasicAuthLucidUserProviderOptions<Model>\n): BasicAuthLucidUserProvider<Model> {\n  return new BasicAuthLucidUserProvider(config)\n}\n"],"mappings":"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","names":[]}

package/build/modules/basic_auth_guard/types.d.ts

@@ -0,0 +1,85 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { Exception } from '@adonisjs/core/exceptions';
+import type { LucidModel } from '@adonisjs/lucid/types/model';
+import type { PROVIDER_REAL_USER } from '../../src/symbols.js';
+/**
+ * A lucid model with verify credentials method to verify user
+ * credentials during authentication.
+ */
+export type LucidAuthenticatable = LucidModel & {
+    /**
+     * Verify credentials method should return the user instance
+     * or throw an exception
+     */
+    verifyCredentials(uid: string, password: string): Promise<InstanceType<LucidAuthenticatable>>;
+};
+/**
+ * Options accepted by the user provider that uses a lucid
+ * model to lookup a user during authentication and verify
+ * credentials
+ */
+export type BasicAuthLucidUserProviderOptions<Model extends LucidAuthenticatable> = {
+    /**
+     * The model to use for users lookup
+     */
+    model: () => Promise<{
+        default: Model;
+    }>;
+};
+/**
+ * Guard user is an adapter between the user provider
+ * and the guard.
+ *
+ * The guard is user provider agnostic and therefore it
+ * needs a adapter to known some basic info about the
+ * user.
+ */
+export type BasicAuthGuardUser<RealUser> = {
+    getId(): string | number | BigInt;
+    getOriginal(): RealUser;
+};
+/**
+ * The user provider used by basic auth guard to lookup users
+ * during authentication
+ */
+export interface BasicAuthUserProviderContract<RealUser> {
+    [PROVIDER_REAL_USER]: RealUser;
+    /**
+     * Create a user object that acts as an adapter between
+     * the guard and real user value.
+     */
+    createUserForGuard(user: RealUser): Promise<BasicAuthGuardUser<RealUser>>;
+    /**
+     * Verify user credentials and must return an instance of the
+     * user back or null when the credentials are invalid
+     */
+    verifyCredentials(uid: string, password: string): Promise<BasicAuthGuardUser<RealUser> | null>;
+}
+/**
+ * Events emitted by the basic auth guard
+ */
+export type BasicAuthGuardEvents<User> = {
+    /**
+     * Attempting to authenticate the user
+     */
+    'basic_auth:authentication_attempted': {
+        ctx: HttpContext;
+        guardName: string;
+    };
+    /**
+     * Authentication was successful
+     */
+    'basic_auth:authentication_succeeded': {
+        ctx: HttpContext;
+        guardName: string;
+        user: User;
+    };
+    /**
+     * Authentication failed
+     */
+    'basic_auth:authentication_failed': {
+        ctx: HttpContext;
+        guardName: string;
+        error: Exception;
+    };
+};

package/build/modules/basic_auth_guard/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/build/modules/basic_auth_guard/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/modules/basic_auth_guard/user_providers/lucid.d.ts

@@ -0,0 +1,35 @@
+import { PROVIDER_REAL_USER } from '../../../src/symbols.js';
+import type { BasicAuthGuardUser, LucidAuthenticatable, BasicAuthUserProviderContract, BasicAuthLucidUserProviderOptions } from '../types.js';
+/**
+ * Uses a Lucid model to verify access tokens and find a user during
+ * authentication
+ */
+export declare class BasicAuthLucidUserProvider<UserModel extends LucidAuthenticatable> implements BasicAuthUserProviderContract<InstanceType<UserModel>> {
+    /**
+     * Lucid provider options
+     */
+    protected options: BasicAuthLucidUserProviderOptions<UserModel>;
+    [PROVIDER_REAL_USER]: InstanceType<UserModel>;
+    /**
+     * Reference to the lazily imported model
+     */
+    protected model?: UserModel;
+    constructor(
+    /**
+     * Lucid provider options
+     */
+    options: BasicAuthLucidUserProviderOptions<UserModel>);
+    /**
+     * Imports the model from the provider, returns and caches it
+     * for further operations.
+     */
+    protected getModel(): Promise<UserModel>;
+    /**
+     * Creates an adapter user for the guard
+     */
+    createUserForGuard(user: InstanceType<UserModel>): Promise<BasicAuthGuardUser<InstanceType<UserModel>>>;
+    /**
+     * Verifies credentials using the underlying model
+     */
+    verifyCredentials(uid: string, password: string): Promise<BasicAuthGuardUser<InstanceType<UserModel>> | null>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/auth",
-  "version": "9.0.3",
+  "version": "9.1.1",
   "description": "Official authentication provider for Adonis framework",
   "type": "module",
   "main": "build/index.js",
@@ -24,11 +24,13 @@
     "./access_tokens": "./build/modules/access_tokens_guard/main.js",
     "./types/access_tokens": "./build/modules/access_tokens_guard/types.js",
     "./session": "./build/modules/session_guard/main.js",
-    "./types/session": "./build/modules/session_guard/types.js"
+    "./types/session": "./build/modules/session_guard/types.js",
+    "./basic_auth": "./build/modules/basic_auth_guard/main.js",
+    "./types/basic_auth": "./build/modules/basic_auth_guard/types.js"
   },
   "scripts": {
     "pretest": "npm run lint",
-    "test": "c8 npm run test:sqlite && npm run test:mysql && npm run test:pg && npm run test:mssql",
+    "test": "npm run test:mysql && npm run test:pg && npm run test:mssql && c8 npm run test:sqlite",
     "test:sqlite": "npm run quick:test",
     "test:mysql": "cross-env DB=mysql npm run quick:test",
     "test:mssql": "cross-env DB=mssql npm run quick:test",
@@ -64,11 +66,11 @@
     "url": "https://github.com/adonisjs/auth/issues"
   },
   "devDependencies": {
-    "@adonisjs/assembler": "^7.1.0",
+    "@adonisjs/assembler": "^7.1.1",
     "@adonisjs/core": "^6.2.1",
     "@adonisjs/eslint-config": "^1.2.1",
     "@adonisjs/i18n": "^2.0.0",
-    "@adonisjs/lucid": "^20.0.0",
+    "@adonisjs/lucid": "^20.1.0",
     "@adonisjs/prettier-config": "^1.2.1",
     "@adonisjs/session": "^7.1.1",
     "@adonisjs/tsconfig": "^1.2.1",
@@ -96,9 +98,9 @@
     "dotenv": "^16.4.1",
     "eslint": "^8.56.0",
     "github-label-sync": "^2.3.1",
-    "husky": "^9.0.1",
+    "husky": "^9.0.7",
     "luxon": "^3.4.4",
-    "mysql2": "^3.8.0",
+    "mysql2": "^3.9.1",
     "nock": "^13.5.0",
     "np": "^9.2.0",
     "pg": "^8.11.3",
@@ -148,9 +150,9 @@
     "basic-auth": "^2.0.1"
   },
   "peerDependencies": {
-    "@adonisjs/core": "^6.2.0",
-    "@adonisjs/lucid": "^19.0.0",
-    "@adonisjs/session": "^7.0.0",
+    "@adonisjs/core": "^6.2.1",
+    "@adonisjs/lucid": "^20.1.0",
+    "@adonisjs/session": "^7.1.1",
     "@japa/api-client": "^2.0.2",
     "@japa/browser-client": "^2.0.2",
     "@japa/plugin-adonisjs": "^3.0.0"
@@ -184,7 +186,9 @@
       "./modules/access_tokens_guard/main.ts",
       "./modules/access_tokens_guard/types.ts",
       "./modules/session_guard/main.ts",
-      "./modules/session_guard/types.ts"
+      "./modules/session_guard/types.ts",
+      "./modules/basic_auth_guard/main.ts",
+      "./modules/basic_auth_guard/types.ts"
     ],
     "outDir": "./build",
     "clean": true,