@aromix/core 0.4.1 → 0.4.3

package/dist/index.d.ts

@@ -1,254 +1,32 @@
-import { AnySchema } from '@aromix/validator';
-import { Db, InsertOneOptions, InsertOneResult, BulkWriteOptions, InsertManyResult, Filter, FindOptions, UpdateFilter, UpdateOptions, UpdateResult, ReplaceOptions, DeleteOptions, DeleteResult, FindOneAndUpdateOptions, FindOneAndDeleteOptions, FindOneAndReplaceOptions, CountDocumentsOptions, DistinctOptions, AggregateOptions, AggregationCursor, BulkWriteResult, CreateIndexesOptions, DropIndexesOptions } from 'mongodb';
-import * as http from 'http';
-import { IncomingMessage, ServerResponse } from 'http';
+import { AxSchemaShape, AxObjectSchema } from '@aromix/validator';
 
-interface KvEntityUserInput<Schema extends AnySchema> {
+type Phase = 'start' | 'stop';
+interface Block {
     name: string;
-    model: Schema;
+    start(): void | Promise<void>;
+    stop?(): void | Promise<void>;
+    error?(err: Error, phase: Phase): void | Promise<void>;
 }
-declare class KvEntity<Schema extends AnySchema> {
-    readonly state: KvEntityUserInput<Schema>;
-    private adapter;
-    constructor(userProvided: KvEntityUserInput<Schema>, internal: EntityBuilder.KvAdapter);
-    get(key: string): Promise<Schema['$select']>;
-    set(key: string, value: Schema['$insert']): Promise<void>;
-    delete(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
-}
-
-interface MongoEntityUserInput<Schema extends AnySchema> {
-    name: string;
-    model: Schema;
-}
-declare class MongoEntity<Schema extends AnySchema> {
-    readonly states: MongoEntityUserInput<Schema>;
-    private readonly collection;
-    constructor(userInput: MongoEntityUserInput<Schema>, db: Db);
-    insertOne(doc: Schema['$insert'], options?: InsertOneOptions): Promise<InsertOneResult>;
-    insertMany(docs: Schema['$insert'][], options?: BulkWriteOptions): Promise<InsertManyResult>;
-    findOne(filter: Filter<Schema['$select']>, options?: FindOptions): Promise<Schema['$select'] | null>;
-    find(filter: Filter<Schema['$select']>, options?: FindOptions): Promise<Schema['$select'][]>;
-    updateOne(filter: Filter<Schema['$select']>, update: UpdateFilter<Schema['$update']>, options?: UpdateOptions): Promise<UpdateResult>;
-    updateMany(filter: Filter<Schema['$select']>, update: UpdateFilter<Schema['$update']>, options?: UpdateOptions): Promise<UpdateResult>;
-    replaceOne(filter: Filter<Schema['$select']>, replacement: Schema['$select'], options?: ReplaceOptions): Promise<UpdateResult>;
-    deleteOne(filter: Filter<Schema['$select']>, options?: DeleteOptions): Promise<DeleteResult>;
-    deleteMany(filter: Filter<Schema['$select']>, options?: DeleteOptions): Promise<DeleteResult>;
-    findOneAndUpdate(filter: Filter<Schema['$select']>, update: UpdateFilter<Schema['$update']>, options?: FindOneAndUpdateOptions): Promise<Schema['$select'] | null>;
-    findOneAndDelete(filter: Filter<Schema['$select']>, options?: FindOneAndDeleteOptions): Promise<Schema['$select'] | null>;
-    findOneAndReplace(filter: Filter<Schema['$select']>, replacement: Schema['$select'], options?: FindOneAndReplaceOptions): Promise<Schema['$select'] | null>;
-    countDocuments(filter: Filter<Schema['$select']>, options?: CountDocumentsOptions): Promise<number>;
-    estimatedDocumentCount(): Promise<number>;
-    distinct<Field extends keyof Schema['$select'] & string>(field: Field, filter: Filter<Schema['$select']>, options?: DistinctOptions): Promise<Array<Schema['$select'][Field]>>;
-    aggregate(pipeline: any[], options?: AggregateOptions): AggregationCursor;
-    bulkWrite(operations: any[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
-    createIndex(indexSpec: any, options?: CreateIndexesOptions): Promise<string>;
-    dropIndex(indexName: string, options?: DropIndexesOptions): Promise<void>;
-}
-
-declare namespace EntityBuilder {
-    interface KvAdapter {
-        get(key: string): Promise<unknown>;
-        set(key: string, value: unknown): Promise<void>;
-        delete(key: string): Promise<void>;
-        has(key: string): Promise<boolean>;
-    }
-    interface KvInput {
-        transport: 'http';
-        adapter(): KvAdapter;
-    }
-    function kv(builderInput: KvInput): {
-        entity<Schema extends AnySchema>(entityInput: KvEntityUserInput<Schema>): KvEntity<Schema>;
-    };
-    interface MongoInput {
-        adapter(): Db;
-        transport: 'http';
-    }
-    function mongo(builderInput: MongoInput): {
-        entity<Schema extends AnySchema>(entityInput: MongoEntityUserInput<Schema>): MongoEntity<Schema>;
-    };
-}
-
-interface ComposeInput {
-    entities: Array<MongoEntity<AnySchema> | KvEntity<AnySchema>>;
-}
-declare function compose(input: ComposeInput): {
-    readonly descriptor: {
-        entities: any[];
-    };
-    dispatch(route: string, payload: unknown): Promise<any>;
-};
+type ErrorHandler = (err: Error, phase: Phase | 'runtime') => void | Promise<void>;
 
-declare class Descriptor {
-    private isExcluded;
-    private parseSchema;
-    kv(entity: KvEntity<AnySchema>): {
-        name: string;
-        platform: string;
-        methods: ({
-            name: string;
-            route: string;
-            input: {
-                type: string;
-                shape?: undefined;
-            };
-            output: any;
-        } | {
-            name: string;
-            route: string;
-            input: {
-                type: string;
-                shape: {
-                    key: {
-                        type: string;
-                    };
-                    value: any;
-                };
-            };
-            output: {
-                type: string;
-            };
-        })[];
-    };
-    private buildMongoMethod;
-    mongo(entity: MongoEntity<AnySchema>): {
-        name: string;
-        platform: string;
-        methods: {
-            name: string;
-            route: string;
-            input: any;
-            output: {
-                type: string;
-                shape: {
-                    acknowledged: {
-                        type: string;
-                    };
-                    matchedCount: {
-                        type: string;
-                    };
-                    modifiedCount: {
-                        type: string;
-                    };
-                    upsertedCount: {
-                        type: string;
-                    };
-                    upsertedId: {
-                        type: string;
-                    };
-                };
-            } | {
-                type: string;
-                shape: {
-                    acknowledged: {
-                        type: string;
-                    };
-                    insertedId: {
-                        type: string;
-                    };
-                    insertedCount?: undefined;
-                    insertedIds?: undefined;
-                    matchedCount?: undefined;
-                    modifiedCount?: undefined;
-                    upsertedCount?: undefined;
-                    upsertedId?: undefined;
-                    deletedCount?: undefined;
-                };
-                items?: undefined;
-                element?: undefined;
-            } | {
-                type: string;
-                shape: {
-                    acknowledged: {
-                        type: string;
-                    };
-                    insertedCount: {
-                        type: string;
-                    };
-                    insertedIds: {
-                        type: string;
-                    };
-                    insertedId?: undefined;
-                    matchedCount?: undefined;
-                    modifiedCount?: undefined;
-                    upsertedCount?: undefined;
-                    upsertedId?: undefined;
-                    deletedCount?: undefined;
-                };
-                items?: undefined;
-                element?: undefined;
-            } | {
-                type: string;
-                items: any[];
-                shape?: undefined;
-                element?: undefined;
-            } | {
-                type: string;
-                element: any;
-                shape?: undefined;
-                items?: undefined;
-            } | {
-                type: string;
-                shape: {
-                    acknowledged: {
-                        type: string;
-                    };
-                    matchedCount: {
-                        type: string;
-                    };
-                    modifiedCount: {
-                        type: string;
-                    };
-                    upsertedCount: {
-                        type: string;
-                    };
-                    upsertedId: {
-                        type: string;
-                    };
-                    insertedId?: undefined;
-                    insertedCount?: undefined;
-                    insertedIds?: undefined;
-                    deletedCount?: undefined;
-                };
-                items?: undefined;
-                element?: undefined;
-            } | {
-                type: string;
-                items: any[];
-                shape?: undefined;
-                element?: undefined;
-            } | {
-                type: string;
-                shape: {
-                    acknowledged: {
-                        type: string;
-                    };
-                    deletedCount: {
-                        type: string;
-                    };
-                    insertedId?: undefined;
-                    insertedCount?: undefined;
-                    insertedIds?: undefined;
-                    matchedCount?: undefined;
-                    modifiedCount?: undefined;
-                    upsertedCount?: undefined;
-                    upsertedId?: undefined;
-                };
-                items?: undefined;
-                element?: undefined;
-            } | {
-                type: string;
-                shape?: undefined;
-                items?: undefined;
-                element?: undefined;
-            };
-        }[];
-    };
+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 Composed = ReturnType<typeof compose>;
-declare function make(composed: Composed): {
-    listen(port: number): http.Server<typeof IncomingMessage, typeof ServerResponse>;
-};
+type LoadEnvOptions<Shape extends AxSchemaShape> = Partial<{
+    path: string;
+    schema: AxObjectSchema<Shape>;
+}>;
+declare function loadEnv<Shape extends AxSchemaShape>(options: LoadEnvOptions<Shape>): Block;
 
-export { type ComposeInput, Descriptor, EntityBuilder, KvEntity, type KvEntityUserInput, MongoEntity, type MongoEntityUserInput, compose, make };
+export { App, type Block, type ErrorHandler, type LoadEnvOptions, type Phase, loadEnv };

package/dist/index.js

@@ -1,380 +1,124 @@
-// src/entity/platforms/kv.ts
-var KvEntity = class {
-  state;
-  adapter;
-  constructor(userProvided, internal) {
-    this.state = userProvided;
-    this.adapter = internal;
-  }
-  async get(key) {
-    const formattedKey = `${this.state.name}:${key}`;
-    const raw = await this.adapter.get(formattedKey);
-    return raw;
-  }
-  async set(key, value) {
-    const formattedKey = `${this.state.name}:${key}`;
-    await this.adapter.set(formattedKey, value);
-  }
-  async delete(key) {
-    const formattedKey = `${this.state.name}:${key}`;
-    await this.adapter.delete(formattedKey);
-  }
-  async has(key) {
-    const formattedKey = `${this.state.name}:${key}`;
-    return this.adapter.has(formattedKey);
-  }
-};
-
-// src/entity/platforms/mongo.ts
-var MongoEntity = class {
-  states;
-  collection;
-  constructor(userInput, db) {
-    this.states = userInput;
-    this.collection = db.collection(userInput.name);
-  }
-  async insertOne(doc, options) {
-    return this.collection.insertOne(doc, options);
-  }
-  async insertMany(docs, options) {
-    return this.collection.insertMany(docs, options);
-  }
-  async findOne(filter, options) {
-    return this.collection.findOne(filter, options);
-  }
-  async find(filter, options) {
-    return this.collection.find(filter, options).toArray();
-  }
-  async updateOne(filter, update, options) {
-    return this.collection.updateOne(filter, update, options);
-  }
-  async updateMany(filter, update, options) {
-    return this.collection.updateMany(filter, update, options);
-  }
-  async replaceOne(filter, replacement, options) {
-    return this.collection.replaceOne(filter, replacement, options);
-  }
-  async deleteOne(filter, options) {
-    return this.collection.deleteOne(filter, options);
-  }
-  async deleteMany(filter, options) {
-    return this.collection.deleteMany(filter, options);
-  }
-  async findOneAndUpdate(filter, update, options) {
-    return this.collection.findOneAndUpdate(filter, update, options);
-  }
-  async findOneAndDelete(filter, options) {
-    return this.collection.findOneAndDelete(filter, options);
-  }
-  async findOneAndReplace(filter, replacement, options) {
-    return this.collection.findOneAndReplace(filter, replacement, options);
-  }
-  async countDocuments(filter, options) {
-    return this.collection.countDocuments(filter, options);
-  }
-  async estimatedDocumentCount() {
-    return this.collection.estimatedDocumentCount();
-  }
-  async distinct(field, filter, options) {
-    return this.collection.distinct(field, filter, options);
-  }
-  aggregate(pipeline, options) {
-    return this.collection.aggregate(pipeline, options);
-  }
-  async bulkWrite(operations, options) {
-    return this.collection.bulkWrite(operations, options);
-  }
-  async createIndex(indexSpec, options) {
-    return this.collection.createIndex(indexSpec, options);
-  }
-  async dropIndex(indexName, options) {
-    return this.collection.dropIndex(indexName, options);
-  }
-};
-
-// src/entity/builder.ts
-var EntityBuilder;
-((EntityBuilder2) => {
-  function kv(builderInput) {
-    const adapter = builderInput.adapter();
-    const result = {
-      entity(entityInput) {
-        return new KvEntity(entityInput, adapter);
-      }
-    };
-    return result;
-  }
-  EntityBuilder2.kv = kv;
-  function mongo(builderInput) {
-    const db = builderInput.adapter();
-    const result = {
-      entity(entityInput) {
-        return new MongoEntity(entityInput, db);
+// 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.`);
+    }
+    this.blocks.push(block);
+    console.debug("[Aromix] Block registered", { block: block.name, phase: "register" });
+  }
+  onError(handler) {
+    this.errorHandlers.push(handler);
+    return this;
+  }
+  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);
       }
-    };
-    return result;
-  }
-  EntityBuilder2.mongo = mongo;
-})(EntityBuilder || (EntityBuilder = {}));
-
-// src/organize/descriptor.ts
-var Descriptor = class {
-  isExcluded(schema, slot) {
-    const accessors = schema.state.accessors ?? {};
-    if (slot === "select") return !!accessors.hidden;
-    if (slot === "insert") return accessors.readonlyValue !== void 0 || !!accessors.readonlyFn;
-    return accessors.readonlyValue !== void 0 || !!accessors.readonlyFn || !!accessors.locked;
-  }
-  parseSchema(schema, slot) {
-    const state = schema.state;
-    if (state.type === "object") {
-      const shape = state.typeMeta.objectShape ?? {};
-      const fields = {};
-      for (const key in shape) {
-        if (this.isExcluded(shape[key], slot)) continue;
-        fields[key] = this.parseSchema(shape[key], slot);
-      }
-      return { type: "object", shape: fields };
-    }
-    if (state.type === "array") {
-      return { type: "array", element: this.parseSchema(state.typeMeta.arrayElement, slot) };
-    }
-    if (state.type === "tuple") {
-      return { type: "tuple", items: (state.typeMeta.tupleItems ?? []).map((s) => this.parseSchema(s, slot)) };
-    }
-    if (state.type === "union") {
-      return { type: "union", items: (state.typeMeta.unionItems ?? []).map((s) => this.parseSchema(s, slot)) };
-    }
-    if (state.type === "record") {
-      return { type: "record", element: this.parseSchema(state.typeMeta.recordElement, slot) };
-    }
-    if (state.type === "literals") {
-      return { type: "literals", values: state.typeMeta.literalValues };
-    }
-    return { type: state.type };
-  }
-  kv(entity) {
-    const name = entity.state.name;
-    const model = entity.state.model;
-    return {
-      name,
-      platform: "kv",
-      methods: [
-        { name: "get", route: `${name}.kv.get`, input: { type: "string" }, output: this.parseSchema(model, "select") },
-        { name: "set", route: `${name}.kv.set`, input: { type: "object", shape: { key: { type: "string" }, value: this.parseSchema(model, "insert") } }, output: { type: "null" } },
-        { name: "delete", route: `${name}.kv.delete`, input: { type: "string" }, output: { type: "null" } },
-        { name: "has", route: `${name}.kv.has`, input: { type: "string" }, output: { type: "boolean" } }
-      ]
-    };
-  }
-  buildMongoMethod(model, methodName) {
-    if (methodName === "insertOne") {
-      return { input: this.parseSchema(model, "insert"), output: { type: "object", shape: { acknowledged: { type: "boolean" }, insertedId: { type: "unknown" } } } };
     }
-    if (methodName === "insertMany") {
-      return {
-        input: { type: "array", element: this.parseSchema(model, "insert") },
-        output: { type: "object", shape: { acknowledged: { type: "boolean" }, insertedCount: { type: "number" }, insertedIds: { type: "unknown" } } }
-      };
-    }
-    if (methodName === "findOne") {
-      return { input: this.parseSchema(model, "select"), output: { type: "union", items: [this.parseSchema(model, "select"), { type: "null" }] } };
-    }
-    if (methodName === "find") {
-      return { input: this.parseSchema(model, "select"), output: { type: "array", element: this.parseSchema(model, "select") } };
-    }
-    if (methodName === "updateOne" || methodName === "updateMany") {
-      return {
-        input: { type: "object", shape: { filter: this.parseSchema(model, "select"), update: this.parseSchema(model, "update") } },
-        output: {
-          type: "object",
-          shape: {
-            acknowledged: { type: "boolean" },
-            matchedCount: { type: "number" },
-            modifiedCount: { type: "number" },
-            upsertedCount: { type: "number" },
-            upsertedId: { type: "unknown" }
-          }
-        }
-      };
-    }
-    if (methodName === "replaceOne" || methodName === "findOneAndReplace") {
-      const updateResultShape = {
-        type: "object",
-        shape: { acknowledged: { type: "boolean" }, matchedCount: { type: "number" }, modifiedCount: { type: "number" }, upsertedCount: { type: "number" }, upsertedId: { type: "unknown" } }
-      };
-      return {
-        input: { type: "object", shape: { filter: this.parseSchema(model, "select"), replacement: this.parseSchema(model, "select") } },
-        output: methodName === "replaceOne" ? updateResultShape : { type: "union", items: [this.parseSchema(model, "select"), { type: "null" }] }
-      };
-    }
-    if (methodName === "deleteOne" || methodName === "deleteMany") {
-      return { input: this.parseSchema(model, "select"), output: { type: "object", shape: { acknowledged: { type: "boolean" }, deletedCount: { type: "number" } } } };
-    }
-    if (methodName === "findOneAndUpdate") {
-      return {
-        input: { type: "object", shape: { filter: this.parseSchema(model, "select"), update: this.parseSchema(model, "update") } },
-        output: { type: "union", items: [this.parseSchema(model, "select"), { type: "null" }] }
-      };
-    }
-    if (methodName === "findOneAndDelete") {
-      return { input: this.parseSchema(model, "select"), output: { type: "union", items: [this.parseSchema(model, "select"), { type: "null" }] } };
-    }
-    if (methodName === "countDocuments") {
-      return { input: this.parseSchema(model, "select"), output: { type: "number" } };
-    }
-    if (methodName === "estimatedDocumentCount") {
-      return { input: { type: "null" }, output: { type: "number" } };
-    }
-    if (methodName === "distinct") {
-      return { input: { type: "object", shape: { field: { type: "string" }, filter: this.parseSchema(model, "select") } }, output: { type: "unknown" } };
-    }
-    if (methodName === "createIndex") {
-      return { input: { type: "unknown" }, output: { type: "string" } };
-    }
-    if (methodName === "dropIndex") {
-      return { input: { type: "string" }, output: { type: "null" } };
-    }
-    return { input: { type: "unknown" }, output: { type: "unknown" } };
-  }
-  mongo(entity) {
-    const name = entity.states.name;
-    const model = entity.states.model;
-    const proto = Object.getPrototypeOf(entity);
-    const methods = [];
-    for (const key of Object.getOwnPropertyNames(proto)) {
-      if (key === "constructor") continue;
-      const shape = this.buildMongoMethod(model, key);
-      methods.push({ name: key, route: `${name}.mongo.${key}`, input: shape.input, output: shape.output });
-    }
-    return { name, platform: "mongo", methods };
-  }
-};
-
-// src/organize/compose.ts
-function compose(input) {
-  const descriptors = [];
-  const routes = /* @__PURE__ */ new Map();
-  const des = new Descriptor();
-  for (const entity of input.entities) {
-    if (entity instanceof MongoEntity) {
-      const descriptor = des.mongo(entity);
-      descriptors.push(descriptor);
-      for (const method of descriptor.methods) {
-        routes.set(method.route, { entity, methodName: method.name });
+    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 });
+  }
+  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")) {
+      try {
+        await block.error(error, phase);
+      } catch (handlerErr) {
+        console.error(`[Aromix] Block "${block.name}" error handler itself threw`, handlerErr, { block: block.name, phase });
       }
     }
-    if (entity instanceof KvEntity) {
-      const descriptor = des.kv(entity);
-      descriptors.push(descriptor);
-      for (const method of descriptor.methods) {
-        routes.set(method.route, { entity, methodName: method.name });
+    for (const handler of this.errorHandlers) {
+      try {
+        await handler(error, phase);
+      } catch (handlerErr) {
+        console.error("[Aromix] Global error handler threw", handlerErr, { phase });
       }
     }
   }
-  return {
-    get descriptor() {
-      return { entities: descriptors };
-    },
-    async dispatch(route, payload) {
-      const target = routes.get(route);
-      if (target === void 0) {
-        throw new Error(`no method registered for route "${route}"`);
+  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 block.stop?.();
+        console.log("[Aromix] Block stopped", { block: block.name, phase: "stop", durationMs: Date.now() - startedAt });
+      } catch (err) {
+        allStoppedCleanly = false;
+        console.error("[Aromix] Block failed to stop", err, { block: block.name, phase: "stop" });
+        await this.notifyError(err, "stop", block);
       }
-      const fn = target.entity[target.methodName];
-      return fn.call(target.entity, payload);
-    }
-  };
-}
-
-// src/organize/make.ts
-import { createServer } from "http";
-async function toWebRequest(req) {
-  const url = `http://${req.headers.host}${req.url}`;
-  const headers = new Headers();
-  for (const key in req.headers) {
-    const value = req.headers[key];
-    if (typeof value === "string") {
-      headers.set(key, value);
     }
-    if (Array.isArray(value)) {
-      headers.set(key, value.join(", "));
-    }
-  }
-  if (req.method === "GET" || req.method === "HEAD") {
-    return new Request(url, { method: req.method, headers });
-  }
-  const chunks = [];
-  for await (const chunk of req) {
-    chunks.push(chunk);
+    return allStoppedCleanly;
   }
-  const body = Buffer.concat(chunks);
-  return new Request(url, { method: req.method, headers, body });
-}
-async function writeWebResponse(webResponse, res) {
-  res.statusCode = webResponse.status;
-  webResponse.headers.forEach((value, key) => {
-    res.setHeader(key, value);
-  });
-  if (webResponse.body === null) {
-    res.end();
-    return;
-  }
-  const reader = webResponse.body.getReader();
-  while (true) {
-    const next = await reader.read();
-    if (next.done) {
-      break;
-    }
-    res.write(next.value);
-  }
-  res.end();
-}
-async function handle(request, composed) {
-  const url = new URL(request.url);
-  if (url.pathname === "/meta") {
-    return Response.json(composed.descriptor);
+  async gracefulShutdown(signal) {
+    console.info(`[Aromix] Received ${signal}. Starting graceful shutdown...`, { signal });
+    const clean = await this.stopAll(signal);
+    process.exit(clean ? 0 : 1);
   }
-  const route = request.headers.get("x-amx-id");
-  if (route === null) {
-    return Response.json({ data: null, errors: null });
-  }
-  let payload;
-  try {
-    payload = await request.json();
-  } catch {
-    payload = void 0;
-  }
-  try {
-    const data = await composed.dispatch(route, payload);
-    return Response.json({ data, errors: null });
-  } catch (error) {
-    let message = "unknown error";
-    if (error instanceof Error) {
-      message = error.message;
-    }
-    return Response.json({ data: null, errors: message }, { status: 400 });
-  }
-}
-function make(composed) {
+};
+
+// src/common/load.env.ts
+import { resolve } from "path";
+import { existsSync } from "fs";
+function loadEnv(options) {
+  const path = resolve(options.path ?? ".env");
   return {
-    listen(port) {
-      const server = createServer((req, res) => {
-        toWebRequest(req).then((request) => handle(request, composed)).then((response) => writeWebResponse(response, res)).catch((error) => {
-          res.statusCode = 500;
-          res.end("internal error");
-        });
-      });
-      server.listen(port);
-      return server;
+    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
+          });
+        }
+      }
     }
   };
 }
 export {
-  Descriptor,
-  EntityBuilder,
-  KvEntity,
-  MongoEntity,
-  compose,
-  make
+  App,
+  loadEnv
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aromix/core",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",
@@ -18,9 +18,8 @@
     "core",
     "server",
     "framework",
-    "runtime-agnostic",
-    "deno",
-    "node"
+    "node",
+    "rpc"
   ],
   "files": [
     "dist"
@@ -35,25 +34,39 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
-  },
   "peerDependencies": {
-    "@aromix/validator": "^0.3.0",
-    "mongodb": "^7.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": {
       "optional": true
+    },
+    "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"
   }
-}
+}