@aromix/core 0.3.2 → 0.4.1

package/dist/index.d.ts

@@ -1,82 +1,254 @@
 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';
 
-interface KvAdapter {
-    get(key: string): Promise<unknown>;
-    set(key: string, value: unknown): Promise<void>;
+interface KvEntityUserInput<Schema extends AnySchema> {
+    name: string;
+    model: Schema;
+}
+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>;
 }
-declare function KvAdapter(adapter: KvAdapter): KvAdapter;
 
-interface KvEntityInput<Schema extends AnySchema> {
+interface MongoEntityUserInput<Schema extends AnySchema> {
     name: string;
-    adapter: KvAdapter;
     model: Schema;
 }
-interface KvEntityOutput<Schema extends AnySchema> {
-    get(key: string): Promise<Schema['$infer']>;
-    set(key: string, value: Schema['$infer']): Promise<void>;
-    delete(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
-    state: {
-        name: string;
-        adapter: KvAdapter;
-        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 function KvEntity<Schema extends AnySchema>(input: KvEntityInput<Schema>): KvEntityOutput<Schema>;
 
-interface MongoCollectionAdapter {
-    insertOne(doc: any): Promise<any>;
-    insertMany(docs: any): Promise<any>;
-    findOne(filter: any): Promise<any>;
-    find(filter: any): Promise<any>;
-    updateOne(filter: any, update: any): Promise<any>;
-    updateMany(filter: any, update: any): Promise<any>;
-    deleteOne(filter: any): Promise<any>;
-    deleteMany(filter: any): Promise<any>;
-    countDocuments(filter?: any): Promise<any>;
-}
-interface MongoAdapter {
-    collection(name: string): MongoCollectionAdapter;
+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>;
+    };
 }
-declare function MongoAdapter(adapter: MongoAdapter): MongoAdapter;
 
-interface MongoEntityInput<Schema extends AnySchema> {
-    name: string;
-    adapter: MongoAdapter;
-    model: Schema;
+interface ComposeInput {
+    entities: Array<MongoEntity<AnySchema> | KvEntity<AnySchema>>;
 }
-interface MongoEntityOutput<Schema extends AnySchema> {
-    insertOne(doc: Schema['$infer']): Promise<{
-        insertedId: unknown;
-    }>;
-    insertMany(docs: Schema['$infer'][]): Promise<{
-        insertedIds: unknown[];
-    }>;
-    findOne(filter: Record<string, unknown>): Promise<Schema['$infer'] | null>;
-    find(filter: Record<string, unknown>): Promise<Schema['$infer'][]>;
-    updateOne(filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
-        matchedCount: number;
-        modifiedCount: number;
-    }>;
-    updateMany(filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
-        matchedCount: number;
-        modifiedCount: number;
-    }>;
-    deleteOne(filter: Record<string, unknown>): Promise<{
-        deletedCount: number;
-    }>;
-    deleteMany(filter: Record<string, unknown>): Promise<{
-        deletedCount: number;
-    }>;
-    countDocuments(filter?: Record<string, unknown>): Promise<number>;
-    state: {
+declare function compose(input: ComposeInput): {
+    readonly descriptor: {
+        entities: any[];
+    };
+    dispatch(route: string, payload: unknown): Promise<any>;
+};
+
+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;
-        adapter: MongoAdapter;
-        model: Schema;
+        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 function MongoEntity<Schema extends AnySchema>(input: MongoEntityInput<Schema>): MongoEntityOutput<Schema>;
 
-export { KvAdapter, KvEntity, type KvEntityInput, type KvEntityOutput, MongoAdapter, type MongoCollectionAdapter, MongoEntity, type MongoEntityInput, type MongoEntityOutput };
+type Composed = ReturnType<typeof compose>;
+declare function make(composed: Composed): {
+    listen(port: number): http.Server<typeof IncomingMessage, typeof ServerResponse>;
+};
+
+export { type ComposeInput, Descriptor, EntityBuilder, KvEntity, type KvEntityUserInput, MongoEntity, type MongoEntityUserInput, compose, make };

package/dist/index.js

@@ -1,88 +1,380 @@
-// src/kv/adapter.ts
-function KvAdapter(adapter) {
-  return adapter;
-}
+// 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/kv/entity.ts
-function KvEntity(input) {
-  const adapter = input.adapter;
+// 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);
+      }
+    };
+    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 });
+      }
+    }
+    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 });
+      }
+    }
+  }
   return {
-    async get(key) {
-      const formattedKey = `${input.name}:${key}`;
-      const raw = await adapter.get(formattedKey);
-      return input.model.parse(raw);
-    },
-    async set(key, value) {
-      const formattedKey = `${input.name}:${key}`;
-      const validated = input.model.parse(value);
-      await adapter.set(formattedKey, validated);
+    get descriptor() {
+      return { entities: descriptors };
     },
-    async delete(key) {
-      const formattedKey = `${input.name}:${key}`;
-      await adapter.delete(formattedKey);
-    },
-    async has(key) {
-      const formattedKey = `${input.name}:${key}`;
-      return await adapter.has(formattedKey);
-    },
-    state: {
-      adapter,
-      model: input.model,
-      name: input.name
+    async dispatch(route, payload) {
+      const target = routes.get(route);
+      if (target === void 0) {
+        throw new Error(`no method registered for route "${route}"`);
+      }
+      const fn = target.entity[target.methodName];
+      return fn.call(target.entity, payload);
     }
   };
 }
 
-// src/mongo/adapter.ts
-function MongoAdapter(adapter) {
-  return adapter;
+// 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);
+  }
+  const body = Buffer.concat(chunks);
+  return new Request(url, { method: req.method, headers, body });
 }
-
-// src/mongo/entity.ts
-function MongoEntity(input) {
-  const collection = input.adapter.collection(input.name);
+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);
+  }
+  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) {
   return {
-    async insertOne(doc) {
-      const validated = input.model.parse(doc);
-      const result = await collection.insertOne(validated);
-      return { insertedId: result.insertedId };
-    },
-    async insertMany(docs) {
-      const validated = docs.map((d) => input.model.parse(d));
-      const result = await collection.insertMany(validated);
-      return { insertedIds: Object.values(result.insertedIds) };
-    },
-    async findOne(filter) {
-      const raw = await collection.findOne(filter);
-      return raw === null ? null : input.model.parse(raw);
-    },
-    async find(filter) {
-      const raw = await collection.find(filter);
-      return raw.map((r) => input.model.parse(r));
-    },
-    async updateOne(filter, update) {
-      const result = await collection.updateOne(filter, update);
-      return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
-    },
-    async updateMany(filter, update) {
-      const result = await collection.updateMany(filter, update);
-      return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
-    },
-    async deleteOne(filter) {
-      const result = await collection.deleteOne(filter);
-      return { deletedCount: result.deletedCount };
-    },
-    async deleteMany(filter) {
-      const result = await collection.deleteMany(filter);
-      return { deletedCount: result.deletedCount };
-    },
-    countDocuments: (filter) => collection.countDocuments(filter),
-    state: { name: input.name, adapter: input.adapter, model: input.model }
+    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;
+    }
   };
 }
 export {
-  KvAdapter,
+  Descriptor,
+  EntityBuilder,
   KvEntity,
-  MongoAdapter,
-  MongoEntity
+  MongoEntity,
+  compose,
+  make
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aromix/core",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",
@@ -41,12 +41,19 @@
     "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@aromix/validator": "^0.2.0"
+    "@aromix/validator": "^0.3.0",
+    "mongodb": "^7.3.0"
   },
   "devDependencies": {
-    "@aromix/validator": "^0.2.0",
+    "@aromix/validator": "^0.3.0",
     "@types/node": "^22.10.2",
+    "mongodb": "^7.3.0",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
+  },
+  "peerDependenciesMeta": {
+    "mongodb": {
+      "optional": true
+    }
   }
 }