alepha 0.13.1 → 0.13.3

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

@@ -20,7 +20,7 @@ import { Logger } from "../services/Logger.ts";
  * }
  * ```
  */
-export const $logger = (options: LoggerDescriptorOptions = {}): Logger => {
+export const $logger = (options: LoggerPrimitiveOptions = {}): Logger => {
   const { alepha, service, module } = $context();
 
   return $inject(Logger, {
@@ -32,7 +32,7 @@ export const $logger = (options: LoggerDescriptorOptions = {}): Logger => {
   });
 };
 
-export interface LoggerDescriptorOptions {
+export interface LoggerPrimitiveOptions {
   name?: string;
 }
 

package/src/logger/services/Logger.ts

@@ -43,7 +43,7 @@ export class Logger implements LoggerInterface {
   }
 
   public get level(): string {
-    const stateLogLevel = this.alepha.state.get("alepha.logger.level");
+    const stateLogLevel = this.alepha.store.get("alepha.logger.level");
     if (stateLogLevel && stateLogLevel !== this.appLogLevel) {
       this.appLogLevel = stateLogLevel;
       this.logLevel = this.parseLevel(this.appLogLevel, this.module);

package/src/orm/constants/PG_SYMBOLS.ts

@@ -2,7 +2,7 @@ import type {
   PgSequenceOptions,
   UpdateDeleteAction,
 } from "drizzle-orm/pg-core";
-import type { EntityDescriptor } from "../descriptors/$entity.ts";
+import type { EntityPrimitive } from "../primitives/$entity.ts";
 
 export const PG_DEFAULT = Symbol.for("Alepha.Postgres.Default");
 export const PG_PRIMARY_KEY = Symbol.for("Alepha.Postgres.PrimaryKey");
@@ -56,7 +56,7 @@ export interface PgEnumOptions {
 export interface PgRefOptions {
   ref: () => {
     name: string;
-    entity: EntityDescriptor;
+    entity: EntityPrimitive;
   };
   actions?: {
     onUpdate?: UpdateDeleteAction;

package/src/orm/index.browser.ts

@@ -9,13 +9,13 @@ export {
   pageQuerySchema,
   pageSchema,
 } from "alepha";
-export * from "./descriptors/$entity.ts";
 export * from "./errors/DbEntityNotFoundError.ts";
 export * from "./helpers/parseQueryString.ts";
 export * from "./helpers/pgAttr.ts";
 export * from "./interfaces/FilterOperators.ts";
 export * from "./interfaces/PgQuery.ts";
 export * from "./interfaces/PgQueryWhere.ts";
+export * from "./primitives/$entity.ts";
 export * from "./providers/PostgresTypeProvider.ts";
 export * from "./schemas/legacyIdSchema.ts";
 
@@ -23,6 +23,6 @@ export * from "./schemas/legacyIdSchema.ts";
 
 export const AlephaPostgres = $module({
   name: "alepha.postgres",
-  descriptors: [],
+  primitives: [],
   services: [AlephaDateTime],
 });

package/src/orm/index.ts

@@ -1,9 +1,9 @@
 import { $module, type Alepha, t } from "alepha";
 import { AlephaDateTime } from "alepha/datetime";
 import * as drizzle from "drizzle-orm";
-import { $entity } from "./descriptors/$entity.ts";
-import { $repository } from "./descriptors/$repository.ts";
-import { $sequence } from "./descriptors/$sequence.ts";
+import { $entity } from "./primitives/$entity.ts";
+import { $repository } from "./primitives/$repository.ts";
+import { $sequence } from "./primitives/$sequence.ts";
 import { DrizzleKitProvider } from "./providers/DrizzleKitProvider.ts";
 import { DatabaseProvider } from "./providers/drivers/DatabaseProvider.ts";
 import { NodePostgresProvider } from "./providers/drivers/NodePostgresProvider.ts";
@@ -95,10 +95,6 @@ export {
 export { sql } from "drizzle-orm";
 export * from "drizzle-orm/pg-core";
 export * from "./constants/PG_SYMBOLS.ts";
-export * from "./descriptors/$entity.ts";
-export * from "./descriptors/$repository.ts";
-export * from "./descriptors/$sequence.ts";
-export * from "./descriptors/$transaction.ts";
 export * from "./errors/DbConflictError.ts";
 export * from "./errors/DbEntityNotFoundError.ts";
 export * from "./errors/DbError.ts";
@@ -109,6 +105,10 @@ export * from "./helpers/pgAttr.ts";
 export * from "./interfaces/FilterOperators.ts";
 export * from "./interfaces/PgQuery.ts";
 export * from "./interfaces/PgQueryWhere.ts";
+export * from "./primitives/$entity.ts";
+export * from "./primitives/$repository.ts";
+export * from "./primitives/$sequence.ts";
+export * from "./primitives/$transaction.ts";
 export * from "./providers/DrizzleKitProvider.ts";
 export * from "./providers/drivers/DatabaseProvider.ts";
 export * from "./providers/drivers/NodePostgresProvider.ts";
@@ -164,7 +164,7 @@ export * from "./types/schema.ts";
  */
 export const AlephaPostgres = $module({
   name: "alepha.postgres",
-  descriptors: [$sequence, $entity],
+  primitives: [$sequence, $entity],
   services: [
     AlephaDateTime,
     DatabaseProvider,

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

@@ -9,7 +9,7 @@ import { insertSchema, type TObjectInsert } from "../schemas/insertSchema.ts";
 import { type TObjectUpdate, updateSchema } from "../schemas/updateSchema.ts";
 
 /**
- * Creates a database entity descriptor that defines table structure using TypeBox schemas.
+ * Creates a database entity primitive that defines table structure using TypeBox schemas.
  *
  * @example
  * ```ts
@@ -27,14 +27,14 @@ import { type TObjectUpdate, updateSchema } from "../schemas/updateSchema.ts";
  * ```
  */
 export const $entity = <TSchema extends TObject>(
-  options: EntityDescriptorOptions<TSchema>,
-): EntityDescriptor<TSchema> => {
-  return new EntityDescriptor<TSchema>(options);
+  options: EntityPrimitiveOptions<TSchema>,
+): EntityPrimitive<TSchema> => {
+  return new EntityPrimitive<TSchema>(options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface EntityDescriptorOptions<
+export interface EntityPrimitiveOptions<
   T extends TObject,
   Keys = keyof Static<T>,
 > {
@@ -163,15 +163,15 @@ export interface EntityDescriptorOptions<
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class EntityDescriptor<T extends TObject = TObject> {
-  public readonly options: EntityDescriptorOptions<T>;
+export class EntityPrimitive<T extends TObject = TObject> {
+  public readonly options: EntityPrimitiveOptions<T>;
 
-  constructor(options: EntityDescriptorOptions<T>) {
+  constructor(options: EntityPrimitiveOptions<T>) {
     this.options = options;
   }
 
   alias(alias: string): this {
-    const aliased = new EntityDescriptor<T>(this.options);
+    const aliased = new EntityPrimitive<T>(this.options);
     return new Proxy(aliased, {
       get(target, prop, receiver) {
         if (prop === "$alias") {
@@ -213,7 +213,7 @@ export class EntityDescriptor<T extends TObject = TObject> {
   }
 }
 
-$entity[KIND] = EntityDescriptor;
+$entity[KIND] = EntityPrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -235,7 +235,7 @@ export type SchemaToTableConfig<T extends TObject> = {
 
 export type EntityColumn<T extends TObject> = {
   name: string;
-  entity: EntityDescriptor<T>;
+  entity: EntityPrimitive<T>;
 };
 
 export type EntityColumns<T extends TObject> = {

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

@@ -1,13 +1,13 @@
 import { $context, $inject, type TObject } from "alepha";
 import { RepositoryProvider } from "../providers/RepositoryProvider.ts";
 import type { Repository } from "../services/Repository.ts";
-import type { EntityDescriptor } from "./$entity.ts";
+import type { EntityPrimitive } from "./$entity.ts";
 
 /**
  * Get the repository for the given entity.
  */
 export const $repository = <T extends TObject>(
-  entity: EntityDescriptor<T>,
+  entity: EntityPrimitive<T>,
 ): Repository<T> => {
   const { alepha } = $context();
   const repositoryProvider = alepha.inject(RepositoryProvider);

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

@@ -1,20 +1,20 @@
-import { createDescriptor, Descriptor, KIND } from "alepha";
+import { createPrimitive, KIND, Primitive } from "alepha";
 import { sql } from "drizzle-orm";
 import type { PgSequenceOptions } from "drizzle-orm/pg-core";
 import { DatabaseProvider } from "../providers/drivers/DatabaseProvider.ts";
 
 /**
- * Creates a PostgreSQL sequence descriptor for generating unique numeric values.
+ * Creates a PostgreSQL sequence primitive for generating unique numeric values.
  */
 export const $sequence = (
-  options: SequenceDescriptorOptions = {},
-): SequenceDescriptor => {
-  return createDescriptor(SequenceDescriptor, options);
+  options: SequencePrimitiveOptions = {},
+): SequencePrimitive => {
+  return createPrimitive(SequencePrimitive, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface SequenceDescriptorOptions extends PgSequenceOptions {
+export interface SequencePrimitiveOptions extends PgSequenceOptions {
   /**
    * The name of the sequence. If not provided, the property key will be used.
    */
@@ -25,7 +25,7 @@ export interface SequenceDescriptorOptions extends PgSequenceOptions {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
+export class SequencePrimitive extends Primitive<SequencePrimitiveOptions> {
   public readonly provider = this.$provider();
 
   public onInit() {
@@ -57,4 +57,4 @@ export class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
   }
 }
 
-$sequence[KIND] = SequenceDescriptor;
+$sequence[KIND] = SequencePrimitive;

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/providers/drivers/NodeSqliteProvider.ts

@@ -82,10 +82,10 @@ export class NodeSqliteProvider extends DatabaseProvider {
       return path;
     }
 
-    if (this.alepha.isTest()) {
+    if (this.alepha.isTest() || this.alepha.isServerless()) {
       return ":memory:";
     } else {
-      return "node_modules/sqlite.db";
+      return "node_modules/.alepha/sqlite.db";
     }
   }
 
@@ -149,7 +149,7 @@ export class NodeSqliteProvider extends DatabaseProvider {
       if (filepath !== ":memory:" && filepath !== "") {
         const dirname = filepath.split("/").slice(0, -1).join("/");
         if (dirname) {
-          await mkdir(dirname, { recursive: true });
+          await mkdir(dirname, { recursive: true }).catch(() => null);
         }
       }
 

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