alepha 0.13.0 → 0.13.2

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;

package/src/server-links/providers/LinkProvider.ts

@@ -1,7 +1,7 @@
 import { $inject, Alepha, AlephaError, type Async, t } from "alepha";
 import { $logger } from "alepha/logger";
 import {
-  type ActionDescriptor,
+  type ActionPrimitive,
   type ClientRequestEntry,
   type ClientRequestOptions,
   type ClientRequestResponse,
@@ -79,7 +79,7 @@ export class LinkProvider {
 
   public get links(): HttpClientLink[] {
     // TODO: not performant at all, use a map instead for ServerLinks
-    const apiLinks = this.alepha.state.get(
+    const apiLinks = this.alepha.store.get(
       "alepha.server.request.apiLinks",
     )?.links;
     if (apiLinks) {
@@ -114,7 +114,7 @@ export class LinkProvider {
       },
     );
 
-    this.alepha.state.set("alepha.server.request.apiLinks", data);
+    this.alepha.store.set("alepha.server.request.apiLinks", data);
 
     return data.links;
   }
@@ -277,7 +277,7 @@ export class LinkProvider {
   ): Promise<HttpClientLink> {
     if (
       this.alepha.isBrowser() &&
-      !this.alepha.state.get("alepha.server.request.apiLinks")
+      !this.alepha.store.get("alepha.server.request.apiLinks")
     ) {
       await this.fetchLinks();
     }
@@ -334,15 +334,15 @@ export interface ClientScope {
 }
 
 export type HttpVirtualClient<T> = {
-  [K in keyof T as T[K] extends ActionDescriptor<RequestConfigSchema>
+  [K in keyof T as T[K] extends ActionPrimitive<RequestConfigSchema>
     ? K
-    : never]: T[K] extends ActionDescriptor<infer Schema>
+    : never]: T[K] extends ActionPrimitive<infer Schema>
     ? VirtualAction<Schema>
     : never;
 };
 
 export interface VirtualAction<T extends RequestConfigSchema>
-  extends Pick<ActionDescriptor<T>, "name" | "run" | "fetch"> {
+  extends Pick<ActionPrimitive<T>, "name" | "run" | "fetch"> {
   (
     config?: ClientRequestEntry<T>,
     opts?: ClientRequestOptions,

package/src/server-links/providers/{RemoteDescriptorProvider.ts → RemotePrimitiveProvider.ts}

@@ -1,9 +1,9 @@
 import { $env, $hook, $inject, Alepha, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { $retry } from "alepha/retry";
-import type { ServiceAccountDescriptor } from "alepha/security";
+import type { ServiceAccountPrimitive } from "alepha/security";
 import { ServerProxyProvider } from "alepha/server/proxy";
-import { $remote, type RemoteDescriptor } from "../descriptors/$remote.ts";
+import { $remote, type RemotePrimitive } from "../primitives/$remote.ts";
 import {
   type ApiLinksResponse,
   apiLinksResponseSchema,
@@ -17,7 +17,7 @@ const envSchema = t.object({
   }),
 });
 
-export class RemoteDescriptorProvider {
+export class RemotePrimitiveProvider {
   protected readonly env = $env(envSchema);
   protected readonly alepha = $inject(Alepha);
   protected readonly proxyProvider = $inject(ServerProxyProvider);
@@ -32,7 +32,7 @@ export class RemoteDescriptorProvider {
   public readonly configure = $hook({
     on: "configure",
     handler: async () => {
-      const remotes = this.alepha.descriptors($remote);
+      const remotes = this.alepha.primitives($remote);
       for (const remote of remotes) {
         await this.registerRemote(remote);
       }
@@ -78,7 +78,7 @@ export class RemoteDescriptorProvider {
     },
   });
 
-  public async registerRemote(value: RemoteDescriptor): Promise<void> {
+  public async registerRemote(value: RemotePrimitive): Promise<void> {
     const options = value.options;
     const url = typeof options.url === "string" ? options.url : options.url();
     const linkPath = LinkProvider.path.apiLinks;
@@ -225,7 +225,7 @@ export interface ServerRemote {
   /**
    * Force a default access token provider when not provided.
    */
-  serviceAccount?: ServiceAccountDescriptor;
+  serviceAccount?: ServiceAccountPrimitive;
 
   /**
    * Prefix for the remote service links.

package/src/server-links/providers/ServerLinksProvider.ts

@@ -18,7 +18,7 @@ import {
   apiLinksResponseSchema,
 } from "../schemas/apiLinksResponseSchema.ts";
 import { LinkProvider } from "./LinkProvider.ts";
-import { RemoteDescriptorProvider } from "./RemoteDescriptorProvider.ts";
+import { RemotePrimitiveProvider } from "./RemotePrimitiveProvider.ts";
 
 const envSchema = t.object({
   SERVER_API_PREFIX: t.text({
@@ -31,7 +31,7 @@ export class ServerLinksProvider {
   protected readonly env = $env(envSchema);
   protected readonly alepha = $inject(Alepha);
   protected readonly linkProvider = $inject(LinkProvider);
-  protected readonly remoteProvider = $inject(RemoteDescriptorProvider);
+  protected readonly remoteProvider = $inject(RemotePrimitiveProvider);
   protected readonly serverTimingProvider = $inject(ServerTimingProvider);
 
   public get prefix() {
@@ -42,7 +42,7 @@ export class ServerLinksProvider {
     on: "configure",
     handler: () => {
       // convert all $action to local links
-      for (const action of this.alepha.descriptors($action)) {
+      for (const action of this.alepha.primitives($action)) {
         this.linkProvider.registerLink({
           name: action.name,
           group: action.group,