@aromix/core 0.4.2 → 0.4.3

package/dist/index.d.ts

@@ -1,84 +1,32 @@
-import { AnySchema } from '@aromix/validator';
-import { Server } from 'http';
-import { Db, MongoClient } from 'mongodb';
-import { RedisClientType, RedisClusterType, RedisClientPoolType, RedisSentinelType } from 'redis';
+import { AxSchemaShape, AxObjectSchema } from '@aromix/validator';
 
-type MaybePromise<T> = T | Promise<T>
-
-interface Builder {
+type Phase = 'start' | 'stop';
+interface Block {
     name: string;
-    onRegister?(state: Record<string, any>): MaybePromise<void>;
-    onListen?(server: Server): MaybePromise<void>;
-    onShutdown?(): MaybePromise<void>;
-}
-declare function Builder(def: Builder): Builder;
-
-interface ValidateEnvConfig<Schema extends Record<string, AnySchema>> {
+    start(): void | Promise<void>;
+    stop?(): void | Promise<void>;
+    error?(err: Error, phase: Phase): void | Promise<void>;
+}
+type ErrorHandler = (err: Error, phase: Phase | 'runtime') => void | Promise<void>;
+
+declare class App {
+    private isStarted;
+    private isStopping;
+    private blocks;
+    private errorHandlers;
+    use(block: Block): void;
+    onError(handler: ErrorHandler): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private notifyError;
+    private stopAll;
+    private gracefulShutdown;
+}
+
+type LoadEnvOptions<Shape extends AxSchemaShape> = Partial<{
     path: string;
-    schema: Schema;
-    onError?(err: unknown): void;
-}
-declare function ValidateEnv<const Schema extends Record<string, AnySchema>>(config: ValidateEnvConfig<Schema>): readonly [Builder, <Key extends keyof Schema>(key: Key, fallback?: Schema[Key]["$base"]) => Schema[Key]["$base"]];
-
-interface EffectDef {
-    name: string;
-    run(): void;
-}
-declare function effect(def: EffectDef): EffectDef;
-
-interface GuardDef {
-    name: string;
-    run(): void;
-}
-declare function guard(def: GuardDef): GuardDef;
-
-declare class MongoDatabase {
-    db: Db;
-    constructor();
-    /** internal attach */
-    attach(db: Db): void;
-    entity<Schema extends AnySchema>(input: MongoEntityInput<Schema>): void;
-}
-
-type ClusterResult<T extends readonly string[]> = {
-    builder: Builder;
-    client: MongoClient;
-} & {
-    [K in T[number]]: MongoDatabase;
-};
-interface MongoClusterInput<Databases extends readonly string[]> {
-    name: string;
-    uri: string;
-    databases: Databases;
-    onConnect?(client: MongoClient): MaybePromise<void>;
-    onDisconnect?(client: MongoClient): MaybePromise<void>;
-    onError?(err: unknown): MaybePromise<void>;
-}
-interface MongoEntityInput<Schema extends AnySchema> {
-    name: string;
-    model: Schema;
-}
-
-declare function MongoCluster<const Databases extends readonly string[]>(options: MongoClusterInput<Databases>): ClusterResult<Databases>;
-
-type RedisAdapter = RedisClientType | RedisClusterType | RedisClientPoolType | RedisSentinelType;
-interface RedisInput {
-    name: string;
-    client(): RedisAdapter;
-    onConnect?(client: RedisAdapter): MaybePromise<void>;
-    onDisconnect?(client: RedisAdapter): MaybePromise<void>;
-    onError?(err: unknown): void;
-}
-declare class Redis {
-    constructor(input: RedisInput);
-}
-
-declare class Application {
-    private state;
-    private builders;
-    register(builder: Builder): void;
-    listen(port: number): Promise<void>;
-}
-declare function bootstrap(): Application;
+    schema: AxObjectSchema<Shape>;
+}>;
+declare function loadEnv<Shape extends AxSchemaShape>(options: LoadEnvOptions<Shape>): Block;
 
-export { Builder, type ClusterResult, type EffectDef, type GuardDef, type MaybePromise, MongoCluster, type MongoClusterInput, MongoDatabase, type MongoEntityInput, Redis, type RedisAdapter, type RedisInput, ValidateEnv, type ValidateEnvConfig, bootstrap, effect, guard };
+export { App, type Block, type ErrorHandler, type LoadEnvOptions, type Phase, loadEnv };

package/dist/index.js

@@ -1,123 +1,124 @@
-// src/server/builder.ts
-function Builder(def) {
-  return def;
-}
-
-// src/common/validate.env.ts
-import { loadEnvFile } from "process";
-function ValidateEnv(config) {
-  const builder = Builder({
-    name: "validate.env",
-    onRegister(state) {
-      loadEnvFile(config.path);
-      console.log(state);
-      console.log(process.env);
+// src/app/builder.ts
+var App = class {
+  isStarted = false;
+  isStopping = false;
+  blocks = [];
+  errorHandlers = [];
+  use(block) {
+    if (this.isStarted) {
+      throw new Error(`[Aromix] Unable to register "${block.name}": process already started.`);
+    }
+    if (this.blocks.some((b) => b.name === block.name)) {
+      throw new Error(`[Aromix] Block with name "${block.name}" is already registered.`);
     }
-  });
-  function env(key, fallback) {
-    return process.env[key] ?? fallback;
+    this.blocks.push(block);
+    console.debug("[Aromix] Block registered", { block: block.name, phase: "register" });
   }
-  return [builder, env];
-}
-
-// src/layer/effect.ts
-function effect(def) {
-  return def;
-}
-
-// src/layer/guard.ts
-function guard(def) {
-  return def;
-}
-
-// src/mongo/cluster.ts
-import { MongoClient } from "mongodb";
-
-// src/mongo/database.ts
-var MongoDatabase = class {
-  db;
-  constructor() {
+  onError(handler) {
+    this.errorHandlers.push(handler);
+    return this;
   }
-  /** internal attach */
-  attach(db) {
-    this.db = db;
+  async start() {
+    if (this.isStarted) {
+      throw new Error("[Aromix] Process has already been started.");
+    }
+    this.isStarted = true;
+    console.info("[Aromix] Starting application", { totalBlocks: this.blocks.length });
+    for (const block of this.blocks) {
+      const startedAt = Date.now();
+      try {
+        await block.start();
+        console.log("[Aromix] Block started", { block: block.name, phase: "start", durationMs: Date.now() - startedAt });
+      } catch (err) {
+        console.error("[Aromix] Fatal: block failed to start. Rolling back...", err, { block: block.name, phase: "start" });
+        await this.notifyError(err, "start", block);
+        await this.stopAll("start-failure");
+        process.exit(1);
+      }
+    }
+    process.on("uncaughtException", (err) => {
+      console.error("[Aromix] Uncaught exception. Shutting down...", err);
+      this.notifyError(err, "runtime").finally(() => this.gracefulShutdown("uncaughtException"));
+    });
+    process.on("unhandledRejection", (reason) => {
+      const err = reason instanceof Error ? reason : new Error(String(reason));
+      console.error("[Aromix] Unhandled rejection. Shutting down...", err);
+      this.notifyError(err, "runtime").finally(() => this.gracefulShutdown("unhandledRejection"));
+    });
+    process.once("SIGINT", () => this.gracefulShutdown("SIGINT"));
+    process.once("SIGTERM", () => this.gracefulShutdown("SIGTERM"));
+    console.log("[Aromix] Application started successfully", { totalBlocks: this.blocks.length });
   }
-  entity(input) {
+  async stop() {
+    await this.stopAll("manual");
   }
-};
-
-// src/mongo/cluster.ts
-function MongoCluster(options) {
-  const client = new MongoClient(options.uri);
-  const databases = {};
-  for (const name of options.databases) {
-    databases[name] = new MongoDatabase();
+  async notifyError(err, phase, block) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (block?.error && (phase === "start" || phase === "stop")) {
+      try {
+        await block.error(error, phase);
+      } catch (handlerErr) {
+        console.error(`[Aromix] Block "${block.name}" error handler itself threw`, handlerErr, { block: block.name, phase });
+      }
+    }
+    for (const handler of this.errorHandlers) {
+      try {
+        await handler(error, phase);
+      } catch (handlerErr) {
+        console.error("[Aromix] Global error handler threw", handlerErr, { phase });
+      }
+    }
   }
-  const builder = Builder({
-    name: options.name,
-    async onListen() {
+  async stopAll(reason) {
+    if (this.isStopping) return true;
+    this.isStopping = true;
+    console.info("[Aromix] Stopping all blocks", { phase: "stop", signal: reason, totalBlocks: this.blocks.length });
+    let allStoppedCleanly = true;
+    for (let i = this.blocks.length - 1; i >= 0; i--) {
+      const block = this.blocks[i];
+      const startedAt = Date.now();
       try {
-        await client.connect();
-        for (const name of options.databases) {
-          const db = client.db(name);
-          databases[name].attach(db);
-        }
-        await options.onConnect?.(client);
+        await block.stop?.();
+        console.log("[Aromix] Block stopped", { block: block.name, phase: "stop", durationMs: Date.now() - startedAt });
       } catch (err) {
-        await options.onError?.(err);
-        throw err;
+        allStoppedCleanly = false;
+        console.error("[Aromix] Block failed to stop", err, { block: block.name, phase: "stop" });
+        await this.notifyError(err, "stop", block);
       }
-    },
-    async onShutdown() {
-      await options.onDisconnect?.(client);
-      await client.close();
     }
-  });
-  return {
-    client,
-    builder,
-    ...databases
-  };
-}
-
-// src/redis/redis.ts
-var Redis = class {
-  constructor(input) {
+    return allStoppedCleanly;
+  }
+  async gracefulShutdown(signal) {
+    console.info(`[Aromix] Received ${signal}. Starting graceful shutdown...`, { signal });
+    const clean = await this.stopAll(signal);
+    process.exit(clean ? 0 : 1);
   }
 };
 
-// src/server/application.ts
-import { createServer } from "http";
-var Application = class {
-  state = {};
-  builders = [];
-  register(builder) {
-    this.builders.push(builder);
-    builder.onRegister?.(this.state);
-  }
-  async listen(port) {
-    const server = createServer();
-    for (const builder of this.builders) {
-      await builder.onListen?.(server);
-    }
-    server.listen(port);
-    server.on("close", async () => {
-      for (const builder of this.builders) {
-        await builder.onShutdown?.();
+// src/common/load.env.ts
+import { resolve } from "path";
+import { existsSync } from "fs";
+function loadEnv(options) {
+  const path = resolve(options.path ?? ".env");
+  return {
+    name: "Load Env",
+    async start() {
+      if (!existsSync(path)) {
+        throw new Error(`[Load Env]  Environment file not found: ${path}`);
       }
-    });
-  }
-};
-function bootstrap() {
-  return new Application();
+      process.loadEnvFile(path);
+      if (options.schema) {
+        const [result, issues] = options.schema.parseBase(process.env);
+        if (issues) {
+          throw new Error("[Load Env] Schema Validation Failed", {
+            cause: issues
+          });
+        }
+      }
+    }
+  };
 }
 export {
-  Builder,
-  MongoCluster,
-  MongoDatabase,
-  Redis,
-  ValidateEnv,
-  bootstrap,
-  effect,
-  guard
+  App,
+  loadEnv
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aromix/core",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",
@@ -34,23 +34,22 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
-  },
   "peerDependencies": {
-    "@aromix/validator": "^0.3.0",
+    "@aromix/validator": "0.5.5",
     "mongodb": "^7.3.0",
     "redis": "^6.0.1"
   },
   "devDependencies": {
-    "@aromix/validator": "^0.3.0",
+    "@aromix/validator": "0.5.5",
+    "@biomejs/biome": "^1.9.4",
     "@types/node": "^22.10.2",
+    "beachball": "^2.65.5",
     "mongodb": "^7.3.0",
     "redis": "^6.0.1",
+    "rimraf": "^6.1.3",
     "tsup": "^8.3.5",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "vitest": "^4.1.6"
   },
   "peerDependenciesMeta": {
     "mongodb": {
@@ -59,5 +58,15 @@
     "redis": {
       "optional": true
     }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "format": "biome format --write .",
+    "test": "vitest run",
+    "change": "beachball change",
+    "bump": "beachball bump",
+    "release": "beachball publish --yes --access public"
   }
-}
+}