alepha 0.13.1 → 0.13.2

package/src/core/{descriptors → primitives}/$module.ts

@@ -2,11 +2,11 @@ import type { Alepha } from "../Alepha.ts";
 import { KIND } from "../constants/KIND.ts";
 import { MODULE } from "../constants/MODULE.ts";
 import { AlephaError } from "../errors/AlephaError.ts";
-import type { DescriptorFactoryLike } from "../helpers/descriptor.ts";
+import type { PrimitiveFactoryLike } from "../helpers/primitive.ts";
 import type { Service } from "../interfaces/Service.ts";
 
 /**
- * Wrap Services and Descriptors into a Module.
+ * Wrap Services and Primitives into a Module.
  *
  * - A module is just a Service with some extra {@link Module}.
  * - You must attach a `name` to it.
@@ -54,9 +54,9 @@ import type { Service } from "../interfaces/Service.ts";
  * Meaning that if you have 100 actions, you should have at least 3 modules.
  */
 export const $module = <T extends object = {}>(
-  options: ModuleDescriptorOptions,
+  options: ModulePrimitiveOptions,
 ): Service<Module> => {
-  const { services = [], descriptors = [], name } = options;
+  const { services = [], primitives = [], name } = options;
 
   // ensure name is valid
   if (!name || !Module.NAME_REGEX.test(name)) {
@@ -94,7 +94,7 @@ export const $module = <T extends object = {}>(
     }
   }
 
-  for (const factory of descriptors) {
+  for (const factory of primitives) {
     if (typeof factory[KIND] === "function") {
       factory[KIND][MODULE] = $;
     }
@@ -105,7 +105,7 @@ export const $module = <T extends object = {}>(
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface ModuleDescriptorOptions {
+export interface ModulePrimitiveOptions {
   /**
    * Name of the module.
    *
@@ -122,9 +122,9 @@ export interface ModuleDescriptorOptions {
   services?: Array<Service>;
 
   /**
-   * List of $descriptors to register in the module.
+   * List of $primitives to register in the module.
    */
-  descriptors?: Array<DescriptorFactoryLike>;
+  primitives?: Array<PrimitiveFactoryLike>;
 
   /**
    * By default, module will register ALL services.
@@ -140,7 +140,7 @@ export interface ModuleDescriptorOptions {
  * Base class for all modules.
  */
 export abstract class Module {
-  public abstract readonly options: ModuleDescriptorOptions;
+  public abstract readonly options: ModulePrimitiveOptions;
 
   public abstract register(alepha: Alepha): void;
 

package/src/core/{descriptors → primitives}/$use.ts

@@ -32,9 +32,9 @@ export const $use = <T extends TObject, N extends string>(
   const { alepha } = $context();
 
   // register atom in state if not already registered
-  alepha.state.register(atom);
+  alepha.store.register(atom);
 
-  const init = alepha.state.get(atom.key as keyof State) as object;
+  const init = alepha.store.get(atom.key as keyof State) as object;
 
   return {
     [OPTIONS]: { getter: atom.key }, // alepha will replace this with by a real 'get prop()'

package/src/core/providers/CodecManager.ts

@@ -1,6 +1,6 @@
 import type { StaticEncode, TSchema } from "typebox";
-import { $inject } from "../descriptors/$inject.ts";
 import { AlephaError } from "../errors/AlephaError.ts";
+import { $inject } from "../primitives/$inject.ts";
 import { JsonSchemaCodec } from "./JsonSchemaCodec.ts";
 import type { SchemaCodec } from "./SchemaCodec.ts";
 import { SchemaValidator, type ValidateOptions } from "./SchemaValidator.ts";

package/src/core/providers/JsonSchemaCodec.ts

@@ -1,5 +1,5 @@
 import type { TSchema } from "typebox";
-import { $inject } from "../descriptors/$inject.ts";
+import { $inject } from "../primitives/$inject.ts";
 import { Json } from "./Json.ts";
 import { SchemaCodec } from "./SchemaCodec.ts";
 import type { Static } from "./TypeProvider.ts";

package/src/core/providers/StateManager.ts

@@ -4,8 +4,8 @@ import {
   Atom,
   type AtomStatic,
   type TAtomObject,
-} from "../descriptors/$atom.ts";
-import { $inject } from "../descriptors/$inject.ts";
+} from "../primitives/$atom.ts";
+import { $inject } from "../primitives/$inject.ts";
 import { AlsProvider } from "./AlsProvider.ts";
 import { EventManager } from "./EventManager.ts";
 import { JsonSchemaCodec } from "./JsonSchemaCodec.ts";

package/src/datetime/index.ts

@@ -1,14 +1,14 @@
 import { $module } from "alepha";
-import { $interval } from "./descriptors/$interval.ts";
+import { $interval } from "./primitives/$interval.ts";
 import { DateTimeProvider } from "./providers/DateTimeProvider.ts";
 
-export * from "./descriptors/$interval.ts";
+export * from "./primitives/$interval.ts";
 export * from "./providers/DateTimeProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 export const AlephaDateTime = $module({
   name: "alepha.datetime",
-  descriptors: [$interval],
+  primitives: [$interval],
   services: [DateTimeProvider],
 });

package/src/datetime/{descriptors → primitives}/$interval.ts

@@ -1,4 +1,4 @@
-import { $inject, createDescriptor, Descriptor, KIND } from "alepha";
+import { $inject, createPrimitive, KIND, Primitive } from "alepha";
 import {
   DateTimeProvider,
   type DurationLike,
@@ -9,12 +9,12 @@ import {
  * It uses the `setInterval` internally.
  * It starts by default when the context starts and stops when the context stops.
  */
-export const $interval = (options: IntervalDescriptorOptions) =>
-  createDescriptor(IntervalDescriptor, options);
+export const $interval = (options: IntervalPrimitiveOptions) =>
+  createPrimitive(IntervalPrimitive, options);
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface IntervalDescriptorOptions {
+export interface IntervalPrimitiveOptions {
   /**
    * The interval handler.
    */
@@ -28,7 +28,7 @@ export interface IntervalDescriptorOptions {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export class IntervalDescriptor extends Descriptor<IntervalDescriptorOptions> {
+export class IntervalPrimitive extends Primitive<IntervalPrimitiveOptions> {
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
 
   public called = 0;
@@ -41,4 +41,4 @@ export class IntervalDescriptor extends Descriptor<IntervalDescriptorOptions> {
   }
 }
 
-$interval[KIND] = IntervalDescriptor;
+$interval[KIND] = IntervalPrimitive;

package/src/email/index.ts

@@ -1,5 +1,5 @@
 import { $module } from "alepha";
-import { $email } from "./descriptors/$email.ts";
+import { $email } from "./primitives/$email.ts";
 import { EmailProvider } from "./providers/EmailProvider.ts";
 import { LocalEmailProvider } from "./providers/LocalEmailProvider.ts";
 import { MemoryEmailProvider } from "./providers/MemoryEmailProvider.ts";
@@ -7,8 +7,8 @@ import { NodemailerEmailProvider } from "./providers/NodemailerEmailProvider.ts"
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$email.ts";
 export * from "./errors/EmailError.ts";
+export * from "./primitives/$email.ts";
 export * from "./providers/EmailProvider.ts";
 export * from "./providers/LocalEmailProvider.ts";
 export * from "./providers/MemoryEmailProvider.ts";
@@ -38,7 +38,7 @@ declare module "alepha" {
 /**
  * Provides email sending capabilities for Alepha applications with multiple provider backends.
  *
- * The email module enables declarative email sending through the `$email` descriptor, allowing you to send
+ * The email module enables declarative email sending through the `$email` primitive, allowing you to send
  * emails through different providers: memory (for testing), local file system, or SMTP via Nodemailer.
  * It supports HTML email content and automatic provider selection based on environment configuration.
  *
@@ -47,7 +47,7 @@ declare module "alepha" {
  */
 export const AlephaEmail = $module({
   name: "alepha.email",
-  descriptors: [$email],
+  primitives: [$email],
   services: [
     EmailProvider,
     MemoryEmailProvider,

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

@@ -1,8 +1,8 @@
 import {
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   type InstantiableClass,
   KIND,
+  Primitive,
 } from "alepha";
 import type { EmailSendOptions } from "../providers/EmailProvider.ts";
 import { EmailProvider } from "../providers/EmailProvider.ts";
@@ -10,12 +10,12 @@ import { MemoryEmailProvider } from "../providers/MemoryEmailProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export const $email = (options: EmailDescriptorOptions = {}) =>
-  createDescriptor(EmailDescriptor, options);
+export const $email = (options: EmailPrimitiveOptions = {}) =>
+  createPrimitive(EmailPrimitive, options);
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface EmailDescriptorOptions {
+export interface EmailPrimitiveOptions {
   name?: string;
   provider?: InstantiableClass<EmailProvider> | "memory";
 }
@@ -23,7 +23,7 @@ export interface EmailDescriptorOptions {
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * Email descriptor for sending emails through various providers.
+ * Email primitive for sending emails through various providers.
  *
  * Usage:
  * ```typescript
@@ -40,7 +40,7 @@ export interface EmailDescriptorOptions {
  * }
  * ```
  */
-export class EmailDescriptor extends Descriptor<EmailDescriptorOptions> {
+export class EmailPrimitive extends Primitive<EmailPrimitiveOptions> {
   protected readonly provider = this.$provider();
 
   public get name() {
@@ -83,4 +83,4 @@ export class EmailDescriptor extends Descriptor<EmailDescriptorOptions> {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-$email[KIND] = EmailDescriptor;
+$email[KIND] = EmailPrimitive;

package/src/file/index.ts

@@ -24,7 +24,7 @@ export * from "./services/FileDetector.ts";
  */
 export const AlephaFile = $module({
   name: "alepha.file",
-  descriptors: [],
+  primitives: [],
   services: [FileDetector, FileSystemProvider, NodeFileSystemProvider],
   register: (alepha) =>
     alepha.with({

package/src/lock/index.ts

@@ -1,13 +1,13 @@
 import { $module } from "alepha";
 import { MemoryTopicProvider } from "alepha/topic";
-import { $lock } from "./descriptors/$lock.ts";
+import { $lock } from "./primitives/$lock.ts";
 import { LockProvider } from "./providers/LockProvider.ts";
 import { LockTopicProvider } from "./providers/LockTopicProvider.ts";
 import { MemoryLockProvider } from "./providers/MemoryLockProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$lock.ts";
+export * from "./primitives/$lock.ts";
 export * from "./providers/LockProvider.ts";
 export * from "./providers/LockTopicProvider.ts";
 export * from "./providers/MemoryLockProvider.ts";
@@ -25,7 +25,7 @@ export * from "./providers/MemoryLockProvider.ts";
  */
 export const AlephaLock = $module({
   name: "alepha.lock",
-  descriptors: [$lock],
+  primitives: [$lock],
   services: [LockProvider, MemoryLockProvider, LockTopicProvider],
   register: (alepha) =>
     alepha

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

@@ -2,9 +2,9 @@ import {
   $env,
   $inject,
   type AsyncFn,
-  createDescriptor,
-  Descriptor,
+  createPrimitive,
   KIND,
+  Primitive,
   type Static,
   t,
 } from "alepha";
@@ -19,7 +19,7 @@ import { LockProvider } from "../providers/LockProvider.ts";
 import { LockTopicProvider } from "../providers/LockTopicProvider.ts";
 
 /**
- * Creates a distributed lock descriptor for ensuring single-instance execution across processes.
+ * Creates a distributed lock primitive for ensuring single-instance execution across processes.
  *
  * Prevents multiple instances of the same operation from running simultaneously, essential for
  * maintaining data consistency and preventing race conditions in distributed applications.
@@ -68,14 +68,14 @@ import { LockTopicProvider } from "../providers/LockTopicProvider.ts";
  * ```
  */
 export const $lock = <TFunc extends AsyncFn>(
-  options: LockDescriptorOptions<TFunc>,
-): LockDescriptor<TFunc> => {
-  return createDescriptor(LockDescriptor<TFunc>, options);
+  options: LockPrimitiveOptions<TFunc>,
+): LockPrimitive<TFunc> => {
+  return createPrimitive(LockPrimitive<TFunc>, options);
 };
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export interface LockDescriptorOptions<TFunc extends AsyncFn> {
+export interface LockPrimitiveOptions<TFunc extends AsyncFn> {
   /**
    * The function to execute when the lock is successfully acquired.
    *
@@ -295,8 +295,8 @@ declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 
-export class LockDescriptor<TFunc extends AsyncFn> extends Descriptor<
-  LockDescriptorOptions<TFunc>
+export class LockPrimitive<TFunc extends AsyncFn> extends Primitive<
+  LockPrimitiveOptions<TFunc>
 > {
   protected readonly log = $logger();
   protected readonly provider = $inject(LockProvider);
@@ -439,7 +439,7 @@ export class LockDescriptor<TFunc extends AsyncFn> extends Descriptor<
   }
 }
 
-$lock[KIND] = LockDescriptor;
+$lock[KIND] = LockPrimitive;
 
 export interface LockResult {
   id: string;

package/src/logger/index.ts

@@ -1,5 +1,5 @@
 import { $module, type Static, t } from "alepha";
-import { $logger } from "./descriptors/$logger.ts";
+import { $logger } from "./primitives/$logger.ts";
 import { ConsoleDestinationProvider } from "./providers/ConsoleDestinationProvider.ts";
 import { JsonFormatterProvider } from "./providers/JsonFormatterProvider.ts";
 import { LogDestinationProvider } from "./providers/LogDestinationProvider.ts";
@@ -12,7 +12,7 @@ import { Logger } from "./services/Logger.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./descriptors/$logger.ts";
+export * from "./primitives/$logger.ts";
 export * from "./providers/ConsoleColorProvider.ts";
 export * from "./providers/ConsoleDestinationProvider.ts";
 export * from "./providers/JsonFormatterProvider.ts";
@@ -28,7 +28,7 @@ export * from "./services/Logger.ts";
 /**
  * Minimalist logger module for Alepha.
  *
- * It offers a global logger interface (info, warn, ...) via the `$logger` descriptor.
+ * It offers a global logger interface (info, warn, ...) via the `$logger` primitive.
  *
  * ```ts
  * import { $logger } from "alepha/logger";
@@ -95,7 +95,7 @@ export * from "./services/Logger.ts";
  */
 export const AlephaLogger = $module({
   name: "alepha.logger",
-  descriptors: [$logger],
+  primitives: [$logger],
   services: [
     Logger,
     ConsoleDestinationProvider,
@@ -121,8 +121,8 @@ export const AlephaLogger = $module({
         };
 
         try {
-          alepha.state.get("alepha.test.afterEach")?.(printOnError);
-          alepha.state.get("alepha.test.onTestFinished")?.(printOnError);
+          alepha.store.get("alepha.test.afterEach")?.(printOnError);
+          alepha.store.get("alepha.test.onTestFinished")?.(printOnError);
         } catch {
           // ignore
         }
@@ -163,7 +163,7 @@ export const AlephaLogger = $module({
       use: getLogFormatterProvider(),
     });
 
-    alepha.state.set(
+    alepha.store.set(
       "alepha.logger",
       alepha.inject(Logger, {
         lifetime: "transient",
@@ -171,7 +171,7 @@ export const AlephaLogger = $module({
       }),
     );
 
-    alepha.state.set(
+    alepha.store.set(
       "alepha.logger.level",
       env.LOG_LEVEL ?? (alepha.isTest() ? "trace" : "info"),
     );

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;