@aromix/core 0.1.2 → 0.2.0

package/README.md

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

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
+import { AnySchema, Operator } from '@aromix/validator';
 
-type Platform = "node" | "bun" | "cloudflare:worker";
-interface AromixBuildConfig {
+type Platform = 'node' | 'bun' | 'cloudflare:worker';
+interface BuildConfig {
     entry: string;
     outDir: string;
     platform: Platform;
@@ -10,54 +10,202 @@ interface AromixBuildConfig {
     tsConfig: string;
 }
 /** Identity fn :: exists purely for autocomplete and type safety */
-declare function build(options: AromixBuildConfig): AromixBuildConfig;
+declare function build(options: BuildConfig): BuildConfig;
 
-interface Config {
+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> {
+        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>;
+        state: {
+            name: string;
+            adapter: Kv.Adapter;
+            model: Schema;
+        };
+    }
+    function entity<Schema extends AnySchema>(input: Kv.EntityInput<Schema>): Kv.EntityOutput<Schema>;
 }
-declare function config<T extends Config>(config: T | (() => T)): T;
 
-interface BaseCtx {
-    id: string;
-    payload: unknown;
-    args<T>(schema: StandardSchemaV1<T>): T;
+interface ColumnTypeMap {
+    int: number
+    real: number
+    text: string
+    blob: Uint8Array
 }
-interface CommandCtx extends BaseCtx {
+
+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 StreamCtx extends BaseCtx {
+
+interface ColumnReference {
+    entityName: string
+    columnName: string
+    tableState: Record<string, ColumnState>
 }
-interface SocketCtx<Receive extends EventMap, Send extends EventMap> extends BaseCtx {
-    on<E extends keyof Receive>(event: E, handler: (data: Receive[E]) => void | Promise<void>): void;
-    send<E extends keyof Send>(event: E, data: Send[E]): void;
-    onClose(handler: () => void): void;
-    close(): void;
+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>[]
 }
-type EventMap = Record<string, unknown>;
 
-declare class Builder {
-}
+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 Entity {
+interface CheckExpression {
+    left: string
+    op: 'gt' | 'gte' | 'lt' | 'lte'
+    right: string
 }
-declare function entity(options: Entity): void;
 
-declare const Codec: {
-    encode(data: unknown): Uint8Array;
-    decode(buf: Uint8Array): unknown;
-    fromRequest(req: Request): Promise<unknown>;
-    response(data: unknown): Response;
-};
+type ColumnKey<State extends TableState> = keyof State & string
 
-declare function toFetchHandler(): void;
+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 make(): 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 function plugin(): void;
+declare const lite: {
+    int(): Chain<"int">;
+    real(): Chain<"real">;
+    text(): Chain<"text">;
+    blob(): Chain<"blob">;
+};
 
-declare global {
-    namespace Aromix {
-        type GlobPattern = string | string[];
-        function load(pattern: GlobPattern): string[];
+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 { type AromixBuildConfig, type BaseCtx, Builder, Codec, type CommandCtx, type Config, type EventMap, type Platform, type SocketCtx, type StreamCtx, build, config, entity, make, plugin, toFetchHandler };
+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,63 +3,226 @@ function build(options) {
   return options;
 }
 
-// src/config.ts
-function config(config2) {
-  return typeof config2 === "function" ? config2() : config2;
-}
+// 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/entity/builder.ts
-var Builder = class {
-};
+// 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;
+    }
+    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/entity/entity.ts
-function entity(options) {
-}
+// 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/fetch/codec.ts
-import { encode, decode } from "@msgpack/msgpack";
-var Codec = {
-  encode(data) {
-    return encode(data);
+// src/lite/index.ts
+var lite = {
+  int() {
+    return Column.create("int");
   },
-  decode(buf) {
-    return decode(buf);
+  real() {
+    return Column.create("real");
   },
-  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));
+  text() {
+    return Column.create("text");
   },
-  response(data) {
-    return new Response(encode(data), {
-      status: 200,
-      headers: { "Content-Type": "application/x-msgpack" }
-    });
+  blob() {
+    return Column.create("blob");
   }
 };
-
-// src/fetch/fetch.ts
-function toFetchHandler() {
-}
-
-// src/make/impl.ts
-function make() {
-}
-
-// src/plugin.ts
-function plugin() {
-}
 export {
-  Builder,
-  Codec,
+  Column,
+  Kv,
+  Sqlite,
   build,
-  config,
-  entity,
-  make,
-  plugin,
-  toFetchHandler
+  lite
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aromix/core",
-  "version": "0.1.2",
-  "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",
@@ -27,26 +27,24 @@
   "files": [
     "dist"
   ],
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": "./dist/index.js"
     }
   },
   "publishConfig": {
     "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",

package/dist/index.cjs

@@ -1,65 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/build.ts
-function build(options) {
-  return options;
-}
-
-// src/config.ts
-function config(config2) {
-  return typeof config2 === "function" ? config2() : config2;
-}
-
-// src/entity/builder.ts
-var Builder = class {
-};
-
-// src/entity/entity.ts
-function entity(options) {
-}
-
-// src/fetch/codec.ts
-var _msgpack = require('@msgpack/msgpack');
-var Codec = {
-  encode(data) {
-    return _msgpack.encode.call(void 0, data);
-  },
-  decode(buf) {
-    return _msgpack.decode.call(void 0, 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 _msgpack.decode.call(void 0, new Uint8Array(buf));
-  },
-  response(data) {
-    return new Response(_msgpack.encode.call(void 0, data), {
-      status: 200,
-      headers: { "Content-Type": "application/x-msgpack" }
-    });
-  }
-};
-
-// src/fetch/fetch.ts
-function toFetchHandler() {
-}
-
-// src/make/impl.ts
-function make() {
-}
-
-// src/plugin.ts
-function plugin() {
-}
-
-
-
-
-
-
-
-
-
-exports.Builder = Builder; exports.Codec = Codec; exports.build = build; exports.config = config; exports.entity = entity; exports.make = make; exports.plugin = plugin; exports.toFetchHandler = toFetchHandler;

package/dist/index.d.cts

@@ -1,63 +0,0 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
-
-type Platform = "node" | "bun" | "cloudflare:worker";
-interface AromixBuildConfig {
-    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: AromixBuildConfig): AromixBuildConfig;
-
-interface Config {
-}
-declare function config<T extends Config>(config: T | (() => T)): T;
-
-interface BaseCtx {
-    id: string;
-    payload: unknown;
-    args<T>(schema: StandardSchemaV1<T>): T;
-}
-interface CommandCtx extends BaseCtx {
-}
-interface StreamCtx extends BaseCtx {
-}
-interface SocketCtx<Receive extends EventMap, Send extends EventMap> extends BaseCtx {
-    on<E extends keyof Receive>(event: E, handler: (data: Receive[E]) => void | Promise<void>): void;
-    send<E extends keyof Send>(event: E, data: Send[E]): void;
-    onClose(handler: () => void): void;
-    close(): void;
-}
-type EventMap = Record<string, unknown>;
-
-declare class Builder {
-}
-
-interface Entity {
-}
-declare function entity(options: Entity): void;
-
-declare const Codec: {
-    encode(data: unknown): Uint8Array;
-    decode(buf: Uint8Array): unknown;
-    fromRequest(req: Request): Promise<unknown>;
-    response(data: unknown): Response;
-};
-
-declare function toFetchHandler(): void;
-
-declare function make(): void;
-
-declare function plugin(): void;
-
-declare global {
-    namespace Aromix {
-        type GlobPattern = string | string[];
-        function load(pattern: GlobPattern): string[];
-    }
-}
-
-export { type AromixBuildConfig, type BaseCtx, Builder, Codec, type CommandCtx, type Config, type EventMap, type Platform, type SocketCtx, type StreamCtx, build, config, entity, make, plugin, toFetchHandler };