@aromix/core 0.1.3 → 0.3.0

package/dist/index.d.ts

@@ -1,156 +1,96 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
+import { AnySchema } from '@aromix/validator';
 
-type Platform = 'node' | 'bun' | 'cloudflare:worker';
-interface BuildConfig {
-    entry: string;
-    outDir: string;
-    platform: Platform;
-    sourcemap: boolean;
-    minify: boolean;
-    tsConfig: string;
-}
-/** Identity fn :: exists purely for autocomplete and type safety */
-declare function build(options: BuildConfig): BuildConfig;
-
-declare namespace Adapter {
-    interface kv {
-        readonly type: 'kv';
-        get(key: string): Promise<unknown>;
-        set(key: string, value: unknown): Promise<void>;
-        delete(key: string): Promise<void>;
-        has(key: string): Promise<boolean>;
-    }
-}
-
-declare namespace Entity {
-    const $meta: unique symbol;
-    function kv<Schema extends StandardSchemaV1>(configuration: EntityConfig<Schema>): {
-        get(key: string): Promise<SchemaOutput<Schema>>;
-        set(key: string, value: SchemaInput<Schema>): Promise<void>;
-        delete(key: string): Promise<void>;
-        has(key: string): Promise<boolean>;
-        [$meta]: {
-            adapter: Adapter.kv;
-            model: Schema;
-            readAccess: Record<string, boolean>;
-            writeAccess: Record<string, boolean>;
-        };
-    };
-}
-
-declare namespace Type {
-    /** Resolves a mapped/generic type into a plain object shape — improves IDE hover readability. */
-    export type Prettify<TargetType> = {
-        [Key in keyof TargetType]: TargetType[Key];
-    } & {};
-    /** Recursively walks object keys, producing all dot-joined paths. Returns `never` for primitives, null, and undefined. */
-    type WalkKeys<Input> = Input extends object ? {
-        [Key in keyof Input & string]: Key | `${Key}.${CrushKeys<Input[Key]>}`;
-    }[keyof Input & string] : never;
-    /** Returns all dot-joined key paths for a given object. Stops at arrays and `Date`. e.g. `{ a: { b: 1 } }` → `"a" | "a.b"` */
-    export type CrushKeys<Input> = Input extends unknown[] | Date ? never : WalkKeys<Input>;
-    export {  };
+interface KvAdapter {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
 }
+declare function KvAdapter(adapter: KvAdapter): KvAdapter;
 
-type SchemaInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
-type SchemaOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
-interface EntityConfig<Schema extends StandardSchemaV1> {
+interface KvEntityInput<Schema extends AnySchema> {
     name: string;
-    storage: Adapter.kv;
-    guards?: any[];
-    effects?: any[];
+    adapter: KvAdapter;
     model: Schema;
-    access: (can: PermissionSet<SchemaOutput<Schema>>) => void;
-}
-interface Operation<Model> {
-    (fields: Type.CrushKeys<Model>[]): void;
-    omit(fields: Type.CrushKeys<Model>[]): void;
 }
-interface PermissionSet<Model> {
-    read: Operation<Model>;
-    write: Operation<Model>;
-}
-interface EntityKV<Schema extends StandardSchemaV1> {
-    get(key: string): Promise<SchemaOutput<Schema>>;
-    set(key: string, value: SchemaInput<Schema>): Promise<void>;
+interface KvEntityOutput<Schema extends AnySchema> {
+    get(key: string): Promise<Schema['$infer']>;
+    set(key: string, value: Schema['$infer']): Promise<void>;
     delete(key: string): Promise<void>;
-    [Entity.$meta]: {
-        adapter: Adapter.kv;
+    has(key: string): Promise<boolean>;
+    state: {
+        name: string;
+        adapter: KvAdapter;
         model: Schema;
-        readAccess: Record<string, boolean>;
-        writeAccess: Record<string, boolean>;
     };
 }
-
-interface ComposeConfig {
-    entities: EntityKV<StandardSchemaV1>[];
+declare function KvEntity<Schema extends AnySchema>(input: KvEntityInput<Schema>): KvEntityOutput<Schema>;
+
+interface MongoCollectionAdapter {
+    insertOne(doc: unknown): Promise<{
+        insertedId: unknown;
+    }>;
+    insertMany(docs: unknown[]): Promise<{
+        insertedIds: unknown[];
+    }>;
+    findOne(filter: unknown): Promise<unknown | null>;
+    find(filter: unknown): Promise<unknown[]>;
+    updateOne(filter: unknown, update: unknown): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    updateMany(filter: unknown, update: unknown): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    deleteOne(filter: unknown): Promise<{
+        deletedCount: number;
+    }>;
+    deleteMany(filter: unknown): Promise<{
+        deletedCount: number;
+    }>;
+    countDocuments(filter?: unknown): Promise<number>;
 }
-interface ResolvedModule {
-    entities: EntityKV<StandardSchemaV1>[];
-}
-
-declare function compose(config: ComposeConfig): ResolvedModule;
-
-/**
- *  DDL IMPLEMENTATION FOR SQL LITE
- */
-declare class lite {
-    private constructor();
-    static table(): void;
-    static integer(): void;
-    static int(): void;
-    static real(): void;
-    static text(): void;
-    static blob(): void;
-    static numeric(): void;
-    static any(): void;
+interface MongoAdapter {
+    collection(name: string): MongoCollectionAdapter;
 }
+declare function MongoAdapter(adapter: MongoAdapter): MongoAdapter;
 
-/**
- *  DML IMPLEMENTATION FOR SQL LITE
- */
-declare class LiteDml {
-}
-
-declare function createOperation<Model>(): Operation<Model> & {
-    state: Record<string, boolean>;
-};
-declare function validate<Schema extends StandardSchemaV1>(schema: Schema, value: unknown): Promise<SchemaOutput<Schema>>;
-
-declare const Codec: {
-    encode(data: unknown): Uint8Array;
-    decode(buf: Uint8Array): unknown;
-    fromRequest(req: Request): Promise<unknown>;
-    response(data: unknown): Response;
-};
-
-declare function toFetchHandler(): void;
-
-/**
- * Global utility namespace.
- * Holds internal helper functions that are not bound to any specific feature.
- */
-declare namespace Kit {
-    /**
-     * Returns a shallow clone of `input` with the specified keys removed.
-     * Preserves the prototype chain.
-     */
-    function omit<Input, Keys extends keyof Input>(input: Input, remove: Keys[]): Type.Prettify<Omit<Input, Keys>>;
-    /**
-     * Walks an object recursively and returns all dot-joined key paths.
-     * e.g. `{ a: { b: 1 } }` → `["a", "a.b"]`
-     * Stops at arrays and non-plain objects.
-     */
-    function crushKeys<Input>(input: Input): Type.CrushKeys<Input>[];
-}
-
-declare function make(app: ResolvedModule): void;
-
-interface ResolvedApp {
+interface MongoEntityInput<Schema extends AnySchema> {
+    name: string;
+    adapter: MongoAdapter;
+    model: Schema;
 }
-
-declare namespace Storage {
-    function kv(adapter: Adapter.kv): Adapter.kv;
+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: {
+        name: string;
+        adapter: MongoAdapter;
+        model: Schema;
+    };
 }
+declare function MongoEntity<Schema extends AnySchema>(input: MongoEntityInput<Schema>): MongoEntityOutput<Schema>;
 
-export { Adapter, type BuildConfig, Codec, type ComposeConfig, Entity, type EntityConfig, type EntityKV, Kit, LiteDml, type Operation, type PermissionSet, type Platform, type ResolvedApp, type ResolvedModule, type SchemaInput, type SchemaOutput, Storage, Type, build, compose, createOperation, lite, make, toFetchHandler, validate };
+export { KvAdapter, KvEntity, type KvEntityInput, type KvEntityOutput, MongoAdapter, type MongoCollectionAdapter, MongoEntity, type MongoEntityInput, type MongoEntityOutput };

package/dist/index.js

@@ -1,189 +1,74 @@
-// src/build.ts
-function build(options) {
-  return options;
+// src/kv/adapter.ts
+function KvAdapter(adapter) {
+  return adapter;
 }
 
-// src/compose/compose.def.ts
-function compose(config) {
-  return config;
-}
-
-// src/ddl/lite.ddl.ts
-var lite = class {
-  constructor() {
-  }
-  static table() {
-  }
-  static integer() {
-  }
-  static int() {
-  }
-  static real() {
-  }
-  static text() {
-  }
-  static blob() {
-  }
-  static numeric() {
-  }
-  static any() {
-  }
-};
-
-// src/dml/lite.dml.ts
-var LiteDml = class {
-};
-
-// src/entity/entity.util.ts
-function createOperation() {
-  const state = {};
-  const handler = (fields) => {
-    for (const field of fields) {
-      state[field] = true;
-    }
-  };
-  handler.omit = (fields) => {
-    for (const field of fields) {
-      state[field] = false;
+// src/kv/entity.ts
+function KvEntity(input) {
+  const adapter = input.adapter;
+  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);
+    },
+    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
     }
   };
-  return Object.assign(handler, { omit: handler.omit, state });
-}
-async function validate(schema, value) {
-  const result = await schema["~standard"].validate(value);
-  if ("issues" in result) {
-    throw new Error(`Validation failed: ${JSON.stringify(result.issues)}`);
-  }
-  return result.value;
 }
 
-// src/entity/entity.def.ts
-var Entity;
-((Entity2) => {
-  Entity2.$meta = /* @__PURE__ */ Symbol.for("entity:meta");
-  function kv(configuration) {
-    const readOperation = createOperation();
-    const writeOperation = createOperation();
-    configuration.access({ read: readOperation, write: writeOperation });
-    const adapter = configuration.storage;
-    return {
-      async get(key) {
-        const formattedKey = `${configuration.name}:${key}`;
-        const raw = await adapter.get(formattedKey);
-        const validated = await validate(configuration.model, raw);
-        return validated;
-      },
-      async set(key, value) {
-        const formattedKey = `${configuration.name}:${key}`;
-        const validated = await validate(configuration.model, value);
-        await adapter.set(formattedKey, validated);
-      },
-      async delete(key) {
-        const formattedKey = `${configuration.name}:${key}`;
-        await adapter.delete(formattedKey);
-      },
-      async has(key) {
-        const formattedKey = `${configuration.name}:${key}`;
-        return await adapter.has(formattedKey);
-      },
-      [Entity2.$meta]: {
-        adapter,
-        model: configuration.model,
-        readAccess: readOperation.state,
-        writeAccess: writeOperation.state
-      }
-    };
-  }
-  Entity2.kv = kv;
-})(Entity || (Entity = {}));
-
-// src/fetch/codec.ts
-import { decode, encode } from "@msgpack/msgpack";
-var Codec = {
-  encode(data) {
-    return encode(data);
-  },
-  decode(buf) {
-    return decode(buf);
-  },
-  async fromRequest(req) {
-    const contentType = req.headers.get("content-type");
-    if (contentType !== "application/x-msgpack") {
-      throw new Error(`Invalid content-type "${contentType}" \u2014 only application/x-msgpack is accepted`);
-    }
-    const buf = await req.arrayBuffer();
-    if (buf.byteLength === 0) {
-      return void 0;
-    }
-    return decode(new Uint8Array(buf));
-  },
-  response(data) {
-    return new Response(encode(data), {
-      status: 200,
-      headers: { "Content-Type": "application/x-msgpack" }
-    });
-  }
-};
-
-// src/fetch/fetch.ts
-function toFetchHandler() {
+// src/mongo/adapter.ts
+function MongoAdapter(adapter) {
+  return adapter;
 }
 
-// src/global/kit.ts
-var Kit;
-((Kit2) => {
-  function omit(input, remove) {
-    const proto = Object.getPrototypeOf(input);
-    const clone = Object.create(proto);
-    Object.assign(clone, input);
-    for (const key of remove) {
-      delete clone[key];
-    }
-    return clone;
-  }
-  Kit2.omit = omit;
-  function crushKeys(input) {
-    const keys = [];
-    const walk = (value, prefix) => {
-      if (prefix) {
-        keys.push(prefix);
-      }
-      if (value !== null && typeof value === "object" && value.constructor === Object) {
-        for (const [entryKey, entryValue] of Object.entries(value)) {
-          const path = prefix ? `${prefix}.${entryKey}` : entryKey;
-          walk(entryValue, path);
-        }
-      }
-    };
-    walk(input, "");
-    return keys;
-  }
-  Kit2.crushKeys = crushKeys;
-})(Kit || (Kit = {}));
-
-// src/make/make.def.ts
-function make(app) {
+// src/mongo/entity.ts
+function MongoEntity(input) {
+  const collection = input.adapter.collection(input.name);
+  return {
+    async insertOne(doc) {
+      const validated = input.model.parse(doc);
+      return collection.insertOne(validated);
+    },
+    async insertMany(docs) {
+      const validated = docs.map((d) => input.model.parse(d));
+      return collection.insertMany(validated);
+    },
+    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));
+    },
+    updateOne: (filter, update) => collection.updateOne(filter, update),
+    updateMany: (filter, update) => collection.updateMany(filter, update),
+    deleteOne: (filter) => collection.deleteOne(filter),
+    deleteMany: (filter) => collection.deleteMany(filter),
+    countDocuments: (filter) => collection.countDocuments(filter),
+    state: { name: input.name, adapter: input.adapter, model: input.model }
+  };
 }
-
-// src/storage/storage.ts
-var Storage;
-((Storage2) => {
-  function kv(adapter) {
-    return adapter;
-  }
-  Storage2.kv = kv;
-})(Storage || (Storage = {}));
 export {
-  Codec,
-  Entity,
-  Kit,
-  LiteDml,
-  Storage,
-  build,
-  compose,
-  createOperation,
-  lite,
-  make,
-  toFetchHandler,
-  validate
+  KvAdapter,
+  KvEntity,
+  MongoAdapter,
+  MongoEntity
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aromix/core",
-  "version": "0.1.3",
-  "description": "Core runtime-agnostic framework for Aromix",
+  "version": "0.3.0",
+  "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",
   "homepage": "https://aromixjs.github.io/aromix",
@@ -19,9 +19,7 @@
     "server",
     "framework",
     "runtime-agnostic",
-    "bun",
     "deno",
-    "cloudflare",
     "node"
   ],
   "files": [
@@ -37,18 +35,18 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "dependencies": {
-    "@msgpack/msgpack": "^3.1.3",
-    "@standard-schema/spec": "^1.1.0"
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@aromix/validator": "^0.2.0"
   },
   "devDependencies": {
+    "@aromix/validator": "^0.2.0",
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
   }
-}
+}

package/README.md

@@ -1,3 +0,0 @@
-# @aromix/core
-
-Core runtime-agnostic framework for Aromix.