alepha 0.13.1 → 0.13.2

package/src/scheduler/{descriptors → primitives}/$scheduler.ts

@@ -3,9 +3,9 @@ import {
   $inject,
   Alepha,
   type Async,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Static,
   t,
 } from "alepha";
@@ -19,17 +19,17 @@ import { $logger } from "alepha/logger";
 import { CronProvider } from "../providers/CronProvider.ts";
 
 /**
- * Scheduler descriptor.
+ * Scheduler primitive.
  */
 export const $scheduler = (
-  options: SchedulerDescriptorOptions,
-): SchedulerDescriptor => {
-  return createDescriptor(SchedulerDescriptor, options);
+  options: SchedulerPrimitiveOptions,
+): SchedulerPrimitive => {
+  return createPrimitive(SchedulerPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export type SchedulerDescriptorOptions = {
+export type SchedulerPrimitiveOptions = {
   /**
    * Function to run on schedule.
    */
@@ -78,7 +78,7 @@ declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 
-export class SchedulerDescriptor extends Descriptor<SchedulerDescriptorOptions> {
+export class SchedulerPrimitive extends Primitive<SchedulerPrimitiveOptions> {
   protected readonly log = $logger();
   protected readonly env = $env(envSchema);
   protected readonly alepha = $inject(Alepha);
@@ -186,7 +186,7 @@ export class SchedulerDescriptor extends Descriptor<SchedulerDescriptorOptions>
   });
 }
 
-$scheduler[KIND] = SchedulerDescriptor;
+$scheduler[KIND] = SchedulerPrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/scheduler/providers/CronProvider.ts

@@ -74,7 +74,7 @@ export class CronProvider {
   /**
    * Registers a cron job.
    *
-   * It's automatically done when using the `$scheduler` descriptor but can also be used manually.
+   * It's automatically done when using the `$scheduler` primitive but can also be used manually.
    */
   public createCronJob(
     name: string,

package/src/security/index.ts

@@ -1,20 +1,20 @@
 import { $module } from "alepha";
-import { $permission } from "./descriptors/$permission.ts";
-import { $realm } from "./descriptors/$realm.ts";
-import { $role } from "./descriptors/$role.ts";
+import { $permission } from "./primitives/$permission.ts";
+import { $realm } from "./primitives/$realm.ts";
+import { $role } from "./primitives/$role.ts";
 import { CryptoProvider } from "./providers/CryptoProvider.ts";
 import { JwtProvider } from "./providers/JwtProvider.ts";
 import { SecurityProvider } from "./providers/SecurityProvider.ts";
 import type { UserAccount } from "./schemas/userAccountInfoSchema.ts";
 
-export * from "./descriptors/$permission.ts";
-export * from "./descriptors/$realm.ts";
-export * from "./descriptors/$role.ts";
-export * from "./descriptors/$serviceAccount.ts";
 export * from "./errors/InvalidCredentialsError.ts";
 export * from "./errors/InvalidPermissionError.ts";
 export * from "./errors/SecurityError.ts";
 export * from "./interfaces/UserAccountToken.ts";
+export * from "./primitives/$permission.ts";
+export * from "./primitives/$realm.ts";
+export * from "./primitives/$role.ts";
+export * from "./primitives/$serviceAccount.ts";
 export * from "./providers/CryptoProvider.ts";
 export * from "./providers/JwtProvider.ts";
 export * from "./providers/SecurityProvider.ts";
@@ -34,7 +34,7 @@ declare module "alepha" {
 /**
  * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
  *
- * The security module enables building secure applications using descriptors like `$realm`, `$role`, and `$permission`
+ * The security module enables building secure applications using primitives like `$realm`, `$role`, and `$permission`
  * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
  * integration with various authentication providers and user management systems.
  *
@@ -45,6 +45,6 @@ declare module "alepha" {
  */
 export const AlephaSecurity = $module({
   name: "alepha.security",
-  descriptors: [$realm, $role, $permission],
+  primitives: [$realm, $role, $permission],
   services: [SecurityProvider, JwtProvider, CryptoProvider],
 });

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

@@ -1,4 +1,4 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import { SecurityProvider } from "../providers/SecurityProvider.ts";
 import type { UserAccount } from "../schemas/userAccountInfoSchema.ts";
 
@@ -6,14 +6,14 @@ import type { UserAccount } from "../schemas/userAccountInfoSchema.ts";
  * Create a new permission.
  */
 export const $permission = (
-  options: PermissionDescriptorOptions = {},
-): PermissionDescriptor => {
-  return createDescriptor(PermissionDescriptor, options);
+  options: PermissionPrimitiveOptions = {},
+): PermissionPrimitive => {
+  return createPrimitive(PermissionPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface PermissionDescriptorOptions {
+export interface PermissionPrimitiveOptions {
   /**
    * Name of the permission. Use Property name is not provided.
    */
@@ -32,7 +32,7 @@ export interface PermissionDescriptorOptions {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class PermissionDescriptor extends Descriptor<PermissionDescriptorOptions> {
+export class PermissionPrimitive extends Primitive<PermissionPrimitiveOptions> {
   protected readonly securityProvider = $inject(SecurityProvider);
 
   public get name(): string {
@@ -67,4 +67,4 @@ export class PermissionDescriptor extends Descriptor<PermissionDescriptorOptions
   }
 }
 
-$permission[KIND] = PermissionDescriptor;
+$permission[KIND] = PermissionPrimitive;

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);
     },
   });
 

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;
 
 // ---------------------------------------------------------------------------------------------------------------------