alepha 0.13.1 → 0.13.2

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

package/src/server-cache/providers/ServerCacheProvider.ts

@@ -1,11 +1,11 @@
 import type { BinaryLike } from "node:crypto";
 import { createHash } from "node:crypto";
 import { $hook, $inject, Alepha } from "alepha";
-import { $cache, type CacheDescriptorOptions } from "alepha/cache";
+import { $cache, type CachePrimitiveOptions } from "alepha/cache";
 import { DateTimeProvider, type DurationLike } from "alepha/datetime";
 import { $logger } from "alepha/logger";
 import {
-  ActionDescriptor,
+  ActionPrimitive,
   type RequestConfigSchema,
   type ServerRequest,
   type ServerRoute,
@@ -25,13 +25,13 @@ declare module "alepha/server" {
     cache?: ServerRouteCache;
   }
 
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
+  interface ActionPrimitive<TConfig extends RequestConfigSchema> {
     invalidate: () => Promise<void>;
   }
 }
 
-ActionDescriptor.prototype.invalidate = async function (
-  this: ActionDescriptor<RequestConfigSchema>,
+ActionPrimitive.prototype.invalidate = async function (
+  this: ActionPrimitive<RequestConfigSchema>,
 ) {
   await this.alepha.inject(ServerCacheProvider).invalidate(this.route);
 };
@@ -422,11 +422,11 @@ export type ServerRouteCache =
       /**
        * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)
        * If a DurationLike is provided, it will be used as the TTL for the cache.
-       * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.
+       * If CachePrimitiveOptions is provided, it will be used to configure the cache storage.
        *
        * @default false
        */
-      store?: true | DurationLike | CacheDescriptorOptions;
+      store?: true | DurationLike | CachePrimitiveOptions;
       /**
        * If true, enables ETag support for the cached responses.
        */

package/src/server-compress/providers/ServerCompressProvider.ts

@@ -2,7 +2,7 @@ import { Readable, type Transform } from "node:stream";
 import { ReadableStream } from "node:stream/web";
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
-import { $hook, $inject, Alepha, type HookDescriptor } from "alepha";
+import { $hook, $inject, Alepha } from "alepha";
 import type { ServerResponse } from "alepha/server";
 
 const gzip = promisify(zlib.gzip);
@@ -55,11 +55,11 @@ export class ServerCompressProvider {
         "text/plain",
         "text/css",
       ],
-      ...this.alepha.state.get("alepha.server.compress.options"),
+      ...this.alepha.store.get("alepha.server.compress.options"),
     };
   }
 
-  public readonly onResponse: HookDescriptor<"server:onResponse"> = $hook({
+  public readonly onResponse = $hook({
     on: "server:onResponse",
     handler: async ({ request, response }) => {
       // skip if already compressed

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

@@ -3,12 +3,12 @@ import { AlephaServer } from "alepha/server";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$cookie.browser.ts";
+export * from "./primitives/$cookie.browser.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 export const AlephaServerCookies = $module({
   name: "alepha.server.cookies",
-  descriptors: [],
+  primitives: [],
   services: [AlephaServer],
 });

package/src/server-cookies/index.ts

@@ -1,11 +1,11 @@
 import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
-import { $cookie, type Cookies } from "./descriptors/$cookie.ts";
+import { $cookie, type Cookies } from "./primitives/$cookie.ts";
 import { ServerCookiesProvider } from "./providers/ServerCookiesProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$cookie.ts";
+export * from "./primitives/$cookie.ts";
 export * from "./providers/ServerCookiesProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -17,9 +17,9 @@ declare module "alepha/server" {
 }
 
 /**
- * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
+ * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie primitives.
  *
- * The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
+ * The server-cookies module enables declarative cookie handling using the `$cookie` primitive on class properties.
  * It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
  * for managing user sessions, preferences, and authentication tokens.
  *
@@ -28,6 +28,6 @@ declare module "alepha/server" {
  */
 export const AlephaServerCookies = $module({
   name: "alepha.server.cookies",
-  descriptors: [$cookie],
+  primitives: [$cookie],
   services: [AlephaServer, ServerCookiesProvider],
 });

package/src/server-cookies/{descriptors → primitives}/$cookie.browser.ts

@@ -2,23 +2,23 @@ import {
   $inject,
   Alepha,
   AlephaError,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Static,
   type TSchema,
 } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { CookieParser } from "../services/CookieParser.ts";
 import type {
-  AbstractCookieDescriptor,
+  AbstractCookiePrimitive,
   Cookie,
-  CookieDescriptorOptions,
+  CookiePrimitiveOptions,
   Cookies,
 } from "./$cookie.ts";
 
 /**
- * Creates a browser-side cookie descriptor for client-side cookie management.
+ * Creates a browser-side cookie primitive for client-side cookie management.
  *
  * Browser-specific version of $cookie that uses document.cookie API. Supports type-safe
  * cookie operations with schema validation but excludes encryption/signing (use server-side
@@ -46,16 +46,16 @@ import type {
  * ```
  */
 export const $cookie = <T extends TSchema>(
-  options: CookieDescriptorOptions<T>,
-): AbstractCookieDescriptor<T> => {
-  return createDescriptor(BrowserCookieDescriptor<T>, options);
+  options: CookiePrimitiveOptions<T>,
+): AbstractCookiePrimitive<T> => {
+  return createPrimitive(BrowserCookiePrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class BrowserCookieDescriptor<T extends TSchema>
-  extends Descriptor<CookieDescriptorOptions<T>>
-  implements AbstractCookieDescriptor<T>
+export class BrowserCookiePrimitive<T extends TSchema>
+  extends Primitive<CookiePrimitiveOptions<T>>
+  implements AbstractCookiePrimitive<T>
 {
   protected cookieParser = $inject(CookieParser);
   protected alepha = $inject(Alepha);
@@ -143,4 +143,4 @@ export class BrowserCookieDescriptor<T extends TSchema>
   }
 }
 
-$cookie[KIND] = BrowserCookieDescriptor;
+$cookie[KIND] = BrowserCookiePrimitive;

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

@@ -1,8 +1,8 @@
 import {
   $inject,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Static,
   type TSchema,
 } from "alepha";
@@ -11,18 +11,18 @@ import { ServerCookiesProvider } from "../providers/ServerCookiesProvider.ts";
 
 /**
  * Declares a type-safe, configurable HTTP cookie.
- * This descriptor provides methods to get, set, and delete the cookie
+ * This primitive provides methods to get, set, and delete the cookie
  * within the server request/response cycle.
  */
 export const $cookie = <T extends TSchema>(
-  options: CookieDescriptorOptions<T>,
-): AbstractCookieDescriptor<T> => {
-  return createDescriptor(CookieDescriptor<T>, options);
+  options: CookiePrimitiveOptions<T>,
+): AbstractCookiePrimitive<T> => {
+  return createPrimitive(CookiePrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface CookieDescriptorOptions<T extends TSchema> {
+export interface CookiePrimitiveOptions<T extends TSchema> {
   /** The schema for the cookie's value, used for validation and type safety. */
   schema: T;
 
@@ -57,9 +57,9 @@ export interface CookieDescriptorOptions<T extends TSchema> {
   sign?: boolean;
 }
 
-export interface AbstractCookieDescriptor<T extends TSchema> {
+export interface AbstractCookiePrimitive<T extends TSchema> {
   readonly name: string;
-  readonly options: CookieDescriptorOptions<T>;
+  readonly options: CookiePrimitiveOptions<T>;
   set(
     value: Static<T>,
     options?: { cookies?: Cookies; ttl?: DurationLike },
@@ -68,9 +68,9 @@ export interface AbstractCookieDescriptor<T extends TSchema> {
   del(options?: { cookies?: Cookies }): void;
 }
 
-export class CookieDescriptor<T extends TSchema>
-  extends Descriptor<CookieDescriptorOptions<T>>
-  implements AbstractCookieDescriptor<T>
+export class CookiePrimitive<T extends TSchema>
+  extends Primitive<CookiePrimitiveOptions<T>>
+  implements AbstractCookiePrimitive<T>
 {
   protected readonly serverCookiesProvider = $inject(ServerCookiesProvider);
 
@@ -119,7 +119,7 @@ export class CookieDescriptor<T extends TSchema>
   }
 }
 
-$cookie[KIND] = CookieDescriptor;
+$cookie[KIND] = CookiePrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/server-cookies/providers/ServerCookiesProvider.ts

@@ -21,9 +21,9 @@ import { DEFAULT_APP_SECRET } from "alepha/security";
 import type { ServerRequest } from "alepha/server";
 import type {
   Cookie,
-  CookieDescriptorOptions,
+  CookiePrimitiveOptions,
   Cookies,
-} from "../descriptors/$cookie.ts";
+} from "../primitives/$cookie.ts";
 import { CookieParser } from "../services/CookieParser.ts";
 
 const envSchema = t.object({
@@ -96,7 +96,7 @@ export class ServerCookiesProvider {
 
   public getCookie<T extends TSchema>(
     name: string,
-    options: CookieDescriptorOptions<T>,
+    options: CookiePrimitiveOptions<T>,
     contextCookies?: Cookies,
   ): Static<T> | undefined {
     const cookies = this.getCookiesFromContext(contextCookies);
@@ -145,7 +145,7 @@ export class ServerCookiesProvider {
 
   public setCookie<T extends TSchema>(
     name: string,
-    options: CookieDescriptorOptions<T>,
+    options: CookiePrimitiveOptions<T>,
     data: Static<T>,
     contextCookies?: Cookies,
   ): void {

package/src/server-cookies/services/CookieParser.ts

@@ -1,4 +1,4 @@
-import type { Cookie } from "../descriptors/$cookie.ts";
+import type { Cookie } from "../primitives/$cookie.ts";
 
 export class CookieParser {
   public parseRequestCookies(header: string): Record<string, string> {

package/src/server-cors/index.ts

@@ -1,5 +1,5 @@
 import { $module } from "alepha";
-import { $cors } from "./descriptors/$cors.ts";
+import { $cors } from "./primitives/$cors.ts";
 import {
   type CorsOptions,
   ServerCorsProvider,
@@ -7,7 +7,7 @@ import {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$cors.ts";
+export * from "./primitives/$cors.ts";
 export * from "./providers/ServerCorsProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -52,6 +52,6 @@ declare module "alepha/server" {
  */
 export const AlephaServerCors = $module({
   name: "alepha.server.cors",
-  descriptors: [$cors],
+  primitives: [$cors],
   services: [ServerCorsProvider],
 });

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

@@ -1,10 +1,10 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import type { CorsOptions } from "../providers/ServerCorsProvider.ts";
 import { ServerCorsProvider } from "../providers/ServerCorsProvider.ts";
 
 /**
  * Declares CORS configuration for specific server routes.
- * This descriptor provides path-based CORS configuration.
+ * This primitive provides path-based CORS configuration.
  *
  * @example
  * ```ts
@@ -18,15 +18,13 @@ import { ServerCorsProvider } from "../providers/ServerCorsProvider.ts";
  * }
  * ```
  */
-export const $cors = (
-  options: CorsDescriptorConfig,
-): AbstractCorsDescriptor => {
-  return createDescriptor(CorsDescriptor, options);
+export const $cors = (options: CorsPrimitiveConfig): AbstractCorsPrimitive => {
+  return createPrimitive(CorsPrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface CorsDescriptorConfig extends Partial<CorsOptions> {
+export interface CorsPrimitiveConfig extends Partial<CorsOptions> {
   /** Name identifier for this CORS config (default: property key) */
   name?: string;
   /** Path patterns to match (supports wildcards like /api/*) */
@@ -35,14 +33,14 @@ export interface CorsDescriptorConfig extends Partial<CorsOptions> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface AbstractCorsDescriptor {
+export interface AbstractCorsPrimitive {
   readonly name: string;
-  readonly options: CorsDescriptorConfig;
+  readonly options: CorsPrimitiveConfig;
 }
 
-export class CorsDescriptor
-  extends Descriptor<CorsDescriptorConfig>
-  implements AbstractCorsDescriptor
+export class CorsPrimitive
+  extends Primitive<CorsPrimitiveConfig>
+  implements AbstractCorsPrimitive
 {
   protected readonly serverCorsProvider = $inject(ServerCorsProvider);
 
@@ -56,4 +54,4 @@ export class CorsDescriptor
   }
 }
 
-$cors[KIND] = CorsDescriptor;
+$cors[KIND] = CorsPrimitive;

package/src/server-cors/providers/ServerCorsProvider.ts

@@ -1,7 +1,7 @@
 import { $atom, $hook, $inject, $use, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { ServerRouterProvider } from "alepha/server";
-import type { CorsDescriptorConfig } from "../descriptors/$cors.ts";
+import type { CorsPrimitiveConfig } from "../primitives/$cors.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -64,12 +64,12 @@ export class ServerCorsProvider {
   /**
    * Registered CORS configurations with their path patterns
    */
-  public readonly registeredConfigs: CorsDescriptorConfig[] = [];
+  public readonly registeredConfigs: CorsPrimitiveConfig[] = [];
 
   /**
-   * Register a CORS configuration (called by descriptors)
+   * Register a CORS configuration (called by primitives)
    */
-  public registerCors(config: CorsDescriptorConfig): void {
+  public registerCors(config: CorsPrimitiveConfig): void {
     this.registeredConfigs.push(config);
   }
 
@@ -132,7 +132,7 @@ export class ServerCorsProvider {
   /**
    * Build complete CORS options by merging with global defaults
    */
-  protected buildCorsOptions(config: CorsDescriptorConfig): CorsOptions {
+  protected buildCorsOptions(config: CorsPrimitiveConfig): CorsOptions {
     return {
       origin: config.origin ?? this.globalOptions.origin,
       methods: config.methods ?? this.globalOptions.methods,

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

@@ -1,12 +1,12 @@
 import { $module } from "alepha";
-import { $client } from "./descriptors/$client.ts";
-import { $remote } from "./descriptors/$remote.ts";
+import { $client } from "./primitives/$client.ts";
+import { $remote } from "./primitives/$remote.ts";
 import { LinkProvider } from "./providers/LinkProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$client.ts";
-export * from "./descriptors/$remote.ts";
+export * from "./primitives/$client.ts";
+export * from "./primitives/$remote.ts";
 export * from "./providers/LinkProvider.ts";
 export * from "./schemas/apiLinksResponseSchema.ts";
 
@@ -14,6 +14,6 @@ export * from "./schemas/apiLinksResponseSchema.ts";
 
 export const AlephaServerLinks = $module({
   name: "alepha.server.links",
-  descriptors: [$remote, $client],
+  primitives: [$remote, $client],
   services: [LinkProvider],
 });

package/src/server-links/index.ts

@@ -1,19 +1,19 @@
 import "alepha/server/security";
 import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
-import { $client } from "./descriptors/$client.ts";
-import { $remote } from "./descriptors/$remote.ts";
+import { $client } from "./primitives/$client.ts";
+import { $remote } from "./primitives/$remote.ts";
 import { LinkProvider } from "./providers/LinkProvider.ts";
-import { RemoteDescriptorProvider } from "./providers/RemoteDescriptorProvider.ts";
+import { RemotePrimitiveProvider } from "./providers/RemotePrimitiveProvider.ts";
 import { ServerLinksProvider } from "./providers/ServerLinksProvider.ts";
 import type { ApiLinksResponse } from "./schemas/apiLinksResponseSchema.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$client.ts";
-export * from "./descriptors/$remote.ts";
+export * from "./primitives/$client.ts";
+export * from "./primitives/$remote.ts";
 export * from "./providers/LinkProvider.ts";
-export * from "./providers/RemoteDescriptorProvider.ts";
+export * from "./providers/RemotePrimitiveProvider.ts";
 export * from "./providers/ServerLinksProvider.ts";
 export * from "./schemas/apiLinksResponseSchema.ts";
 
@@ -36,7 +36,7 @@ declare module "alepha" {
 /**
  * Provides server-side link management and remote capabilities for client-server interactions.
  *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
+ * The server-links module enables declarative link definitions using `$remote` and `$client` primitives,
  * facilitating seamless API endpoint management and client-server communication. It integrates with server
  * security features to ensure safe and controlled access to resources.
  *
@@ -46,11 +46,11 @@ declare module "alepha" {
  */
 export const AlephaServerLinks = $module({
   name: "alepha.server.links",
-  descriptors: [$remote, $client],
+  primitives: [$remote, $client],
   services: [
     AlephaServer,
     ServerLinksProvider,
-    RemoteDescriptorProvider,
+    RemotePrimitiveProvider,
     LinkProvider,
   ],
 });

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

@@ -1,9 +1,9 @@
-import { createDescriptor, Descriptor, KIND } from "alepha";
-import type { ServiceAccountDescriptor } from "alepha/security";
-import type { ProxyDescriptorOptions } from "alepha/server/proxy";
+import { createPrimitive, KIND, Primitive } from "alepha";
+import type { ServiceAccountPrimitive } from "alepha/security";
+import type { ProxyPrimitiveOptions } from "alepha/server/proxy";
 
 /**
- * $remote is a descriptor that allows you to define remote service access.
+ * $remote is a primitive that allows you to define remote service access.
  *
  * Use it only when you have 2 or more services that need to communicate with each other.
  *
@@ -11,11 +11,11 @@ import type { ProxyDescriptorOptions } from "alepha/server/proxy";
  *
  * You can add a service account if you want to use a security layer.
  */
-export const $remote = (options: RemoteDescriptorOptions) => {
-  return createDescriptor(RemoteDescriptor, options);
+export const $remote = (options: RemotePrimitiveOptions) => {
+  return createPrimitive(RemotePrimitive, options);
 };
 
-export interface RemoteDescriptorOptions {
+export interface RemotePrimitiveOptions {
   /**
    * The URL of the remote service.
    * You can use a function to generate the URL dynamically.
@@ -52,7 +52,7 @@ export interface RemoteDescriptorOptions {
   proxy?:
     | boolean
     | Partial<
-        ProxyDescriptorOptions & {
+        ProxyPrimitiveOptions & {
           /**
            * If true, the remote service won't be available internally, only through the proxy.
            */
@@ -64,13 +64,13 @@ export interface RemoteDescriptorOptions {
    * For communication between the server and the remote service with a security layer.
    * This will be used for internal communication and will not be exposed to the client.
    */
-  serviceAccount?: ServiceAccountDescriptor;
+  serviceAccount?: ServiceAccountPrimitive;
 }
 
-export class RemoteDescriptor extends Descriptor<RemoteDescriptorOptions> {
+export class RemotePrimitive extends Primitive<RemotePrimitiveOptions> {
   public get name(): string {
     return this.options.name ?? this.config.propertyKey;
   }
 }
 
-$remote[KIND] = RemoteDescriptor;
+$remote[KIND] = RemotePrimitive;