@aromix/core 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,211 +1,96 @@
-import { AnySchema, Operator } from '@aromix/validator';
+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;
+interface KvAdapter {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    has(key: string): Promise<boolean>;
 }
-/** Identity fn :: exists purely for autocomplete and type safety */
-declare function build(options: BuildConfig): BuildConfig;
+declare function KvAdapter(adapter: KvAdapter): KvAdapter;
 
-declare namespace Kv {
-    interface Adapter {
-        get(key: string): Promise<unknown>;
-        set(key: string, value: unknown): Promise<void>;
-        delete(key: string): Promise<void>;
-        has(key: string): Promise<boolean>;
-    }
-    function adapter(adapter: Kv.Adapter): Adapter;
-    interface EntityInput<Schema extends AnySchema> {
+interface KvEntityInput<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: Kv.Adapter;
+        adapter: KvAdapter;
         model: Schema;
-    }
-    interface EntityOutput<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: Kv.Adapter;
-            model: Schema;
-        };
-    }
-    function entity<Schema extends AnySchema>(input: Kv.EntityInput<Schema>): Kv.EntityOutput<Schema>;
+    };
 }
-
-interface ColumnTypeMap {
-    int: number
-    real: number
-    text: string
-    blob: Uint8Array
+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>;
 }
-
-type ColumnType = keyof ColumnTypeMap
-
-type UniqueConflict = 'conflict:error' | 'conflict:replace' | 'conflict:ignore'
-type Collation = 'binary' | 'nocase' | 'rtrim'
-
-type ReferenceAction =
-    | 'delete:noAction'
-    | 'update:noAction'
-    | 'delete:restrict'
-    | 'update:restrict'
-    | 'delete:cascade'
-    | 'update:cascade'
-    | 'delete:setNull'
-    | 'update:setNull'
-    | 'delete:setDefault'
-    | 'update:setDefault'
-
-interface CheckEntry {
-    op: 'gt' | 'gte' | 'lt' | 'lte' | 'minLength' | 'maxLength'
-    val: number
+interface MongoAdapter {
+    collection(name: string): MongoCollectionAdapter;
 }
+declare function MongoAdapter(adapter: MongoAdapter): MongoAdapter;
 
-interface ColumnReference {
-    entityName: string
-    columnName: string
-    tableState: Record<string, ColumnState>
-}
-interface ColumnState {
-    colType: ColumnType
-    primaryKey: boolean
-    autoIncrement: boolean
-    notNull: boolean
-    unique: boolean
-    uniqueConflict: UniqueConflict
-    index: boolean
-    checks: CheckEntry[]
-    in: string[]
-    collate?: Collation
-    references?: { col: ColumnReference; actions: ReferenceAction[] }
-    default?: unknown
-    defaultFn?: () => unknown
-    onUpdate?: () => unknown
-    pipes: Operator<any, any>[]
+interface MongoEntityInput<Schema extends AnySchema> {
+    name: string;
+    adapter: MongoAdapter;
+    model: Schema;
 }
-
-type Chain<Type extends ColumnType, Used extends string = never, Output = ColumnTypeMap[Type]> = Omit<
-    {
-        readonly state: ColumnState
-        primaryKey(): Chain<Type, Used | 'primaryKey'>
-        autoIncrement(): Chain<Type, Used | 'autoIncrement'>
-        notNull(): Chain<Type, Used | 'notNull'>
-        unique(conflict?: UniqueConflict): Chain<Type, Used | 'unique'>
-        index(): Chain<Type, Used | 'index'>
-        collate(value: Collation): Chain<Type, Used | 'collate'>
-        gt(value: number): Chain<Type, Used>
-        gte(value: number): Chain<Type, Used>
-        lt(value: number): Chain<Type, Used>
-        lte(value: number): Chain<Type, Used>
-        minLength(value: number): Chain<Type, Used>
-        maxLength(value: number): Chain<Type, Used>
-        in(values: string[]): Chain<Type, Used | 'in'>
-        references(col: unknown, actions?: ReferenceAction[]): Chain<Type, Used | 'references'>
-        default(value: ColumnTypeMap[Type]): Chain<Type, Used | 'default'>
-        defaultFn(fn: () => ColumnTypeMap[Type]): Chain<Type, Used | 'defaultFn'>
-        onUpdate(fn: () => ColumnTypeMap[Type]): Chain<Type, Used | 'onUpdate'>
-        pipe<Next>(operator: Operator<Output, Next>): Chain<Type, Used, Next>
-    },
-    Used
->
-
-type TableState = Record<string, { readonly state: ColumnState }>
-
-interface CheckExpression {
-    left: string
-    op: 'gt' | 'gte' | 'lt' | 'lte'
-    right: string
-}
-
-type ColumnKey<State extends TableState> = keyof State & string
-
-interface TableOptionsCtx<State extends TableState> {
-    unique(cols: ColumnKey<State>[], conflict: UniqueConflict): void
-    primaryKey(cols: ColumnKey<State>[]): void
-    index(cols: ColumnKey<State>[]): void
-    uniqueIndex(cols: ColumnKey<State>[]): void
-    checks(exprs: CheckExpression[]): void
-    gt(left: ColumnKey<State>, right: ColumnKey<State>): CheckExpression
-    gte(left: ColumnKey<State>, right: ColumnKey<State>): CheckExpression
-    lt(left: ColumnKey<State>, right: ColumnKey<State>): CheckExpression
-    lte(left: ColumnKey<State>, right: ColumnKey<State>): CheckExpression
-    withoutRowId(): void
-}
-
-declare class Column<Type extends ColumnType> {
-    readonly state: ColumnState;
-    private constructor();
-    static create<Type extends ColumnType>(colType: Type): Chain<Type>;
-    primaryKey(): this;
-    autoIncrement(): this;
-    notNull(): this;
-    unique(conflict: UniqueConflict): this;
-    index(): this;
-    collate(value: Collation): this;
-    gt(value: number): this;
-    gte(value: number): this;
-    lt(value: number): this;
-    lte(value: number): this;
-    minLength(value: number): this;
-    maxLength(value: number): this;
-    in(values: string[]): this;
-    references(col: ColumnReference, actions?: ReferenceAction[]): this;
-    default(value: ColumnTypeMap[Type]): this;
-    defaultFn(fn: () => ColumnTypeMap[Type]): this;
-    onUpdate(fn: () => ColumnTypeMap[Type]): this;
-    pipe<Next>(operator: Operator<ColumnTypeMap[Type], Next>): this;
-}
-
-declare const lite: {
-    int(): Chain<"int">;
-    real(): Chain<"real">;
-    text(): Chain<"text">;
-    blob(): Chain<"blob">;
-};
-
-declare namespace Sqlite {
-    interface Adapter {
-        query(sql: string): Promise<unknown>;
-    }
-    function adapter(adapter: Sqlite.Adapter): Adapter;
-    interface EntityInput<State extends TableState> {
+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: Sqlite.Adapter;
-        columns: State;
-        options(ctx: TableOptionsCtx<State>): void;
-    }
-    interface EntityOutput<State extends TableState> {
-        state: {
-            name: string;
-            columns: {
-                [Key in keyof State]: ColumnState;
-            };
-            unique: {
-                cols: string[];
-                conflict?: UniqueConflict;
-            }[];
-            primaryKey: {
-                cols: string[];
-            }[];
-            index: {
-                cols: string[];
-            }[];
-            uniqueIndex: {
-                cols: string[];
-            }[];
-            checks: CheckExpression[];
-            withoutRowId: boolean;
-        };
-        col(columnName: ColumnKey<State>): ColumnReference;
-    }
-    function entity<State extends TableState>(input: Sqlite.EntityInput<State>): Sqlite.EntityOutput<State>;
+        adapter: MongoAdapter;
+        model: Schema;
+    };
 }
+declare function MongoEntity<Schema extends AnySchema>(input: MongoEntityInput<Schema>): MongoEntityOutput<Schema>;
 
-export { type BuildConfig, type Chain, type CheckExpression, Column, type ColumnKey, type ColumnReference, type ColumnState, Kv, type Platform, Sqlite, type TableOptionsCtx, type TableState, type UniqueConflict, build, lite };
+export { KvAdapter, KvEntity, type KvEntityInput, type KvEntityOutput, MongoAdapter, type MongoCollectionAdapter, MongoEntity, type MongoEntityInput, type MongoEntityOutput };

package/dist/index.js

@@ -1,228 +1,74 @@
-// src/build.ts
-function build(options) {
-  return options;
+// src/kv/adapter.ts
+function KvAdapter(adapter) {
+  return adapter;
 }
 
-// src/drivers/kv.ts
-var Kv;
-((Kv2) => {
-  function adapter(adapter2) {
-    return adapter2;
-  }
-  Kv2.adapter = adapter;
-  function entity(input) {
-    const adapter2 = input.adapter;
-    return {
-      async get(key) {
-        const formattedKey = `${input.name}:${key}`;
-        const raw = await adapter2.get(formattedKey);
-        return input.model.parse(raw);
-      },
-      async set(key, value) {
-        const formattedKey = `${input.name}:${key}`;
-        const validated = input.model.parse(value);
-        await adapter2.set(formattedKey, validated);
-      },
-      async delete(key) {
-        const formattedKey = `${input.name}:${key}`;
-        await adapter2.delete(formattedKey);
-      },
-      async has(key) {
-        const formattedKey = `${input.name}:${key}`;
-        return await adapter2.has(formattedKey);
-      },
-      state: {
-        adapter: adapter2,
-        model: input.model,
-        name: input.name
-      }
-    };
-  }
-  Kv2.entity = entity;
-})(Kv || (Kv = {}));
-
-// src/drivers/sqlite.ts
-var Sqlite;
-((Sqlite2) => {
-  function adapter(adapter2) {
-    return adapter2;
-  }
-  Sqlite2.adapter = adapter;
-  function entity(input) {
-    const columns = {};
-    for (const key of Object.keys(input.columns)) {
-      columns[key] = input.columns[key].state;
+// 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
     }
-    const state = {
-      name: input.name,
-      columns,
-      unique: [],
-      primaryKey: [],
-      index: [],
-      uniqueIndex: [],
-      checks: [],
-      withoutRowId: false
-    };
-    input.options({
-      unique(cols, conflict) {
-        state.unique.push({ cols, conflict });
-      },
-      primaryKey(cols) {
-        state.primaryKey.push({ cols });
-      },
-      index(cols) {
-        state.index.push({ cols });
-      },
-      uniqueIndex(cols) {
-        state.uniqueIndex.push({ cols });
-      },
-      checks(exprs) {
-        state.checks = exprs;
-      },
-      gt(left, right) {
-        return { left, op: "gt", right };
-      },
-      gte(left, right) {
-        return { left, op: "gte", right };
-      },
-      lt(left, right) {
-        return { left, op: "lt", right };
-      },
-      lte(left, right) {
-        return { left, op: "lte", right };
-      },
-      withoutRowId() {
-        state.withoutRowId = true;
-      }
-    });
-    return {
-      state,
-      col(columnName) {
-        return {
-          entityName: input.name,
-          columnName,
-          tableState: columns
-        };
-      }
-    };
-  }
-  Sqlite2.entity = entity;
-})(Sqlite || (Sqlite = {}));
+  };
+}
 
-// src/lite/column.ts
-var Column = class _Column {
-  constructor(state) {
-    this.state = state;
-  }
-  state;
-  static create(colType) {
-    return new _Column({
-      colType,
-      primaryKey: false,
-      autoIncrement: false,
-      notNull: false,
-      unique: false,
-      uniqueConflict: "conflict:error",
-      index: false,
-      checks: [],
-      in: [],
-      pipes: []
-    });
-  }
-  primaryKey() {
-    this.state.primaryKey = true;
-    return this;
-  }
-  autoIncrement() {
-    this.state.autoIncrement = true;
-    return this;
-  }
-  notNull() {
-    this.state.notNull = true;
-    return this;
-  }
-  unique(conflict) {
-    this.state.unique = true;
-    this.state.uniqueConflict = conflict;
-    return this;
-  }
-  index() {
-    this.state.index = true;
-    return this;
-  }
-  collate(value) {
-    this.state.collate = value;
-    return this;
-  }
-  gt(value) {
-    this.state.checks.push({ op: "gt", val: value });
-    return this;
-  }
-  gte(value) {
-    this.state.checks.push({ op: "gte", val: value });
-    return this;
-  }
-  lt(value) {
-    this.state.checks.push({ op: "lt", val: value });
-    return this;
-  }
-  lte(value) {
-    this.state.checks.push({ op: "lte", val: value });
-    return this;
-  }
-  minLength(value) {
-    this.state.checks.push({ op: "minLength", val: value });
-    return this;
-  }
-  maxLength(value) {
-    this.state.checks.push({ op: "maxLength", val: value });
-    return this;
-  }
-  in(values) {
-    this.state.in = values;
-    return this;
-  }
-  references(col, actions = []) {
-    this.state.references = { col, actions };
-    return this;
-  }
-  default(value) {
-    this.state.default = value;
-    return this;
-  }
-  defaultFn(fn) {
-    this.state.defaultFn = fn;
-    return this;
-  }
-  onUpdate(fn) {
-    this.state.onUpdate = fn;
-    return this;
-  }
-  pipe(operator) {
-    this.state.pipes.push(operator);
-    return this;
-  }
-};
+// src/mongo/adapter.ts
+function MongoAdapter(adapter) {
+  return adapter;
+}
 
-// src/lite/index.ts
-var lite = {
-  int() {
-    return Column.create("int");
-  },
-  real() {
-    return Column.create("real");
-  },
-  text() {
-    return Column.create("text");
-  },
-  blob() {
-    return Column.create("blob");
-  }
-};
+// 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 }
+  };
+}
 export {
-  Column,
-  Kv,
-  Sqlite,
-  build,
-  lite
+  KvAdapter,
+  KvEntity,
+  MongoAdapter,
+  MongoEntity
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aromix/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",
@@ -19,9 +19,7 @@
     "server",
     "framework",
     "runtime-agnostic",
-    "bun",
     "deno",
-    "cloudflare",
     "node"
   ],
   "files": [
@@ -37,18 +35,18 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
+  "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",
-    "@aromix/validator": "^0.2.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit"
+    "typescript": "^5.7.2"
   }
-}
+}

package/README.md

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