@aromix/core 0.1.1 → 0.1.3

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';
 
-type Platform = "node" | "bun" | "cloudflare:worker";
-interface AromixBuildConfig {
+type Platform = 'node' | 'bun' | 'cloudflare:worker';
+interface BuildConfig {
     entry: string;
     outDir: string;
     platform: Platform;
@@ -10,35 +10,112 @@ 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 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 {  };
 }
-declare function config<T extends Config>(config: T | (() => T)): T;
 
-interface BaseCtx {
-    id: string;
-    payload: unknown;
-    args<T>(schema: StandardSchemaV1<T>): T;
+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 CommandCtx extends BaseCtx {
+interface Operation<Model> {
+    (fields: Type.CrushKeys<Model>[]): void;
+    omit(fields: Type.CrushKeys<Model>[]): void;
 }
-interface StreamCtx extends BaseCtx {
+interface PermissionSet<Model> {
+    read: Operation<Model>;
+    write: Operation<Model>;
 }
-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 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 EventMap = Record<string, unknown>;
 
-declare class Builder {
+interface ComposeConfig {
+    entities: EntityKV<StandardSchemaV1>[];
+}
+interface ResolvedModule {
+    entities: EntityKV<StandardSchemaV1>[];
 }
 
-interface Entity {
+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;
 }
-declare function entity(options: Entity): void;
+
+/**
+ *  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;
@@ -49,15 +126,31 @@ declare const Codec: {
 
 declare function toFetchHandler(): void;
 
-declare function make(): 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 plugin(): void;
+declare function make(app: ResolvedModule): void;
 
-declare global {
-    namespace Aromix {
-        type GlobPattern = string | string[];
-        function load(pattern: GlobPattern): string[];
-    }
+interface ResolvedApp {
+}
+
+declare namespace Storage {
+    function kv(adapter: Adapter.kv): Adapter.kv;
 }
 
-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 { 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 };

package/dist/index.js

@@ -3,21 +3,102 @@ function build(options) {
   return options;
 }
 
-// src/config.ts
-function config(config2) {
-  return typeof config2 === "function" ? config2() : config2;
+// src/compose/compose.def.ts
+function compose(config) {
+  return config;
 }
 
-// src/entity/builder.ts
-var Builder = class {
+// 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/entity/entity.ts
-function entity(options) {
+// 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)}`);
+  }
+  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 { encode, decode } from "@msgpack/msgpack";
+import { decode, encode } from "@msgpack/msgpack";
 var Codec = {
   encode(data) {
     return encode(data);
@@ -31,7 +112,9 @@ var Codec = {
       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;
+    if (buf.byteLength === 0) {
+      return void 0;
+    }
     return decode(new Uint8Array(buf));
   },
   response(data) {
@@ -46,20 +129,61 @@ var Codec = {
 function toFetchHandler() {
 }
 
-// src/make/impl.ts
-function make() {
-}
+// 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/plugin.ts
-function plugin() {
+// src/make/make.def.ts
+function make(app) {
 }
+
+// src/storage/storage.ts
+var Storage;
+((Storage2) => {
+  function kv(adapter) {
+    return adapter;
+  }
+  Storage2.kv = kv;
+})(Storage || (Storage = {}));
 export {
-  Builder,
   Codec,
+  Entity,
+  Kit,
+  LiteDml,
+  Storage,
   build,
-  config,
-  entity,
+  compose,
+  createOperation,
+  lite,
   make,
-  plugin,
-  toFetchHandler
+  toFetchHandler,
+  validate
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aromix/core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Core runtime-agnostic framework for Aromix",
   "type": "module",
   "license": "MIT",
@@ -27,12 +27,10 @@
   "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": {

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 };