@aromix/core 0.4.4 → 0.4.6

package/dist/index.d.ts

@@ -1,32 +1,26 @@
 import { AxSchemaShape, AxObjectSchema } from '@aromix/validator';
 
-type Phase = 'start' | 'stop';
-interface Block {
+type Loader<T> = () => Promise<{
+    default: T;
+}>;
+interface Unit {
     name: string;
     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): void;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    private notifyError;
-    private stopAll;
-    private gracefulShutdown;
-}
+declare function system(): {
+    load: (loader: Loader<unknown>) => void;
+    register: (loader: Loader<Unit>) => void;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+};
 
-type LoadEnvOptions<Shape extends AxSchemaShape> = Partial<{
+declare function LoadEnv<Shape extends AxSchemaShape = AxSchemaShape>(options: Partial<{
     path: string;
     schema: AxObjectSchema<Shape>;
-}>;
-declare function loadEnv<Shape extends AxSchemaShape>(options: LoadEnvOptions<Shape>): Block;
+}>): {
+    env: <Key extends keyof Shape["base"]>(key: Key) => Shape["base"][Key];
+};
 
-export { App, type Block, type ErrorHandler, type LoadEnvOptions, type Phase, loadEnv };
+export { LoadEnv, type Unit, system };

package/dist/index.js

@@ -1,104 +1,94 @@
-// 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.`);
+// src/system/def.ts
+function system() {
+  const configLoaders = [];
+  const unitLoaders = [];
+  const units = [];
+  let state = "idle";
+  function assertIdle(action) {
+    if (state !== "idle") {
+      throw new Error(`[Aromix] Cannot ${action}: system is "${state}", expected "idle".`);
     }
-    if (this.blocks.some((b) => b.name === block.name)) {
-      throw new Error(`[Aromix] Block with name "${block.name}" is already registered.`);
-    }
-    this.blocks.push(block);
   }
-  onError(handler) {
-    this.errorHandlers.push(handler);
+  function load(loader) {
+    assertIdle("add a config loader");
+    configLoaders.push(loader);
   }
-  async start() {
-    if (this.isStarted) {
-      throw new Error("[Aromix] Process has already been started.");
-    }
-    this.isStarted = true;
-    for (const block of this.blocks) {
-      const startedAt = Date.now();
+  function register(loader) {
+    assertIdle("register a unit");
+    unitLoaders.push(loader);
+  }
+  async function stop() {
+    if (state === "stopped" || state === "stopping") return;
+    state = "stopping";
+    for (let i = units.length - 1; i >= 0; i--) {
       try {
-        await block.start();
+        await units[i].stop?.();
       } catch (err) {
-        await this.notifyError(err, "start", block);
-        await this.stopAll("start-failure");
-        process.exit(1);
+        console.error(`[Aromix] "${units[i].name}" failed to stop`, err);
       }
     }
-    process.on("uncaughtException", (err) => {
-      this.notifyError(err, "runtime").finally(() => this.gracefulShutdown("uncaughtException"));
-    });
-    process.on("unhandledRejection", (reason) => {
-      const err = reason instanceof Error ? reason : new Error(String(reason));
-      this.notifyError(err, "runtime").finally(() => this.gracefulShutdown("unhandledRejection"));
-    });
-    process.once("SIGINT", () => this.gracefulShutdown("SIGINT"));
-    process.once("SIGTERM", () => this.gracefulShutdown("SIGTERM"));
+    state = "stopped";
   }
-  async stop() {
-    await this.stopAll("manual");
-  }
-  async notifyError(err, phase, block) {
-    const error = err instanceof Error ? err : new Error(String(err));
-    if (block?.error && (phase === "start" || phase === "stop")) {
-      await block.error(error, phase);
-    }
-    for (const handler of this.errorHandlers) {
-      await handler(error, phase);
+  async function start() {
+    assertIdle("start");
+    state = "loading";
+    for (const loader of configLoaders) {
+      await loader();
     }
-  }
-  async stopAll(reason) {
-    if (this.isStopping) return true;
-    this.isStopping = true;
-    let allStoppedCleanly = true;
-    for (let i = this.blocks.length - 1; i >= 0; i--) {
-      const block = this.blocks[i];
-      const startedAt = Date.now();
+    state = "starting";
+    for (const loader of unitLoaders) {
+      const { default: unit } = await loader();
+      if (units.some((u) => u.name === unit.name)) {
+        throw new Error(`[Aromix] Unit with name "${unit.name}" is already registered.`);
+      }
       try {
-        await block.stop?.();
+        await unit.start();
+        units.push(unit);
       } catch (err) {
-        allStoppedCleanly = false;
-        await this.notifyError(err, "stop", block);
+        await stop();
+        throw new Error(`[Aromix] "${unit.name}" failed to start`, { cause: err });
       }
     }
-    return allStoppedCleanly;
-  }
-  async gracefulShutdown(signal) {
-    const clean = await this.stopAll(signal);
-    process.exit(clean ? 0 : 1);
+    state = "running";
+    const onSignal = async () => {
+      await stop();
+      process.exit(0);
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
   }
-};
+  return {
+    load,
+    register,
+    start,
+    stop
+  };
+}
 
-// src/common/load.env.ts
-import { resolve } from "path";
+// src/common/LoadEnv.ts
 import { existsSync } from "fs";
-function loadEnv(options) {
+import { resolve } from "path";
+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}`);
-      }
-      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
-          });
-        }
-      }
+  if (!existsSync(path)) {
+    throw new Error(`[LoadEnv] Environment file not found: ${path}`);
+  }
+  process.loadEnvFile(path);
+  let values = process.env;
+  if (options.schema) {
+    const [result, issues] = options.schema.parseBase(process.env);
+    if (issues) {
+      console.error(issues);
+      throw new Error("[LoadEnv] Schema validation failed");
     }
-  };
+    values = result;
+  }
+  function env(key) {
+    return values[key];
+  }
+  return { env };
 }
 export {
-  App,
-  loadEnv
+  LoadEnv,
+  system
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aromix/core",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",