alepha 0.13.1 → 0.13.2

package/src/orm/{descriptors → primitives}/$transaction.ts

@@ -6,9 +6,9 @@ import { DbVersionMismatchError } from "../errors/DbVersionMismatchError.ts";
 import { DatabaseProvider } from "../providers/drivers/DatabaseProvider.ts";
 
 /**
- * Creates a transaction descriptor for database operations requiring atomicity and consistency.
+ * Creates a transaction primitive for database operations requiring atomicity and consistency.
  *
- * This descriptor provides a convenient way to wrap database operations in PostgreSQL
+ * This primitive provides a convenient way to wrap database operations in PostgreSQL
  * transactions, ensuring ACID properties and automatic retry logic for version conflicts.
  * It integrates seamlessly with the repository pattern and provides built-in handling
  * for optimistic locking scenarios with automatic retry on version mismatches.
@@ -21,7 +21,7 @@ import { DatabaseProvider } from "../providers/drivers/DatabaseProvider.ts";
  * - Use appropriate isolation levels based on your consistency requirements
  */
 export const $transaction = <T extends any[], R>(
-  opts: TransactionDescriptorOptions<T, R>,
+  opts: TransactionPrimitiveOptions<T, R>,
 ) => {
   const { alepha } = $context();
   const provider = alepha.inject(DatabaseProvider);
@@ -38,7 +38,7 @@ export const $transaction = <T extends any[], R>(
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface TransactionDescriptorOptions<T extends any[], R> {
+export interface TransactionPrimitiveOptions<T extends any[], R> {
   /**
    * Transaction handler function that contains all database operations to be executed atomically.
    *

package/src/orm/providers/PostgresTypeProvider.ts

@@ -159,9 +159,9 @@ export class PostgresTypeProvider {
    *
    * This is used to track the version of a row in the database.
    *
-   * You can use it for optimistic concurrency control (OCC) with {@link RepositoryDescriptor#save}.
+   * You can use it for optimistic concurrency control (OCC) with {@link RepositoryPrimitive#save}.
    *
-   * @see {@link RepositoryDescriptor#save}
+   * @see {@link RepositoryPrimitive#save}
    * @see {@link PgVersionMismatchError}
    */
   public readonly version = (options: TNumberOptions = {}) =>
@@ -239,7 +239,7 @@ export class PostgresTypeProvider {
 
   /**
    * Creates a page schema for a given object schema.
-   * It's used by {@link RepositoryDescriptor#paginate} method.
+   * It's used by {@link RepositoryPrimitive#paginate} method.
    */
   public readonly page = <T extends TObject>(
     resource: T,

package/src/orm/providers/RepositoryProvider.ts

@@ -1,12 +1,12 @@
 import { $inject, Alepha, type Service, type TObject } from "alepha";
-import type { EntityDescriptor } from "../descriptors/$entity.ts";
+import type { EntityPrimitive } from "../primitives/$entity.ts";
 import { Repository } from "../services/Repository.ts";
 import type { DatabaseProvider } from "./drivers/DatabaseProvider.ts";
 
 export class RepositoryProvider {
   protected readonly alepha = $inject(Alepha);
   protected readonly registry = new Map<
-    EntityDescriptor<any>,
+    EntityPrimitive<any>,
     Service<Repository<any>>
   >();
 
@@ -21,14 +21,14 @@ export class RepositoryProvider {
   }
 
   public getRepository<T extends TObject>(
-    entity: EntityDescriptor<T>,
+    entity: EntityPrimitive<T>,
   ): Repository<T> {
     const RepositoryClass = this.createClassRepository(entity);
     return this.alepha.inject(RepositoryClass);
   }
 
   public createClassRepository<T extends TObject>(
-    entity: EntityDescriptor<T>,
+    entity: EntityPrimitive<T>,
   ): Service<Repository<T>> {
     let name = entity.name.charAt(0).toUpperCase() + entity.name.slice(1);
     if (name.endsWith("s")) {

package/src/orm/providers/drivers/DatabaseProvider.ts

@@ -13,12 +13,12 @@ import {
   type PgDatabase,
   type PgTableWithColumns,
 } from "drizzle-orm/pg-core";
+import { DbError } from "../../errors/DbError.ts";
 import type {
-  EntityDescriptor,
+  EntityPrimitive,
   SchemaToTableConfig,
-} from "../../descriptors/$entity.ts";
-import type { SequenceDescriptor } from "../../descriptors/$sequence.ts";
-import { DbError } from "../../errors/DbError.ts";
+} from "../../primitives/$entity.ts";
+import type { SequencePrimitive } from "../../primitives/$sequence.ts";
 import type { ModelBuilder } from "../../services/ModelBuilder.ts";
 import type { DrizzleKitProvider } from "../DrizzleKitProvider.ts";
 
@@ -46,7 +46,7 @@ export abstract class DatabaseProvider {
   }
 
   public table<T extends TObject>(
-    entity: EntityDescriptor<T>,
+    entity: EntityPrimitive<T>,
   ): PgTableWithColumns<SchemaToTableConfig<T>> {
     const table = this.tables.get(entity.name);
     if (!table) {
@@ -65,11 +65,11 @@ export abstract class DatabaseProvider {
     return table as PgTableWithColumns<SchemaToTableConfig<T>>;
   }
 
-  public registerEntity(entity: EntityDescriptor) {
+  public registerEntity(entity: EntityPrimitive) {
     this.builder.buildTable(entity, this);
   }
 
-  public registerSequence(sequence: SequenceDescriptor) {
+  public registerSequence(sequence: SequencePrimitive) {
     this.builder.buildSequence(sequence, this);
   }
 

package/src/orm/services/ModelBuilder.ts

@@ -1,6 +1,6 @@
 import type { SQL } from "drizzle-orm";
-import type { EntityDescriptor } from "../descriptors/$entity.ts";
-import type { SequenceDescriptor } from "../descriptors/$sequence.ts";
+import type { EntityPrimitive } from "../primitives/$entity.ts";
+import type { SequencePrimitive } from "../primitives/$sequence.ts";
 
 /**
  * Database-specific table configuration functions
@@ -24,15 +24,15 @@ export interface TableConfigBuilders<TConfig> {
 }
 
 /**
- * Abstract base class for transforming Alepha Descriptors (Entity, Sequence, etc...)
+ * Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
  * into drizzle models (tables, enums, sequences, etc...).
  */
 export abstract class ModelBuilder {
   /**
-   * Build a table from an entity descriptor.
+   * Build a table from an entity primitive.
    */
   abstract buildTable(
-    entity: EntityDescriptor,
+    entity: EntityPrimitive,
     options: {
       tables: Map<string, unknown>;
       enums: Map<string, unknown>;
@@ -41,10 +41,10 @@ export abstract class ModelBuilder {
   ): void;
 
   /**
-   * Build a sequence from a sequence descriptor.
+   * Build a sequence from a sequence primitive.
    */
   abstract buildSequence(
-    sequence: SequenceDescriptor,
+    sequence: SequencePrimitive,
     options: {
       sequences: Map<string, unknown>;
       schema: string;
@@ -65,13 +65,13 @@ export abstract class ModelBuilder {
    * Build the table configuration function for any database.
    * This includes indexes, foreign keys, constraints, and custom config.
    *
-   * @param entity - The entity descriptor
+   * @param entity - The entity primitive
    * @param builders - Database-specific builder functions
    * @param tableResolver - Function to resolve entity references to table columns
    * @param customConfigHandler - Optional handler for custom config
    */
   protected buildTableConfig<TConfig, TSelf>(
-    entity: EntityDescriptor,
+    entity: EntityPrimitive,
     builders: TableConfigBuilders<TConfig>,
     tableResolver?: (entityName: string) => any,
     customConfigHandler?: (config: any, self: TSelf) => TConfig[],

package/src/orm/services/PgRelationManager.ts

@@ -2,8 +2,8 @@ import { type TObject, TypeBoxValue, t } from "alepha";
 import { getTableName, type SQL, sql } from "drizzle-orm";
 import type { PgSelectBase, PgTableWithColumns } from "drizzle-orm/pg-core";
 import { isSQLWrapper } from "drizzle-orm/sql/sql";
-import type { EntityDescriptor } from "../descriptors/$entity.ts";
 import type { PgRelationMap } from "../interfaces/PgQuery.ts";
+import type { EntityPrimitive } from "../primitives/$entity.ts";
 import type { DatabaseProvider } from "../providers/drivers/DatabaseProvider.ts";
 import type { PgJoin } from "./QueryManager.ts";
 
@@ -20,7 +20,7 @@ export class PgRelationManager {
     parentKey?: string,
   ) {
     for (const [key, join] of Object.entries(withRelations)) {
-      const from = provider.table(join.join as EntityDescriptor);
+      const from = provider.table(join.join as EntityPrimitive);
       const on = isSQLWrapper(join.on)
         ? (join.on as SQL)
         : sql`${table[join.on[0] as string]} = ${from[join.on[1].name]}`;

package/src/orm/services/PostgresModelBuilder.ts

@@ -27,8 +27,8 @@ import {
   type PgIdentityOptions,
   type PgRefOptions,
 } from "../constants/PG_SYMBOLS.ts";
-import type { EntityDescriptor, FromSchema } from "../descriptors/$entity.ts";
-import type { SequenceDescriptor } from "../descriptors/$sequence.ts";
+import type { EntityPrimitive, FromSchema } from "../primitives/$entity.ts";
+import type { SequencePrimitive } from "../primitives/$sequence.ts";
 import { byte } from "../types/byte.ts";
 import { schema } from "../types/schema.ts";
 import { ModelBuilder } from "./ModelBuilder.ts";
@@ -57,7 +57,7 @@ export class PostgresModelBuilder extends ModelBuilder {
   }
 
   public buildTable(
-    entity: EntityDescriptor<any>,
+    entity: EntityPrimitive<any>,
     options: {
       tables: Map<string, unknown>;
       enums: Map<string, unknown>;
@@ -88,7 +88,7 @@ export class PostgresModelBuilder extends ModelBuilder {
   }
 
   public buildSequence(
-    sequence: SequenceDescriptor,
+    sequence: SequencePrimitive,
     options: {
       sequences: Map<string, unknown>;
       schema: string;
@@ -113,7 +113,7 @@ export class PostgresModelBuilder extends ModelBuilder {
    * Get PostgreSQL-specific config builder for the table.
    */
   protected getTableConfig(
-    entity: EntityDescriptor,
+    entity: EntityPrimitive,
     tables: Map<string, unknown>,
   ):
     | ((

package/src/orm/services/Repository.ts

@@ -30,10 +30,6 @@ import {
   PG_UPDATED_AT,
   PG_VERSION,
 } from "../constants/PG_SYMBOLS.ts";
-import type {
-  EntityDescriptor,
-  SchemaToTableConfig,
-} from "../descriptors/$entity.ts";
 import { DbConflictError } from "../errors/DbConflictError.ts";
 import { DbEntityNotFoundError } from "../errors/DbEntityNotFoundError.ts";
 import { DbError } from "../errors/DbError.ts";
@@ -49,6 +45,10 @@ import type {
   PgQueryWhere,
   PgQueryWhereOrSQL,
 } from "../interfaces/PgQueryWhere.ts";
+import type {
+  EntityPrimitive,
+  SchemaToTableConfig,
+} from "../primitives/$entity.ts";
 import {
   DatabaseProvider,
   type SQLLike,
@@ -59,7 +59,7 @@ import { PgRelationManager } from "./PgRelationManager.ts";
 import { type PgJoin, QueryManager } from "./QueryManager.ts";
 
 export abstract class Repository<T extends TObject> {
-  public readonly entity: EntityDescriptor<T>;
+  public readonly entity: EntityPrimitive<T>;
   public readonly provider: DatabaseProvider;
 
   protected readonly relationManager = $inject(PgRelationManager);
@@ -67,10 +67,10 @@ export abstract class Repository<T extends TObject> {
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
   protected readonly alepha = $inject(Alepha);
 
-  constructor(entity: EntityDescriptor<T>, provider = DatabaseProvider) {
+  constructor(entity: EntityPrimitive<T>, provider = DatabaseProvider) {
     this.entity = entity;
     this.provider = this.alepha.inject(provider);
-    this.provider.registerEntity(entity as EntityDescriptor);
+    this.provider.registerEntity(entity as EntityPrimitive);
   }
 
   /**

package/src/orm/services/SqliteModelBuilder.ts

@@ -28,13 +28,13 @@ import {
   PG_UPDATED_AT,
   type PgRefOptions,
 } from "../constants/PG_SYMBOLS.ts";
-import type { EntityDescriptor } from "../descriptors/$entity.ts";
-import type { SequenceDescriptor } from "../descriptors/$sequence.ts";
+import type { EntityPrimitive } from "../primitives/$entity.ts";
+import type { SequencePrimitive } from "../primitives/$sequence.ts";
 import { ModelBuilder } from "./ModelBuilder.ts";
 
 export class SqliteModelBuilder extends ModelBuilder {
   public buildTable(
-    entity: EntityDescriptor<any>,
+    entity: EntityPrimitive<any>,
     options: {
       tables: Map<string, unknown>;
       enums: Map<string, unknown>;
@@ -62,7 +62,7 @@ export class SqliteModelBuilder extends ModelBuilder {
   }
 
   public buildSequence(
-    sequence: SequenceDescriptor,
+    sequence: SequencePrimitive,
     options: {
       sequences: Map<string, unknown>;
       schema: string;
@@ -75,7 +75,7 @@ export class SqliteModelBuilder extends ModelBuilder {
    * Get SQLite-specific config builder for the table.
    */
   protected getTableConfig(
-    entity: EntityDescriptor,
+    entity: EntityPrimitive,
     tables: Map<string, unknown>,
   ): ((self: BuildColumns<string, any, "sqlite">) => any) | undefined {
     // SQLite-specific builders

package/src/queue/index.ts

@@ -1,15 +1,15 @@
 import { $module, type Alepha } from "alepha";
-import { $consumer } from "./descriptors/$consumer.ts";
-import { $queue } from "./descriptors/$queue.ts";
+import { $consumer } from "./primitives/$consumer.ts";
+import { $queue } from "./primitives/$queue.ts";
 import { MemoryQueueProvider } from "./providers/MemoryQueueProvider.ts";
 import { QueueProvider } from "./providers/QueueProvider.ts";
 import { WorkerProvider } from "./providers/WorkerProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$consumer.ts";
-export * from "./descriptors/$queue.ts";
 export * from "./interfaces/QueueJob.ts";
+export * from "./primitives/$consumer.ts";
+export * from "./primitives/$queue.ts";
 export * from "./providers/MemoryQueueProvider.ts";
 export * from "./providers/QueueProvider.ts";
 export * from "./providers/WorkerProvider.ts";
@@ -17,9 +17,9 @@ export * from "./providers/WorkerProvider.ts";
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * Provides asynchronous message queuing and processing capabilities through declarative queue descriptors.
+ * Provides asynchronous message queuing and processing capabilities through declarative queue primitives.
  *
- * The queue module enables reliable background job processing and message passing using the `$queue` descriptor
+ * The queue module enables reliable background job processing and message passing using the `$queue` primitive
  * on class properties. It supports schema validation, automatic retries, and multiple queue backends for
  * building scalable, decoupled applications with robust error handling.
  *
@@ -29,7 +29,7 @@ export * from "./providers/WorkerProvider.ts";
  */
 export const AlephaQueue = $module({
   name: "alepha.queue",
-  descriptors: [$queue, $consumer],
+  primitives: [$queue, $consumer],
   services: [QueueProvider, MemoryQueueProvider, WorkerProvider],
   register: (alepha: Alepha) =>
     alepha

package/src/queue/{descriptors → primitives}/$consumer.ts

@@ -1,21 +1,21 @@
 import {
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Static,
   type TSchema,
 } from "alepha";
-import type { QueueDescriptor } from "./$queue.ts";
+import type { QueuePrimitive } from "./$queue.ts";
 
 /**
- * Creates a consumer descriptor to process messages from a specific queue.
+ * Creates a consumer primitive to process messages from a specific queue.
  *
  * Provides a dedicated message consumer that connects to a queue and processes messages
  * with custom handler logic, enabling scalable architectures where multiple consumers
  * can process messages from the same queue.
  *
  * **Key Features**
- * - Seamless integration with any $queue descriptor
+ * - Seamless integration with any $queue primitive
  * - Full type safety inherited from queue schema
  * - Automatic worker management for background processing
  * - Built-in error handling and retry mechanisms
@@ -57,16 +57,16 @@ import type { QueueDescriptor } from "./$queue.ts";
  * ```
  */
 export const $consumer = <T extends TSchema>(
-  options: ConsumerDescriptorOptions<T>,
-): ConsumerDescriptor<T> => {
-  return createDescriptor(ConsumerDescriptor<T>, options);
+  options: ConsumerPrimitiveOptions<T>,
+): ConsumerPrimitive<T> => {
+  return createPrimitive(ConsumerPrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface ConsumerDescriptorOptions<T extends TSchema> {
+export interface ConsumerPrimitiveOptions<T extends TSchema> {
   /**
-   * The queue descriptor that this consumer will process messages from.
+   * The queue primitive that this consumer will process messages from.
    *
    * This establishes the connection between the consumer and its source queue:
    * - The consumer inherits the queue's message schema for type safety
@@ -90,12 +90,12 @@ export interface ConsumerDescriptorOptions<T extends TSchema> {
    *
    * // Then, create a consumer for that queue
    * emailConsumer = $consumer({
-   *   queue: this.emailQueue,  // Reference the queue descriptor
+   *   queue: this.emailQueue,  // Reference the queue primitive
    *   handler: async (message) => { } // process email
    * });
    * ```
    */
-  queue: QueueDescriptor<T>;
+  queue: QueuePrimitive<T>;
 
   /**
    * Message handler function that processes individual messages from the queue.
@@ -175,8 +175,8 @@ export interface ConsumerDescriptorOptions<T extends TSchema> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class ConsumerDescriptor<T extends TSchema> extends Descriptor<
-  ConsumerDescriptorOptions<T>
+export class ConsumerPrimitive<T extends TSchema> extends Primitive<
+  ConsumerPrimitiveOptions<T>
 > {}
 
-$consumer[KIND] = ConsumerDescriptor;
+$consumer[KIND] = ConsumerPrimitive;

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

@@ -1,7 +1,7 @@
 import {
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Service,
   type Static,
   type TSchema,
@@ -15,9 +15,9 @@ import { MemoryQueueProvider } from "../providers/MemoryQueueProvider.ts";
 import { QueueProvider } from "../providers/QueueProvider.ts";
 
 /**
- * Creates a queue descriptor for asynchronous message processing with background workers.
+ * Creates a queue primitive for asynchronous message processing with background workers.
  *
- * The $queue descriptor enables powerful asynchronous communication patterns in your application.
+ * The $queue primitive enables powerful asynchronous communication patterns in your application.
  * It provides type-safe message queuing with automatic worker processing, making it perfect for
  * decoupling components and handling background tasks efficiently.
  *
@@ -126,14 +126,14 @@ import { QueueProvider } from "../providers/QueueProvider.ts";
  * ```
  */
 export const $queue = <T extends TSchema>(
-  options: QueueDescriptorOptions<T>,
-): QueueDescriptor<T> => {
-  return createDescriptor(QueueDescriptor<T>, options);
+  options: QueuePrimitiveOptions<T>,
+): QueuePrimitive<T> => {
+  return createPrimitive(QueuePrimitive<T>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface QueueDescriptorOptions<T extends TSchema> {
+export interface QueuePrimitiveOptions<T extends TSchema> {
   /**
    * Unique name for the queue.
    *
@@ -337,8 +337,8 @@ export interface QueueDescriptorOptions<T extends TSchema> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class QueueDescriptor<T extends TSchema> extends Descriptor<
-  QueueDescriptorOptions<T>
+export class QueuePrimitive<T extends TSchema> extends Primitive<
+  QueuePrimitiveOptions<T>
 > {
   protected readonly log = $logger();
   public readonly provider = this.$provider();
@@ -415,7 +415,7 @@ export class QueueDescriptor<T extends TSchema> extends Descriptor<
   }
 
   /**
-   * Get default job options from descriptor configuration.
+   * Get default job options from primitive configuration.
    */
   protected getDefaultJobOptions() {
     return {
@@ -442,7 +442,7 @@ export class QueueDescriptor<T extends TSchema> extends Descriptor<
   }
 }
 
-$queue[KIND] = QueueDescriptor;
+$queue[KIND] = QueuePrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 

package/src/queue/providers/WorkerProvider.ts

@@ -9,13 +9,13 @@ import {
 } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
-import { $consumer } from "../descriptors/$consumer.ts";
+import type { QueueAcquiredJob } from "../interfaces/QueueJob.ts";
+import { $consumer } from "../primitives/$consumer.ts";
 import {
   $queue,
-  type QueueDescriptor,
   type QueueMessage,
-} from "../descriptors/$queue.ts";
-import type { QueueAcquiredJob } from "../interfaces/QueueJob.ts";
+  type QueuePrimitive,
+} from "../primitives/$queue.ts";
 import { QueueProvider } from "./QueueProvider.ts";
 
 const envSchema = t.object({
@@ -83,7 +83,7 @@ export class WorkerProvider {
     on: "start",
     priority: "last",
     handler: () => {
-      for (const queue of this.alepha.descriptors($queue)) {
+      for (const queue of this.alepha.primitives($queue)) {
         const handler = queue.options.handler;
         if (handler) {
           this.consumers.push({
@@ -93,7 +93,7 @@ export class WorkerProvider {
         }
       }
 
-      for (const consumer of this.alepha.descriptors($consumer)) {
+      for (const consumer of this.alepha.primitives($consumer)) {
         this.consumers.push(consumer.options);
       }
 
@@ -333,7 +333,7 @@ export class WorkerProvider {
 }
 
 export interface Consumer<T extends TSchema = TSchema> {
-  queue: QueueDescriptor<T>;
+  queue: QueuePrimitive<T>;
   handler: (message: QueueMessage<T>) => Promise<void>;
 }
 

package/src/retry/index.ts

@@ -1,12 +1,12 @@
 import { $module } from "alepha";
-import { $retry } from "./descriptors/$retry.ts";
+import { $retry } from "./primitives/$retry.ts";
 import { RetryProvider } from "./providers/RetryProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$retry.ts";
 export * from "./errors/RetryCancelError.ts";
 export * from "./errors/RetryTimeoutError.ts";
+export * from "./primitives/$retry.ts";
 export * from "./providers/RetryProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -19,6 +19,6 @@ export * from "./providers/RetryProvider.ts";
  */
 export const AlephaRetry = $module({
   name: "alepha.retry",
-  descriptors: [$retry],
+  primitives: [$retry],
   services: [RetryProvider],
 });

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

@@ -1,9 +1,9 @@
 import {
   $inject,
-  createDescriptor,
-  Descriptor,
-  type DescriptorArgs,
+  createPrimitive,
   KIND,
+  Primitive,
+  type PrimitiveArgs,
 } from "alepha";
 import type { DurationLike } from "alepha/datetime";
 import type { RetryBackoffOptions } from "../providers/RetryProvider.ts";
@@ -14,16 +14,16 @@ import { RetryProvider } from "../providers/RetryProvider.ts";
  * with support for exponential backoff, max duration, and cancellation.
  */
 export const $retry = <T extends (...args: any[]) => any>(
-  options: RetryDescriptorOptions<T>,
-): RetryDescriptorFn<T> => {
-  const instance = createDescriptor(RetryDescriptor, options);
+  options: RetryPrimitiveOptions<T>,
+): RetryPrimitiveFn<T> => {
+  const instance = createPrimitive(RetryPrimitive, options);
   const fn = (...args: Parameters<T>) => instance.run(...args);
-  return Object.setPrototypeOf(fn, instance) as RetryDescriptorFn<T>;
+  return Object.setPrototypeOf(fn, instance) as RetryPrimitiveFn<T>;
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
+export interface RetryPrimitiveOptions<T extends (...args: any[]) => any> {
   /**
    * The function to retry.
    */
@@ -72,13 +72,13 @@ export interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class RetryDescriptor<
+export class RetryPrimitive<
   T extends (...args: any[]) => any,
-> extends Descriptor<RetryDescriptorOptions<T>> {
+> extends Primitive<RetryPrimitiveOptions<T>> {
   protected readonly retryProvider = $inject(RetryProvider);
   protected appAbortController?: AbortController;
 
-  constructor(args: DescriptorArgs<RetryDescriptorOptions<T>>) {
+  constructor(args: PrimitiveArgs<RetryPrimitiveOptions<T>>) {
     super(args);
 
     this.alepha.events.on("stop", () => {
@@ -100,9 +100,9 @@ export class RetryDescriptor<
   }
 }
 
-export interface RetryDescriptorFn<T extends (...args: any[]) => any>
-  extends RetryDescriptor<T> {
+export interface RetryPrimitiveFn<T extends (...args: any[]) => any>
+  extends RetryPrimitive<T> {
   (...args: Parameters<T>): Promise<ReturnType<T>>;
 }
 
-$retry[KIND] = RetryDescriptor;
+$retry[KIND] = RetryPrimitive;

package/src/scheduler/index.ts

@@ -1,13 +1,13 @@
 import { $module } from "alepha";
 import type { DateTime } from "alepha/datetime";
 import { AlephaLock } from "alepha/lock";
-import { $scheduler } from "./descriptors/$scheduler.ts";
+import { $scheduler } from "./primitives/$scheduler.ts";
 import { CronProvider } from "./providers/CronProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 export * from "./constants/CRON.ts";
-export * from "./descriptors/$scheduler.ts";
+export * from "./primitives/$scheduler.ts";
 export * from "./providers/CronProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -42,6 +42,6 @@ declare module "alepha" {
  */
 export const AlephaScheduler = $module({
   name: "alepha.scheduler",
-  descriptors: [$scheduler],
+  primitives: [$scheduler],
   services: [AlephaLock, CronProvider],
 });