@aromix/core 0.1.3 → 0.2.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
+import { AnySchema, Operator } from '@aromix/validator';
 
 type Platform = 'node' | 'bun' | 'cloudflare:worker';
 interface BuildConfig {
@@ -12,145 +12,200 @@ interface BuildConfig {
 /** Identity fn :: exists purely for autocomplete and type safety */
 declare function build(options: BuildConfig): BuildConfig;
 
-declare namespace Adapter {
-    interface kv {
-        readonly type: 'kv';
+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>;
     }
-}
-
-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>;
+    function adapter(adapter: Kv.Adapter): Adapter;
+    interface EntityInput<Schema extends AnySchema> {
+        name: string;
+        adapter: Kv.Adapter;
+        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>;
-        [$meta]: {
-            adapter: Adapter.kv;
+        state: {
+            name: string;
+            adapter: Kv.Adapter;
             model: Schema;
-            readAccess: Record<string, boolean>;
-            writeAccess: Record<string, boolean>;
         };
-    };
+    }
+    function entity<Schema extends AnySchema>(input: Kv.EntityInput<Schema>): Kv.EntityOutput<Schema>;
 }
 
-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 ColumnTypeMap {
+    int: number
+    real: number
+    text: string
+    blob: Uint8Array
 }
 
-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> {
-    name: string;
-    storage: Adapter.kv;
-    guards?: any[];
-    effects?: any[];
-    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>;
-    delete(key: string): Promise<void>;
-    [Entity.$meta]: {
-        adapter: Adapter.kv;
-        model: Schema;
-        readAccess: Record<string, boolean>;
-        writeAccess: Record<string, boolean>;
-    };
+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 ComposeConfig {
-    entities: EntityKV<StandardSchemaV1>[];
+interface ColumnReference {
+    entityName: string
+    columnName: string
+    tableState: Record<string, ColumnState>
 }
-interface ResolvedModule {
-    entities: EntityKV<StandardSchemaV1>[];
+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>[]
 }
 
-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;
+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
 }
 
-/**
- *  DML IMPLEMENTATION FOR SQL LITE
- */
-declare class LiteDml {
+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 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 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 function make(app: ResolvedModule): void;
-
-interface ResolvedApp {
-}
+declare const lite: {
+    int(): Chain<"int">;
+    real(): Chain<"real">;
+    text(): Chain<"text">;
+    blob(): Chain<"blob">;
+};
 
-declare namespace Storage {
-    function kv(adapter: Adapter.kv): Adapter.kv;
+declare namespace Sqlite {
+    interface Adapter {
+        query(sql: string): Promise<unknown>;
+    }
+    function adapter(adapter: Sqlite.Adapter): Adapter;
+    interface EntityInput<State extends TableState> {
+        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>;
 }
 
-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 { 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 };

package/dist/index.js

@@ -3,187 +3,226 @@ function build(options) {
   return options;
 }
 
-// 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;
-    }
-  };
-  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)}`);
+// src/drivers/kv.ts
+var Kv;
+((Kv2) => {
+  function adapter(adapter2) {
+    return adapter2;
   }
-  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;
+  Kv2.adapter = adapter;
+  function entity(input) {
+    const adapter2 = input.adapter;
     return {
       async get(key) {
-        const formattedKey = `${configuration.name}:${key}`;
-        const raw = await adapter.get(formattedKey);
-        const validated = await validate(configuration.model, raw);
-        return validated;
+        const formattedKey = `${input.name}:${key}`;
+        const raw = await adapter2.get(formattedKey);
+        return input.model.parse(raw);
       },
       async set(key, value) {
-        const formattedKey = `${configuration.name}:${key}`;
-        const validated = await validate(configuration.model, value);
-        await adapter.set(formattedKey, validated);
+        const formattedKey = `${input.name}:${key}`;
+        const validated = input.model.parse(value);
+        await adapter2.set(formattedKey, validated);
       },
       async delete(key) {
-        const formattedKey = `${configuration.name}:${key}`;
-        await adapter.delete(formattedKey);
+        const formattedKey = `${input.name}:${key}`;
+        await adapter2.delete(formattedKey);
       },
       async has(key) {
-        const formattedKey = `${configuration.name}:${key}`;
-        return await adapter.has(formattedKey);
+        const formattedKey = `${input.name}:${key}`;
+        return await adapter2.has(formattedKey);
       },
-      [Entity2.$meta]: {
-        adapter,
-        model: configuration.model,
-        readAccess: readOperation.state,
-        writeAccess: writeOperation.state
+      state: {
+        adapter: adapter2,
+        model: input.model,
+        name: input.name
       }
     };
   }
-  Entity2.kv = kv;
-})(Entity || (Entity = {}));
+  Kv2.entity = entity;
+})(Kv || (Kv = {}));
 
-// 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/drivers/sqlite.ts
+var Sqlite;
+((Sqlite2) => {
+  function adapter(adapter2) {
+    return adapter2;
   }
-};
-
-// src/fetch/fetch.ts
-function toFetchHandler() {
-}
-
-// 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];
+  Sqlite2.adapter = adapter;
+  function entity(input) {
+    const columns = {};
+    for (const key of Object.keys(input.columns)) {
+      columns[key] = input.columns[key].state;
     }
-    return clone;
-  }
-  Kit2.omit = omit;
-  function crushKeys(input) {
-    const keys = [];
-    const walk = (value, prefix) => {
-      if (prefix) {
-        keys.push(prefix);
+    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;
       }
-      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);
-        }
+    });
+    return {
+      state,
+      col(columnName) {
+        return {
+          entityName: input.name,
+          columnName,
+          tableState: columns
+        };
       }
     };
-    walk(input, "");
-    return keys;
   }
-  Kit2.crushKeys = crushKeys;
-})(Kit || (Kit = {}));
+  Sqlite2.entity = entity;
+})(Sqlite || (Sqlite = {}));
 
-// src/make/make.def.ts
-function make(app) {
-}
+// 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/storage/storage.ts
-var Storage;
-((Storage2) => {
-  function kv(adapter) {
-    return adapter;
-  }
-  Storage2.kv = kv;
-})(Storage || (Storage = {}));
+// 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");
+  }
+};
 export {
-  Codec,
-  Entity,
-  Kit,
-  LiteDml,
-  Storage,
+  Column,
+  Kv,
+  Sqlite,
   build,
-  compose,
-  createOperation,
-  lite,
-  make,
-  toFetchHandler,
-  validate
+  lite
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aromix/core",
-  "version": "0.1.3",
-  "description": "Core runtime-agnostic framework for Aromix",
+  "version": "0.2.0",
+  "description": "The Core Package For Aromix",
   "type": "module",
   "license": "MIT",
   "homepage": "https://aromixjs.github.io/aromix",
@@ -37,14 +37,14 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "dependencies": {
-    "@msgpack/msgpack": "^3.1.3",
-    "@standard-schema/spec": "^1.1.0"
+  "peerDependencies": {
+    "@aromix/validator": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "@aromix/validator": "^0.2.0"
   },
   "scripts": {
     "build": "tsup",