alepha 0.13.0 → 0.13.2

package/src/security/{descriptors → primitives}/$realm.ts

@@ -1,10 +1,4 @@
-import {
-  $inject,
-  AlephaError,
-  createDescriptor,
-  Descriptor,
-  KIND,
-} from "alepha";
+import { $inject, AlephaError, createPrimitive, KIND, Primitive } from "alepha";
 import {
   DateTimeProvider,
   type Duration,
@@ -21,13 +15,13 @@ import type { UserAccount } from "../schemas/userAccountInfoSchema.ts";
 /**
  * Create a new realm.
  */
-export const $realm = (options: RealmDescriptorOptions): RealmDescriptor => {
-  return createDescriptor(RealmDescriptor, options);
+export const $realm = (options: RealmPrimitiveOptions): RealmPrimitive => {
+  return createPrimitive(RealmPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export type RealmDescriptorOptions = {
+export type RealmPrimitiveOptions = {
   /**
    * Define the realm name.
    * If not provided, it will use the property key.
@@ -109,7 +103,7 @@ export interface RealmExternal {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class RealmDescriptor extends Descriptor<RealmDescriptorOptions> {
+export class RealmPrimitive extends Primitive<RealmPrimitiveOptions> {
   protected readonly securityProvider = $inject(SecurityProvider);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
   protected readonly jwt = $inject(JwtProvider);
@@ -342,7 +336,7 @@ export class RealmDescriptor extends Descriptor<RealmDescriptorOptions> {
   }
 }
 
-$realm[KIND] = RealmDescriptor;
+$realm[KIND] = RealmPrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/security/{descriptors → primitives}/$role.ts

@@ -1,18 +1,18 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import { SecurityProvider } from "../providers/SecurityProvider.ts";
-import type { PermissionDescriptor } from "./$permission.ts";
-import type { RealmDescriptor } from "./$realm.ts";
+import type { PermissionPrimitive } from "./$permission.ts";
+import type { RealmPrimitive } from "./$realm.ts";
 
 /**
  * Create a new role.
  */
-export const $role = (options: RoleDescriptorOptions = {}): RoleDescriptor => {
-  return createDescriptor(RoleDescriptor, options);
+export const $role = (options: RolePrimitiveOptions = {}): RolePrimitive => {
+  return createPrimitive(RolePrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface RoleDescriptorOptions {
+export interface RolePrimitiveOptions {
   /**
    * Name of the role.
    */
@@ -23,7 +23,7 @@ export interface RoleDescriptorOptions {
    */
   description?: string;
 
-  realm?: string | RealmDescriptor;
+  realm?: string | RealmPrimitive;
 
   permissions?: Array<
     | string
@@ -35,7 +35,7 @@ export interface RoleDescriptorOptions {
   >;
 }
 
-export class RoleDescriptor extends Descriptor<RoleDescriptorOptions> {
+export class RolePrimitive extends Primitive<RolePrimitiveOptions> {
   protected readonly securityProvider = $inject(SecurityProvider);
 
   public get name(): string {
@@ -62,19 +62,19 @@ export class RoleDescriptor extends Descriptor<RoleDescriptorOptions> {
   /**
    * Get the realm of the role.
    */
-  public get realm(): string | RealmDescriptor | undefined {
+  public get realm(): string | RealmPrimitive | undefined {
     return this.options.realm;
   }
 
-  public can(permission: string | PermissionDescriptor): boolean {
+  public can(permission: string | PermissionPrimitive): boolean {
     return this.securityProvider.can(this.name, permission);
   }
 
-  public check(permission: string | PermissionDescriptor) {
+  public check(permission: string | PermissionPrimitive) {
     return this.securityProvider.checkPermission(permission, this.name);
   }
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-$role[KIND] = RoleDescriptor;
+$role[KIND] = RolePrimitive;

package/src/security/{descriptors → primitives}/$serviceAccount.ts

@@ -1,7 +1,7 @@
 import { $context } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import type { UserAccount } from "../schemas/userAccountInfoSchema.ts";
-import type { AccessTokenResponse, RealmDescriptor } from "./$realm.ts";
+import type { AccessTokenResponse, RealmPrimitive } from "./$realm.ts";
 
 /**
  * Allow to get an access token for a service account.
@@ -32,8 +32,8 @@ import type { AccessTokenResponse, RealmDescriptor } from "./$realm.ts";
  * ```
  */
 export const $serviceAccount = (
-  options: ServiceAccountDescriptorOptions,
-): ServiceAccountDescriptor => {
+  options: ServiceAccountPrimitiveOptions,
+): ServiceAccountPrimitive => {
   const { alepha } = $context();
   const store: {
     cache?: AccessTokenResponse;
@@ -150,19 +150,19 @@ export const $serviceAccount = (
   };
 };
 
-export type ServiceAccountDescriptorOptions = {
+export type ServiceAccountPrimitiveOptions = {
   gracePeriod?: number; // Grace period in milliseconds before token expiration
 } & (
   | {
-      oauth2: Oauth2ServiceAccountDescriptorOptions;
+      oauth2: Oauth2ServiceAccountPrimitiveOptions;
     }
   | {
-      realm: RealmDescriptor;
+      realm: RealmPrimitive;
       user: UserAccount;
     }
 );
 
-export interface Oauth2ServiceAccountDescriptorOptions {
+export interface Oauth2ServiceAccountPrimitiveOptions {
   /**
    * Get Token URL.
    */
@@ -179,7 +179,7 @@ export interface Oauth2ServiceAccountDescriptorOptions {
   clientSecret: string;
 }
 
-export interface ServiceAccountDescriptor {
+export interface ServiceAccountPrimitive {
   token: () => Promise<string>;
 }
 

package/src/server/index.browser.ts

@@ -9,6 +9,6 @@ export * from "./index.shared.ts";
 
 export const AlephaServer = $module({
   name: "alepha.server",
-  descriptors: [],
+  primitives: [],
   services: [HttpClient],
 });

package/src/server/index.ts

@@ -1,11 +1,5 @@
 import type { Server } from "node:http";
-import { $module, type Alepha, type DescriptorFactoryLike } from "alepha";
-import {
-  $action,
-  type ActionDescriptor,
-  type ClientRequestOptions,
-} from "./descriptors/$action.ts";
-import { $route } from "./descriptors/$route.ts";
+import { $module, type Alepha, type PrimitiveFactoryLike } from "alepha";
 import type { HttpError } from "./errors/HttpError.ts";
 import type {
   NodeRequestEvent,
@@ -16,6 +10,12 @@ import type {
   ServerRoute,
   WebRequestEvent,
 } from "./interfaces/ServerRequest.ts";
+import {
+  $action,
+  type ActionPrimitive,
+  type ClientRequestOptions,
+} from "./primitives/$action.ts";
+import { $route } from "./primitives/$route.ts";
 import { BunHttpServerProvider } from "./providers/BunHttpServerProvider.ts";
 import { NodeHttpServerProvider } from "./providers/NodeHttpServerProvider.ts";
 import { ServerBodyParserProvider } from "./providers/ServerBodyParserProvider.ts";
@@ -36,12 +36,12 @@ declare module "alepha" {
     // -----------------------------------------------------------------------------------------------------------------
     // Local Actions hooks
     "action:onRequest": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
     };
     "action:onResponse": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
       response: any;
@@ -96,9 +96,9 @@ declare module "alepha" {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$action.ts";
-export * from "./descriptors/$route.ts";
 export * from "./index.shared.ts";
+export * from "./primitives/$action.ts";
+export * from "./primitives/$route.ts";
 export * from "./providers/BunHttpServerProvider.ts";
 export * from "./providers/NodeHttpServerProvider.ts";
 export * from "./providers/ServerLoggerProvider.ts";
@@ -110,9 +110,9 @@ export * from "./providers/ServerTimingProvider.ts";
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * Provides high-performance HTTP server capabilities with declarative routing and action descriptors.
+ * Provides high-performance HTTP server capabilities with declarative routing and action primitives.
  *
- * The server module enables building REST APIs and web applications using `$route` and `$action` descriptors
+ * The server module enables building REST APIs and web applications using `$route` and `$action` primitives
  * on class properties. It provides automatic request/response handling, schema validation, middleware support,
  * and seamless integration with other Alepha modules for a complete backend solution.
  *
@@ -122,7 +122,7 @@ export * from "./providers/ServerTimingProvider.ts";
  */
 export const AlephaServer = $module({
   name: "alepha.server",
-  descriptors: [$route, $action as DescriptorFactoryLike],
+  primitives: [$route, $action as PrimitiveFactoryLike],
   services: [
     ServerProvider,
     BunHttpServerProvider,

package/src/server/{descriptors → primitives}/$action.ts

@@ -2,10 +2,10 @@ import {
   $env,
   $inject,
   type Async,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   isTypeFile,
   KIND,
+  Primitive,
   type Static,
   type TObject,
   type TSchema,
@@ -30,7 +30,7 @@ import {
 } from "../services/HttpClient.ts";
 
 /**
- * Creates a server action descriptor for defining type-safe HTTP endpoints.
+ * Creates a server action primitive for defining type-safe HTTP endpoints.
  *
  * Server actions are the core building blocks for REST APIs in Alepha, providing declarative
  * HTTP endpoints with full type safety, automatic validation, and OpenAPI documentation.
@@ -95,9 +95,9 @@ import {
  * ```
  */
 export const $action = <TConfig extends RequestConfigSchema>(
-  options: ActionDescriptorOptions<TConfig>,
-): ActionDescriptorFn<TConfig> => {
-  const instance = createDescriptor(ActionDescriptor<TConfig>, options);
+  options: ActionPrimitiveOptions<TConfig>,
+): ActionPrimitiveFn<TConfig> => {
+  const instance = createPrimitive(ActionPrimitive<TConfig>, options);
   const fn = (
     config?: ClientRequestEntry<TConfig>,
     options?: ClientRequestOptions,
@@ -109,12 +109,12 @@ export const $action = <TConfig extends RequestConfigSchema>(
       return instance.options.name || instance.config.propertyKey;
     },
   });
-  return Object.setPrototypeOf(fn, instance) as ActionDescriptorFn<TConfig>;
+  return Object.setPrototypeOf(fn, instance) as ActionPrimitiveFn<TConfig>;
 };
 
 // ----------------------------------------------------------------------------------------------------------
 
-export interface ActionDescriptorOptions<TConfig extends RequestConfigSchema>
+export interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema>
   extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
    * Name of the action.
@@ -198,9 +198,9 @@ const envSchema = t.object({
   }),
 });
 
-export class ActionDescriptor<
+export class ActionPrimitive<
   TConfig extends RequestConfigSchema,
-> extends Descriptor<ActionDescriptorOptions<TConfig>> {
+> extends Primitive<ActionPrimitiveOptions<TConfig>> {
   protected readonly log = $logger();
   protected readonly env = $env(envSchema);
   protected readonly httpClient = $inject(HttpClient);
@@ -416,15 +416,15 @@ export class ActionDescriptor<
   }
 }
 
-export interface ActionDescriptorFn<TConfig extends RequestConfigSchema>
-  extends ActionDescriptor<TConfig> {
+export interface ActionPrimitiveFn<TConfig extends RequestConfigSchema>
+  extends ActionPrimitive<TConfig> {
   (
     config?: ClientRequestEntry<TConfig>,
     options?: ClientRequestOptions,
   ): Promise<ClientRequestResponse<TConfig>>;
 }
 
-$action[KIND] = ActionDescriptor;
+$action[KIND] = ActionPrimitive;
 
 // ----------------------------------------------------------------------------------------------------------
 

package/src/server/{descriptors → primitives}/$route.ts

@@ -1,4 +1,4 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import type {
   RequestConfigSchema,
   ServerRoute,
@@ -8,28 +8,28 @@ import { ServerRouterProvider } from "../providers/ServerRouterProvider.ts";
 /**
  * Create a basic endpoint.
  *
- * It's a low level descriptor. You probably want to use `$action` instead.
+ * It's a low level primitive. You probably want to use `$action` instead.
  *
  * @see {@link $action}
  * @see {@link $page}
  */
 export const $route = <TConfig extends RequestConfigSchema>(
-  options: RouteDescriptorOptions<TConfig>,
-): RouteDescriptor<TConfig> => {
-  return createDescriptor(RouteDescriptor<TConfig>, options);
+  options: RoutePrimitiveOptions<TConfig>,
+): RoutePrimitive<TConfig> => {
+  return createPrimitive(RoutePrimitive<TConfig>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface RouteDescriptorOptions<
+export interface RoutePrimitiveOptions<
   TConfig extends RequestConfigSchema = RequestConfigSchema,
 > extends ServerRoute<TConfig> {}
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class RouteDescriptor<
+export class RoutePrimitive<
   TConfig extends RequestConfigSchema,
-> extends Descriptor<RouteDescriptorOptions<TConfig>> {
+> extends Primitive<RoutePrimitiveOptions<TConfig>> {
   protected readonly serverRouterProvider = $inject(ServerRouterProvider);
 
   protected onInit() {
@@ -37,4 +37,4 @@ export class RouteDescriptor<
   }
 }
 
-$route[KIND] = RouteDescriptor;
+$route[KIND] = RoutePrimitive;

package/src/server/providers/NodeHttpServerProvider.ts

@@ -57,7 +57,7 @@ export class NodeHttpServerProvider extends ServerProvider {
     on: "start",
     handler: async () => {
       await this.listen();
-      this.alepha.state.set("alepha.node.server", this.server);
+      this.alepha.store.set("alepha.node.server", this.server);
     },
   });
 
@@ -67,7 +67,7 @@ export class NodeHttpServerProvider extends ServerProvider {
     return createServer(
       {
         // nov 25 - keep connections alive for better performance, cuz we http/1.1 by default
-        keepAlive: true,
+        keepAlive: this.alepha.isProduction(),
       },
       func,
     );

package/src/server/services/HttpClient.ts

@@ -10,7 +10,6 @@ import {
 import { $cache } from "alepha/cache";
 import type { DurationLike } from "alepha/datetime";
 import { $logger } from "alepha/logger";
-import type { ClientRequestOptions } from "../descriptors/$action.ts";
 import { HttpError } from "../errors/HttpError.ts";
 import { isMultipart } from "../helpers/isMultipart.ts";
 import type {
@@ -18,6 +17,7 @@ import type {
   TRequestBody,
   TResponseBody,
 } from "../interfaces/ServerRequest.ts";
+import type { ClientRequestOptions } from "../primitives/$action.ts";
 import { errorSchema } from "../schemas/errorSchema.ts";
 
 export class HttpClient {

package/src/server-auth/index.browser.ts

@@ -8,6 +8,6 @@ export * from "./index.shared.ts";
 
 export const AlephaServerAuth = $module({
   name: "alepha.server.auth",
-  descriptors: [],
+  primitives: [],
   services: [],
 });

package/src/server-auth/index.ts

@@ -1,16 +1,16 @@
 import { $module } from "alepha";
 import type { UserAccount } from "alepha/security";
 import { AlephaServerCookies } from "alepha/server/cookies";
-import { $auth } from "./descriptors/$auth.ts";
+import { $auth } from "./primitives/$auth.ts";
 import { ServerAuthProvider } from "./providers/ServerAuthProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$auth.ts";
-export * from "./descriptors/$authCredentials.ts";
-export * from "./descriptors/$authGithub.ts";
-export * from "./descriptors/$authGoogle.ts";
 export * from "./index.shared.ts";
+export * from "./primitives/$auth.ts";
+export * from "./primitives/$authCredentials.ts";
+export * from "./primitives/$authGithub.ts";
+export * from "./primitives/$authGoogle.ts";
 export * from "./providers/ServerAuthProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -43,6 +43,6 @@ declare module "alepha" {
  */
 export const AlephaServerAuth = $module({
   name: "alepha.server.auth",
-  descriptors: [$auth],
+  primitives: [$auth],
   services: [AlephaServerCookies, ServerAuthProvider],
 });

package/src/server-auth/{descriptors → primitives}/$auth.ts

@@ -2,14 +2,14 @@ import {
   $inject,
   AlephaError,
   type Async,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
 } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import {
   type AccessTokenResponse,
-  type RealmDescriptor,
+  type RealmPrimitive,
   SecurityError,
   SecurityProvider,
   type UserAccount,
@@ -24,7 +24,7 @@ import type { OAuth2Profile } from "../providers/ServerAuthProvider.ts";
 import type { Tokens } from "../schemas/tokensSchema.ts";
 
 /**
- * Creates an authentication provider descriptor for handling user login flows.
+ * Creates an authentication provider primitive for handling user login flows.
  *
  * Supports multiple authentication strategies: credentials (username/password), OAuth2,
  * and OIDC (OpenID Connect). Handles token management, user profile retrieval, and
@@ -57,13 +57,13 @@ import type { Tokens } from "../schemas/tokensSchema.ts";
  * }
  * ```
  */
-export const $auth = (options: AuthDescriptorOptions): AuthDescriptor => {
-  return createDescriptor(AuthDescriptor, options);
+export const $auth = (options: AuthPrimitiveOptions): AuthPrimitive => {
+  return createPrimitive(AuthPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export type AuthDescriptorOptions = {
+export type AuthPrimitiveOptions = {
   /**
    * Name of the identity provider.
    * If not provided, it will be derived from the property key.
@@ -108,7 +108,7 @@ export type AuthExternal = {
  * This relies on the `realm`, which is used to create/verify the access token.
  */
 export type AuthInternal = {
-  realm: RealmDescriptor;
+  realm: RealmPrimitive;
 } & (
   | {
       /**
@@ -251,7 +251,7 @@ export interface OAuth2Options {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class AuthDescriptor extends Descriptor<AuthDescriptorOptions> {
+export class AuthPrimitive extends Primitive<AuthPrimitiveOptions> {
   protected readonly securityProvider = $inject(SecurityProvider);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
 
@@ -433,7 +433,7 @@ export class AuthDescriptor extends Descriptor<AuthDescriptorOptions> {
   }
 }
 
-$auth[KIND] = AuthDescriptor;
+$auth[KIND] = AuthPrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/server-auth/{descriptors → primitives}/$authCredentials.ts

@@ -1,5 +1,5 @@
 import { AlephaError } from "alepha";
-import type { RealmDescriptor } from "alepha/security";
+import type { RealmPrimitive } from "alepha/security";
 import {
   $auth,
   type CredentialsFn,
@@ -8,12 +8,12 @@ import {
 } from "./$auth.ts";
 
 /**
- * Already configured Credentials authentication descriptor.
+ * Already configured Credentials authentication primitive.
  *
  * Uses username and password to authenticate users.
  */
 export const $authCredentials = (
-  realm: RealmDescriptor & WithLoginFn,
+  realm: RealmPrimitive & WithLoginFn,
   options: Partial<CredentialsOptions> = {},
 ) => {
   const name = "credentials";
@@ -24,7 +24,7 @@ export const $authCredentials = (
 
   if (!account) {
     throw new AlephaError(
-      "Credentials authentication requires a login function in the realm descriptor.",
+      "Credentials authentication requires a login function in the realm primitive.",
     );
   }
 

package/src/server-auth/{descriptors → primitives}/$authGithub.ts

@@ -1,5 +1,5 @@
 import { $context, AlephaError, t } from "alepha";
-import type { RealmDescriptor } from "alepha/security";
+import type { RealmPrimitive } from "alepha/security";
 import type { OAuth2Profile } from "../providers/ServerAuthProvider.ts";
 import {
   $auth,
@@ -9,7 +9,7 @@ import {
 } from "./$auth.ts";
 
 /**
- * Already configured GitHub authentication descriptor.
+ * Already configured GitHub authentication primitive.
  *
  * Uses OAuth2 to authenticate users via their GitHub accounts.
  * Upon successful authentication, it links the GitHub account to a user session.
@@ -19,7 +19,7 @@ import {
  * - `GITHUB_CLIENT_SECRET`: The client secret obtained from the GitHub Developer Settings.
  */
 export const $authGithub = (
-  realm: RealmDescriptor & WithLinkFn,
+  realm: RealmPrimitive & WithLinkFn,
   options: Partial<OidcOptions> = {},
 ) => {
   const { alepha } = $context();
@@ -40,7 +40,7 @@ export const $authGithub = (
 
   if (!account) {
     throw new AlephaError(
-      "Authentication requires a link function in the realm descriptor.",
+      "Authentication requires a link function in the realm primitive.",
     );
   }
 

package/src/server-auth/{descriptors → primitives}/$authGoogle.ts

@@ -1,5 +1,5 @@
 import { $context, AlephaError, t } from "alepha";
-import type { RealmDescriptor } from "alepha/security";
+import type { RealmPrimitive } from "alepha/security";
 import {
   $auth,
   type LinkAccountFn,
@@ -8,7 +8,7 @@ import {
 } from "./$auth.ts";
 
 /**
- * Already configured Google authentication descriptor.
+ * Already configured Google authentication primitive.
  *
  * Uses OpenID Connect (OIDC) to authenticate users via their Google accounts.
  * Upon successful authentication, it links the Google account to a user session.
@@ -18,7 +18,7 @@ import {
  * - `GOOGLE_CLIENT_SECRET`: The client secret obtained from the Google Developer Console.
  */
 export const $authGoogle = (
-  realm: RealmDescriptor & WithLinkFn,
+  realm: RealmPrimitive & WithLinkFn,
   options: Partial<OidcOptions> = {},
 ) => {
   const { alepha } = $context();
@@ -39,7 +39,7 @@ export const $authGoogle = (
 
   if (!account) {
     throw new AlephaError(
-      "Authentication requires a link function in the realm descriptor.",
+      "Authentication requires a link function in the realm primitive.",
     );
   }
 

package/src/server-auth/providers/ServerAuthProvider.ts

@@ -22,7 +22,7 @@ import {
   randomState,
 } from "openid-client";
 import { alephaServerAuthRoutes } from "../constants/routes.ts";
-import { $auth, type AuthDescriptor } from "../descriptors/$auth.ts";
+import { $auth, type AuthPrimitive } from "../primitives/$auth.ts";
 import type { AuthenticationProvider } from "../schemas/authenticationProviderSchema.ts";
 import { tokenResponseSchema } from "../schemas/tokenResponseSchema.ts";
 import { type Tokens, tokensSchema } from "../schemas/tokensSchema.ts";
@@ -57,9 +57,9 @@ export class ServerAuthProvider {
     schema: tokensSchema,
   });
 
-  public get identities(): Array<AuthDescriptor> {
+  public get identities(): Array<AuthPrimitive> {
     return this.alepha
-      .descriptors($auth)
+      .primitives($auth)
       .filter((auth) => !auth.options.disabled);
   }
 
@@ -603,7 +603,7 @@ export class ServerAuthProvider {
     },
   });
 
-  protected provider(opts: string | { provider: string }): AuthDescriptor {
+  protected provider(opts: string | { provider: string }): AuthPrimitive {
     const name = typeof opts === "string" ? opts : opts.provider;
     const identity = this.identities.find((identity) => identity.name === name);