alepha 0.13.6 → 0.13.8

package/src/core/providers/TypeProvider.ts

@@ -24,29 +24,21 @@ import type {
   TUnion,
   TUnsafe,
 } from "typebox";
-import * as TypeBox from "typebox";
 import { Type } from "typebox";
 import type {
   TLocalizedValidationError,
   TLocalizedValidationMessageCallback,
 } from "typebox/error";
-import TypeBoxFormat from "typebox/format";
+import Format from "typebox/format";
 import { Locale } from "typebox/system";
-import * as TypeBoxValue from "typebox/value";
+import * as Value from "typebox/value";
 import { OPTIONS } from "../constants/OPTIONS.ts";
 import { AlephaError } from "../errors/AlephaError.ts";
 import type { TypeBoxError } from "../errors/TypeBoxError.ts";
 import { isTypeFile, type TFile, type TStream } from "../helpers/FileLike.ts";
 
-export { TypeBox, TypeBoxValue, TypeBoxFormat };
-
-export const isUUID = TypeBoxFormat.IsUuid;
-export const isEmail = TypeBoxFormat.IsEmail;
-export const isURL = TypeBoxFormat.IsUrl;
-export const isDateTime = TypeBoxFormat.IsDateTime;
-export const isDate = TypeBoxFormat.IsDate;
-export const isTime = TypeBoxFormat.IsTime;
-export const isDuration = TypeBoxFormat.IsDuration;
+export { Type, Value, Format };
+export const isUUID = Format.IsUuid;
 
 export type {
   StaticDecode,
@@ -82,26 +74,26 @@ export type {
 export class TypeGuard {
   // -------------------------------------------------------------------------------------------------------------------
   isBigInt = (value: TSchema): value is TString =>
-    TypeBox.IsString(value) && "format" in value && value.format === "bigint";
+    Type.IsString(value) && "format" in value && value.format === "bigint";
   isUUID = (value: TSchema): value is TString =>
-    TypeBox.IsString(value) && "format" in value && value.format === "uuid";
-  isObject = TypeBox.IsObject;
-  isNumber = TypeBox.IsNumber;
-  isString = TypeBox.IsString;
-  isBoolean = TypeBox.IsBoolean;
-  isAny = TypeBox.IsAny;
-  isArray = TypeBox.IsArray;
-  isOptional = TypeBox.IsOptional;
-  isUnion = TypeBox.IsUnion;
-  isInteger = TypeBox.IsInteger;
-  isNull = TypeBox.IsNull;
-  isUndefined = TypeBox.IsUndefined;
-  isUnsafe = TypeBox.IsUnsafe;
-  isRecord = TypeBox.IsRecord;
-  isTuple = TypeBox.IsTuple;
-  isVoid = TypeBox.IsVoid;
-  isLiteral = TypeBox.IsLiteral;
-  isSchema = TypeBox.IsSchema;
+    Type.IsString(value) && "format" in value && value.format === "uuid";
+  isObject = Type.IsObject;
+  isNumber = Type.IsNumber;
+  isString = Type.IsString;
+  isBoolean = Type.IsBoolean;
+  isAny = Type.IsAny;
+  isArray = Type.IsArray;
+  isOptional = Type.IsOptional;
+  isUnion = Type.IsUnion;
+  isInteger = Type.IsInteger;
+  isNull = Type.IsNull;
+  isUndefined = Type.IsUndefined;
+  isUnsafe = Type.IsUnsafe;
+  isRecord = Type.IsRecord;
+  isTuple = Type.IsTuple;
+  isVoid = Type.IsVoid;
+  isLiteral = Type.IsLiteral;
+  isSchema = Type.IsSchema;
   // -------------------------------------------------------------------------------------------------------------------
   isFile = isTypeFile;
   isDateTime = (schema: unknown) => {
@@ -131,10 +123,10 @@ declare module "typebox" {
 }
 
 export class TypeProvider {
-  static format = TypeBoxFormat;
+  static format = Format;
 
   static {
-    TypeBoxFormat.Set("bigint", (value: string | number) =>
+    Format.Set("bigint", (value: string | number) =>
       TypeProvider.isValidBigInt(value),
     );
   }
@@ -398,7 +390,7 @@ export class TypeProvider {
    * Create a schema for a JSON object.
    * This is a record with string keys and any values.
    */
-  public json(options?: TSchemaOptions): TRecord<string, TAny> {
+  public json<T = any>(options?: TSchemaOptions): TRecord<string, TAny> {
     return t.record(t.text(), t.any(), options);
   }
 

package/src/logger/index.ts

@@ -1,12 +1,13 @@
 import { $module, type Static, t } from "alepha";
 import { $logger } from "./primitives/$logger.ts";
+import { ConsoleColorProvider } from "./providers/ConsoleColorProvider.ts";
 import { ConsoleDestinationProvider } from "./providers/ConsoleDestinationProvider.ts";
 import { JsonFormatterProvider } from "./providers/JsonFormatterProvider.ts";
 import { LogDestinationProvider } from "./providers/LogDestinationProvider.ts";
 import { LogFormatterProvider } from "./providers/LogFormatterProvider.ts";
 import { MemoryDestinationProvider } from "./providers/MemoryDestinationProvider.ts";
+import { PrettyFormatterProvider } from "./providers/PrettyFormatterProvider.ts";
 import { RawFormatterProvider } from "./providers/RawFormatterProvider.ts";
-import { SimpleFormatterProvider } from "./providers/SimpleFormatterProvider.ts";
 import type { LogEntry } from "./schemas/logEntrySchema.ts";
 import { Logger } from "./services/Logger.ts";
 
@@ -19,7 +20,7 @@ export * from "./providers/JsonFormatterProvider.ts";
 export * from "./providers/LogDestinationProvider.ts";
 export * from "./providers/LogFormatterProvider.ts";
 export * from "./providers/MemoryDestinationProvider.ts";
-export * from "./providers/SimpleFormatterProvider.ts";
+export * from "./providers/PrettyFormatterProvider.ts";
 export * from "./schemas/logEntrySchema.ts";
 export * from "./services/Logger.ts";
 
@@ -101,8 +102,9 @@ export const AlephaLogger = $module({
     ConsoleDestinationProvider,
     MemoryDestinationProvider,
     JsonFormatterProvider,
-    SimpleFormatterProvider,
+    PrettyFormatterProvider,
     RawFormatterProvider,
+    ConsoleColorProvider,
   ],
   register: (alepha) => {
     const env = alepha.parseEnv(envSchema);
@@ -141,14 +143,14 @@ export const AlephaLogger = $module({
         if (env.LOG_FORMAT === "raw") {
           return RawFormatterProvider;
         }
-        return SimpleFormatterProvider;
+        return PrettyFormatterProvider;
       }
 
       if (alepha.isProduction() && !alepha.isBrowser()) {
         return JsonFormatterProvider;
       }
 
-      return SimpleFormatterProvider;
+      return PrettyFormatterProvider;
     };
 
     alepha.with({
@@ -202,7 +204,7 @@ const envSchema = t.object({
   /**
    * Built-in log formats.
    * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
-   * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
+   * - "pretty" - Simple text format, human-readable, with colors. {@link PrettyFormatterProvider}
    * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
    */
   LOG_FORMAT: t.optional(

package/src/logger/primitives/$logger.ts

@@ -26,7 +26,7 @@ export const $logger = (options: LoggerPrimitiveOptions = {}): Logger => {
   return $inject(Logger, {
     lifetime: "transient",
     args: [
-      options.name ?? service?.name,
+      options.name ?? service?.name ?? "Func",
       module?.name ?? alepha.env.MODULE_NAME ?? "app",
     ],
   });

package/src/logger/providers/{SimpleFormatterProvider.ts → PrettyFormatterProvider.ts}

@@ -3,7 +3,7 @@ import type { LogEntry } from "../schemas/logEntrySchema.ts";
 import { ConsoleColorProvider } from "./ConsoleColorProvider.ts";
 import { LogFormatterProvider } from "./LogFormatterProvider.ts";
 
-export class SimpleFormatterProvider extends LogFormatterProvider {
+export class PrettyFormatterProvider extends LogFormatterProvider {
   protected color = $inject(ConsoleColorProvider);
   protected alepha = $inject(Alepha);
 
@@ -107,6 +107,15 @@ export class SimpleFormatterProvider extends LogFormatterProvider {
       return "";
     }
 
+    if (this.alepha.isViteDev()) {
+      // Node.js - try to fix stack trace with Vite SSR helper
+      // Actually, it works only because we have a global helper in viteAlephaDev.ts
+      const gl = globalThis as Record<string, unknown>;
+      if (typeof gl === "object" && typeof gl.ssrFixStacktrace === "function") {
+        gl.ssrFixStacktrace(error);
+      }
+    }
+
     let str = error.stack ?? error.message;
 
     const anyError = error as any;

package/src/orm/index.ts

@@ -10,7 +10,10 @@ import { NodePostgresProvider } from "./providers/drivers/NodePostgresProvider.t
 import { NodeSqliteProvider } from "./providers/drivers/NodeSqliteProvider.ts";
 import { PglitePostgresProvider } from "./providers/drivers/PglitePostgresProvider.ts";
 import { RepositoryProvider } from "./providers/RepositoryProvider.ts";
+import { PgJsonQueryManager } from "./services/PgJsonQueryManager.ts";
+import { PgRelationManager } from "./services/PgRelationManager.ts";
 import { PostgresModelBuilder } from "./services/PostgresModelBuilder.ts";
+import { QueryManager } from "./services/QueryManager.ts";
 import { Repository } from "./services/Repository.ts";
 import { SqliteModelBuilder } from "./services/SqliteModelBuilder.ts";
 
@@ -176,6 +179,9 @@ export const AlephaPostgres = $module({
     DrizzleKitProvider,
     RepositoryProvider,
     Repository,
+    PgRelationManager,
+    PgJsonQueryManager,
+    QueryManager,
   ],
   register: (alepha: Alepha) => {
     const env = alepha.parseEnv(

package/src/orm/services/PgRelationManager.ts

@@ -1,4 +1,4 @@
-import { type TObject, TypeBoxValue, t } from "alepha";
+import { type TObject, t, Value } 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";
@@ -103,7 +103,7 @@ export class PgRelationManager {
     joins: PgJoin[],
     parentPath?: string,
   ): TObject {
-    const schema = TypeBoxValue.Clone(baseSchema) as TObject;
+    const schema = Value.Clone(baseSchema) as TObject;
 
     // Group joins by parent
     const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);

package/src/orm/services/PostgresModelBuilder.ts

@@ -279,6 +279,13 @@ export class PostgresModelBuilder extends ModelBuilder {
       return schema(key, value);
     }
 
+    const isTypeEnum = (value: any): value is { enum: any[] } =>
+      t.schema.isUnsafe(value) &&
+      "type" in value &&
+      value.type === "string" &&
+      "enum" in value &&
+      Array.isArray(value.enum);
+
     if (t.schema.isArray(value)) {
       if (t.schema.isObject(value.items)) {
         return schema(key, value);
@@ -298,16 +305,13 @@ export class PostgresModelBuilder extends ModelBuilder {
       if (t.schema.isBoolean(value.items)) {
         return pg.boolean(key).array();
       }
+      if (isTypeEnum(value.items)) {
+        return pg.text(key).array();
+      }
     }
 
     // Enum handling
-    if (
-      t.schema.isUnsafe(value) &&
-      "type" in value &&
-      value.type === "string" &&
-      "enum" in value &&
-      Array.isArray(value.enum)
-    ) {
+    if (isTypeEnum(value)) {
       if (!value.enum.every((it) => typeof it === "string")) {
         throw new AlephaError(
           `Enum for ${fieldName} must be an array of strings, got ${JSON.stringify(

package/src/orm/services/Repository.ts

@@ -546,13 +546,15 @@ export abstract class Repository<T extends TObject> {
   /**
    * Create many entities.
    *
+   * Inserts are batched in chunks of 1000 to avoid hitting database limits.
+   *
    * @param values The entities to create.
    * @param opts The statement options.
    * @returns The created entities.
    */
   public async createMany(
     values: Array<Static<TObjectInsert<T>>>,
-    opts: StatementOptions = {},
+    opts: StatementOptions & { batchSize?: number } = {},
   ): Promise<Static<T>[]> {
     if (values.length === 0) {
       return [];
@@ -563,19 +565,26 @@ export abstract class Repository<T extends TObject> {
       data: values,
     });
 
+    const batchSize = opts.batchSize ?? 1000;
+    const allEntities: Static<T>[] = [];
+
     try {
-      const entities = await this.rawInsert(opts)
-        .values(values.map((data) => this.cast(data, true)))
-        .returning(this.table)
-        .then((rows) => rows.map((it) => this.clean(it, this.entity.schema)));
+      for (let i = 0; i < values.length; i += batchSize) {
+        const batch = values.slice(i, i + batchSize);
+        const entities = await this.rawInsert(opts)
+          .values(batch.map((data) => this.cast(data, true)))
+          .returning(this.table)
+          .then((rows) => rows.map((it) => this.clean(it, this.entity.schema)));
+        allEntities.push(...entities);
+      }
 
       await this.alepha.events.emit("repository:create:after", {
         tableName: this.tableName,
         data: values,
-        entity: entities,
+        entity: allEntities,
       });
 
-      return entities;
+      return allEntities;
     } catch (error) {
       throw this.handleError(error, "Insert query has failed");
     }

package/src/orm/services/SqliteModelBuilder.ts

@@ -190,6 +190,16 @@ export class SqliteModelBuilder extends ModelBuilder {
       return pg.integer(key);
     }
 
+    if (t.schema.isBigInt(value)) {
+      if (PG_PRIMARY_KEY in value || PG_IDENTITY in value) {
+        return pg
+          .integer(key, { mode: "number" })
+          .primaryKey({ autoIncrement: true });
+      }
+
+      return pg.integer(key, { mode: "number" });
+    }
+
     if (t.schema.isNumber(value)) {
       if (PG_IDENTITY in value) {
         return pg

package/src/queue/{index.ts → core/index.ts}

@@ -7,7 +7,6 @@ import { WorkerProvider } from "./providers/WorkerProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./interfaces/QueueJob.ts";
 export * from "./primitives/$consumer.ts";
 export * from "./primitives/$queue.ts";
 export * from "./providers/MemoryQueueProvider.ts";
@@ -17,9 +16,9 @@ export * from "./providers/WorkerProvider.ts";
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * Provides asynchronous message queuing and processing capabilities through declarative queue primitives.
+ * Provides asynchronous message queuing and processing capabilities through declarative queue descriptors.
  *
- * The queue module enables reliable background job processing and message passing using the `$queue` primitive
+ * The queue module enables reliable background job processing and message passing using the `$queue` descriptor
  * on class properties. It supports schema validation, automatic retries, and multiple queue backends for
  * building scalable, decoupled applications with robust error handling.
  *

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

@@ -1,4 +1,5 @@
 import {
+  $inject,
   createPrimitive,
   KIND,
   Primitive,
@@ -7,12 +8,9 @@ import {
   type TSchema,
 } from "alepha";
 import { $logger } from "alepha/logger";
-import type {
-  QueueAddJobOptions,
-  QueueJobBackoff,
-} from "../interfaces/QueueJob.ts";
 import { MemoryQueueProvider } from "../providers/MemoryQueueProvider.ts";
 import { QueueProvider } from "../providers/QueueProvider.ts";
+import { WorkerProvider } from "../providers/WorkerProvider.ts";
 
 /**
  * Creates a queue primitive for asynchronous message processing with background workers.
@@ -256,83 +254,6 @@ export interface QueuePrimitiveOptions<T extends TSchema> {
    * ```
    */
   handler?: (message: QueueMessage<T>) => Promise<void>;
-
-  // ===========================================
-  // Job Options (for crash recovery and retries)
-  // ===========================================
-
-  /**
-   * Maximum number of processing attempts before the job is marked as failed.
-   * Includes the initial attempt.
-   *
-   * Set this to enable automatic retries on failure.
-   *
-   * @default 1 (no retries)
-   * @example 3 // Allows 2 retries after initial failure
-   */
-  maxAttempts?: number;
-
-  /**
-   * Backoff configuration for retries.
-   * Controls the delay between retry attempts.
-   *
-   * @example
-   * ```ts
-   * backoff: {
-   *   type: "exponential",
-   *   delay: 1000,      // Initial delay: 1 second
-   *   maxDelay: 60000   // Maximum delay: 1 minute
-   * }
-   * ```
-   */
-  backoff?: QueueJobBackoff;
-
-  /**
-   * Maximum time in milliseconds a job can be processed before it's considered stalled.
-   * If the worker doesn't complete or extend the lock within this time, the job
-   * can be picked up by another worker.
-   *
-   * Increase this for long-running jobs.
-   *
-   * @default 30000 (30 seconds)
-   */
-  lockDuration?: number;
-
-  /**
-   * Automatically remove jobs when they complete successfully.
-   * - `true`: Remove immediately after completion
-   * - `false`: Keep in completed list (default)
-   * - `number`: Keep this many most recent completed jobs, remove older ones
-   *
-   * @default false
-   * @example
-   * ```ts
-   * // Remove immediately after completion
-   * removeOnComplete: true
-   *
-   * // Keep only the last 100 completed jobs
-   * removeOnComplete: 100
-   * ```
-   */
-  removeOnComplete?: boolean | number;
-
-  /**
-   * Automatically remove jobs when they fail permanently (after all retries exhausted).
-   * - `true`: Remove immediately after failure
-   * - `false`: Keep in failed list (default)
-   * - `number`: Keep this many most recent failed jobs, remove older ones
-   *
-   * @default false
-   * @example
-   * ```ts
-   * // Remove immediately after failure
-   * removeOnFail: true
-   *
-   * // Keep only the last 50 failed jobs for debugging
-   * removeOnFail: 50
-   * ```
-   */
-  removeOnFail?: boolean | number;
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -341,90 +262,24 @@ export class QueuePrimitive<T extends TSchema> extends Primitive<
   QueuePrimitiveOptions<T>
 > {
   protected readonly log = $logger();
+  protected readonly workerProvider = $inject(WorkerProvider);
   public readonly provider = this.$provider();
 
-  /**
-   * Push one or more payloads to the queue for background processing.
-   *
-   * Jobs will be processed with crash recovery, retries (if configured),
-   * and proper lifecycle management.
-   *
-   * @param payloads - One or more payloads to queue
-   */
-  public async push(...payloads: Array<Static<T>>): Promise<void>;
-  /**
-   * Push a payload to the queue with specific options.
-   *
-   * @param payload - The payload to queue
-   * @param options - Job options (priority, delay)
-   */
-  public async push(
-    payload: Static<T>,
-    options: QueueAddJobOptions,
-  ): Promise<void>;
-
-  public async push(
-    payloadOrFirst: Static<T>,
-    optionsOrSecond?: QueueAddJobOptions | Static<T>,
-    ...rest: Array<Static<T>>
-  ): Promise<void> {
-    // Check if second argument is options object
-    const isOptions =
-      optionsOrSecond != null &&
-      typeof optionsOrSecond === "object" &&
-      ("priority" in optionsOrSecond || "delay" in optionsOrSecond);
-
-    if (isOptions) {
-      // Single payload with options
-      const payload = this.alepha.codec.decode(
-        this.options.schema,
-        payloadOrFirst,
-      );
-      await this.provider.addJob(this.name, payload, {
-        ...this.getDefaultJobOptions(),
-        priority: (optionsOrSecond as QueueAddJobOptions).priority,
-        delay: (optionsOrSecond as QueueAddJobOptions).delay,
-      });
-      this.log.debug(`Pushed job to queue ${this.name}`, {
-        payload,
-        options: optionsOrSecond,
-      });
-    } else {
-      // Multiple payloads without per-job options
-      const payloads =
-        optionsOrSecond != null
-          ? [payloadOrFirst, optionsOrSecond as Static<T>, ...rest]
-          : [payloadOrFirst, ...rest];
+  public async push(...payloads: Array<Static<T>>) {
+    await Promise.all(
+      payloads.map((payload) =>
+        this.provider.push(
+          this.name,
+          JSON.stringify({
+            headers: {},
+            payload: this.alepha.codec.decode(this.options.schema, payload),
+          }),
+        ),
+      ),
+    );
 
-      await Promise.all(
-        payloads.map((p) => {
-          const payload = this.alepha.codec.decode(this.options.schema, p);
-          return this.provider.addJob(
-            this.name,
-            payload,
-            this.getDefaultJobOptions(),
-          );
-        }),
-      );
-
-      this.log.debug(
-        `Pushed ${payloads.length} job(s) to queue ${this.name}`,
-        payloads,
-      );
-    }
-  }
-
-  /**
-   * Get default job options from primitive configuration.
-   */
-  protected getDefaultJobOptions() {
-    return {
-      maxAttempts: this.options.maxAttempts,
-      backoff: this.options.backoff,
-      lockDuration: this.options.lockDuration,
-      removeOnComplete: this.options.removeOnComplete,
-      removeOnFail: this.options.removeOnFail,
-    };
+    this.log.debug(`Pushed to queue ${this.name}`, payloads);
+    this.workerProvider.wakeUp();
   }
 
   public get name() {

package/src/queue/core/providers/MemoryQueueProvider.ts

@@ -0,0 +1,19 @@
+import { $logger } from "alepha/logger";
+import type { QueueProvider } from "./QueueProvider.ts";
+
+export class MemoryQueueProvider implements QueueProvider {
+  protected readonly log = $logger();
+  protected queueList: Record<string, string[]> = {};
+
+  public async push(queue: string, ...messages: string[]): Promise<void> {
+    if (this.queueList[queue] == null) {
+      this.queueList[queue] = [];
+    }
+
+    this.queueList[queue].push(...messages);
+  }
+
+  public async pop(queue: string): Promise<string | undefined> {
+    return this.queueList[queue]?.shift();
+  }
+}

package/src/queue/core/providers/QueueProvider.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimalist Queue interface.
+ *
+ * Will be probably enhanced in the future to support more advanced features. But for now, it's enough!
+ */
+export abstract class QueueProvider {
+  /**
+   * Push a message to the queue.
+   *
+   * @param queue Name of the queue to push the message to.
+   * @param message String message to be pushed to the queue. Buffer messages are not supported for now.
+   */
+  public abstract push(queue: string, message: string): Promise<void>;
+
+  /**
+   * Pop a message from the queue.
+   *
+   * @param queue Name of the queue to pop the message from.
+   *
+   * @returns The message popped or `undefined` if the queue is empty.
+   */
+  public abstract pop(queue: string): Promise<string | undefined>;
+}