chore: bump version to 0.18.1 and update jsonv-ts dependency to 0.8.5

docs: add note about Cloudflare Image Optimization plugin requirement

.cursor/mcp.json

@@ -0,0 +1,7 @@
+{
+  "mcpServers": {
+    "bknd": {
+      "url": "http://localhost:28623/api/system/mcp"
+    }
+  }
+}

.github/workflows/test.yml

@@ -12,15 +12,28 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22.x"
+          
       - name: Setup Bun
         uses: oven-sh/setup-bun@v1
         with:
-          bun-version: latest
+          bun-version: "1.2.22"
 
       - name: Install dependencies
         working-directory: ./app
         run: bun install
 
-      - name: Run tests
+      - name: Build
         working-directory: ./app
-        run: bun run test
+        run: bun run build:ci
+
+      - name: Run Bun tests
+        working-directory: ./app
+        run: bun run test:bun
+
+      - name: Run Node tests
+        working-directory: ./app
+        run: npm run test:node

.gitignore

@@ -29,4 +29,8 @@ packages/media/.env
 .idea
 .vscode
 .git_old
-docker/tmp
+docker/tmp
+.debug
+.history
+.aider*
+.vercel

.nvmrc

@@ -0,0 +1 @@
+22

README.md

@@ -1,31 +1,38 @@
 [![npm version](https://img.shields.io/npm/v/bknd.svg)](https://npmjs.org/package/bknd)
-[![npm downloads](https://img.shields.io/npm/dm/bknd)](https://www.npmjs.com/package/bknd)
 
-![bknd](https://raw.githubusercontent.com/bknd-io/bknd/refs/heads/main/docs/_assets/poster.png)
+![bknd](https://raw.githubusercontent.com/bknd-io/bknd/refs/heads/main/docs/public/assets/poster.png)
 
 <p align="center" width="100%">
-<a href="https://stackblitz.com/github/bknd-io/bknd-examples?hideExplorer=1&embed=1&view=preview&startScript=example-admin-rich&initialPath=%2Fdata%2Fschema" target="_blank">
+<a href="https://stackblitz.com/github/bknd-io/bknd-demo?hideExplorer=1&embed=1&view=preview&initialPath=%2Fdata%2Fschema" target="_blank">
 <strong>⭐ Live Demo</strong>
 </a>
 </p>
 
 bknd simplifies app development by providing a fully functional backend for database management, authentication, media and workflows. Being lightweight and built on Web Standards, it can be deployed nearly anywhere, including running inside your framework of choice. No more deploying multiple separate services!
+* **Runtimes**: Node.js 22+, Bun 1.0+, Deno, Browser, Cloudflare Workers/Pages, Vercel, Netlify, AWS Lambda, etc.
+* **Databases**:
+  * SQLite: LibSQL, Node SQLite, Bun SQLite, Cloudflare D1, Cloudflare Durable Objects SQLite, SQLocal
+  * Postgres: Vanilla Postgres, Supabase, Neon, Xata
+* **Frameworks**: React, Next.js, React Router, Astro, Vite, Waku
+* **Storage**: AWS S3, S3-compatible (Tigris, R2, Minio, etc.), Cloudflare R2 (binding), Cloudinary, Filesystem
 
 **For documentation and examples, please visit https://docs.bknd.io.**
 
 > [!WARNING]
+> This project requires Node.js 22.13 or higher (because of `node:sqlite`).
+>
 > Please keep in mind that **bknd** is still under active development
 > and therefore full backward compatibility is not guaranteed before reaching v1.0.0.
 
 ## Size
-![gzipped size of bknd](https://img.badgesize.io/https://unpkg.com/bknd@latest/dist/index.js?compression=gzip&label=bknd)
+![gzipped size of bknd](https://img.shields.io/bundlejs/size/bknd?label=bknd)
 ![gzipped size of bknd/client](https://img.badgesize.io/https://unpkg.com/bknd@latest/dist/ui/client/index.js?compression=gzip&label=bknd/client)
-![gzipped size of bknd/elements](https://img.badgesize.io/https://unpkg.com/bknd@latest/dist/ui/elements/index.js?compression=gzip&label=bknd/elements)
-![gzipped size of bknd/ui](https://img.badgesize.io/https://unpkg.com/bknd@latest/dist/ui/index.js?compression=gzip&label=bknd/ui)
+![gzipped size of bknd/elements](https://img.badgesize.io/https://unpkg.com/bknd@latest/dist/ui/elements/index.js?compression=gzip&label=bknd/elements&t=1)
+![gzipped size of bknd/ui](https://img.badgesize.io/https://unpkg.com/bknd@latest/dist/ui/index.js?compression=gzip&label=bknd/ui&t=1)
 
 The size on npm is misleading, as the `bknd` package includes the backend, the ui components as well as the whole backend bundled into the cli including static assets. 
 
-Depending on what you use, the size can be higher as additional dependencies are getting pulled in. The minimal size of a full `bknd` app as an API is around 212 kB gzipped (e.g. deployed as Cloudflare Worker).
+Depending on what you use, the size can be higher as additional dependencies are getting pulled in. The minimal size of a full `bknd` app as an API is around 300 kB gzipped (e.g. deployed as Cloudflare Worker).
 
 ## Motivation
 Creating digital products always requires developing both the backend (the logic) and the frontend (the appearance). Building a backend from scratch demands deep knowledge in areas such as authentication and database management. Using a backend framework can speed up initial development, but it still requires ongoing effort to work within its constraints (e.g., *"how to do X with Y?"*), which can quickly slow you down. Choosing a backend system is a tough decision, as you might not be aware of its limitations until you encounter them.
@@ -45,6 +52,7 @@ Creating digital products always requires developing both the backend (the logic
   * using a React framework (Next.js, React Router, Astro)
 * 📦 Official API and React SDK with type-safety
 * ⚛️ React elements for auto-configured authentication and media components
+* 🛠️ MCP server, client and UI built-in to control your backend
 
 ## Structure
 The package is mainly split into 4 parts, each serving a specific purpose:

app/.env.example

@@ -0,0 +1,42 @@
+# ===== DB Settings =====
+VITE_DB_URL=:memory:
+# you can set a location for a database here, it'll overwrite the previous setting
+# ideally use the ".db" folder (create it first), it's git ignored
+VITE_DB_URL=file:.db/dev.db
+
+# alternatively, you can use url/token combination
+#VITE_DB_URL=
+#VITE_DB_TOKEN=
+
+
+# ===== DEV Server =====
+# restart the dev server on every change (enable with "1")
+VITE_APP_FRESH=
+# displays react-scan widget (enable with "1")
+VITE_DEBUG_RERENDERS=
+# console logs registered routes on start (enable with "1")
+VITE_SHOW_ROUTES=
+
+
+# ===== Test Credentials =====
+RESEND_API_KEY=
+R2_TOKEN=
+
+R2_ACCESS_KEY=
+R2_SECRET_ACCESS_KEY=
+R2_URL=
+
+AWS_ACCESS_KEY=
+AWS_SECRET_KEY=
+AWS_S3_URL=
+
+OAUTH_CLIENT_ID=
+OAUTH_CLIENT_SECRET=
+
+PUBLIC_POSTHOG_KEY=
+PUBLIC_POSTHOG_HOST=
+
+# ===== Internals =====
+BKND_CLI_CREATE_REF=main
+BKND_CLI_LOG_LEVEL=debug
+BKND_MODULES_DEBUG=1

app/.gitignore

@@ -0,0 +1,4 @@
+playwright-report
+test-results
+bknd.config.*
+__test__/helper.d.ts

app/__test__/App.spec.ts

@@ -1,27 +1,148 @@
-import { afterAll, afterEach, describe, expect, test } from "bun:test";
-import { App } from "../src";
+import { afterEach, describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { App, createApp } from "core/test/utils";
 import { getDummyConnection } from "./helper";
+import { Hono } from "hono";
+import * as proto from "../src/data/prototype";
+import { pick } from "lodash-es";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
-afterEach(afterAllCleanup);
+afterEach(async () => (await afterAllCleanup()) && enableConsoleLog());
 
 describe("App tests", async () => {
    test("boots and pongs", async () => {
       const app = new App(dummyConnection);
       await app.build();
 
-      //expect(await app.data?.em.ping()).toBeTrue();
+      expect(await app.em.ping()).toBeTrue();
    });
 
-   /*test.only("what", async () => {
-      const app = new App(dummyConnection, {
-         auth: {
-            enabled: true,
+   test("plugins", async () => {
+      const called: string[] = [];
+      const app = createApp({
+         config: {
+            auth: {
+               enabled: true,
+            },
+         },
+         options: {
+            plugins: [
+               (app) => {
+                  expect(app).toBeDefined();
+                  expect(app).toBeInstanceOf(App);
+                  return {
+                     name: "test",
+                     schema: () => {
+                        called.push("schema");
+                        return proto.em(
+                           {
+                              posts: proto.entity("posts", {
+                                 title: proto.text(),
+                              }),
+                              comments: proto.entity("comments", {
+                                 content: proto.text(),
+                              }),
+                              users: proto.entity("users", {
+                                 email_verified: proto.boolean(),
+                              }),
+                           },
+                           (fn, s) => {
+                              fn.relation(s.comments).manyToOne(s.posts);
+                              fn.index(s.posts).on(["title"]);
+                           },
+                        );
+                     },
+                     onBoot: async () => {
+                        called.push("onBoot");
+                     },
+                     beforeBuild: async () => {
+                        called.push("beforeBuild");
+                     },
+                     onBuilt: async () => {
+                        called.push("onBuilt");
+                     },
+                     onServerInit: async (server) => {
+                        called.push("onServerInit");
+                        expect(server).toBeDefined();
+                        expect(server).toBeInstanceOf(Hono);
+                     },
+                     onFirstBoot: async () => {
+                        called.push("onFirstBoot");
+                     },
+                  };
+               },
+            ],
          },
       });
-      await app.module.auth.build();
-      await app.module.data.build();
-      console.log(app.em.entities.map((e) => e.name));
-      console.log(await app.em.schema().getDiff());
-   });*/
+
+      await app.build();
+
+      expect(app.em.entities.map((e) => e.name)).toEqual(["users", "posts", "comments"]);
+      expect(app.em.indices.map((i) => i.name)).toEqual([
+         "idx_unique_users_email",
+         "idx_users_strategy",
+         "idx_users_strategy_value",
+         "idx_posts_title",
+      ]);
+      expect(
+         app.em.relations.all.map((r) => pick(r.toJSON(), ["type", "source", "target"])),
+      ).toEqual([
+         {
+            type: "n:1",
+            source: "comments",
+            target: "posts",
+         },
+      ]);
+      expect(called).toEqual([
+         "onBoot",
+         "onServerInit",
+         "beforeBuild",
+         "onServerInit",
+         "schema",
+         "onFirstBoot",
+         "onBuilt",
+      ]);
+      expect(app.plugins.size).toBe(1);
+      expect(Array.from(app.plugins.keys())).toEqual(["test"]);
+   });
+
+   test.only("drivers", async () => {
+      const called: string[] = [];
+      const app = new App(dummyConnection, undefined, {
+         drivers: {
+            email: {
+               send: async (to, subject, body) => {
+                  called.push("email.send");
+                  return {
+                     id: "",
+                  };
+               },
+            },
+            cache: {
+               get: async (key) => {
+                  called.push("cache.get");
+                  return "";
+               },
+               set: async (key, value, ttl) => {
+                  called.push("cache.set");
+               },
+               del: async (key) => {
+                  called.push("cache.del");
+               },
+            },
+         },
+      });
+      await app.build();
+
+      expect(app.drivers.cache).toBeDefined();
+      expect(app.drivers.email).toBeDefined();
+      await app.drivers.email.send("", "", "");
+      await app.drivers.cache.get("");
+      await app.drivers.cache.set("", "", 0);
+      await app.drivers.cache.del("");
+
+      expect(called).toEqual(["email.send", "cache.get", "cache.set", "cache.del"]);
+   });
 });

app/__test__/_assets/.gitignore

@@ -1 +1,2 @@
-tmp/*
+tmp/*
+!tmp/.gitkeep

app/__test__/_assets/test.txt

@@ -0,0 +1 @@
+hello

app/__test__/adapter/adapter.test.ts

@@ -0,0 +1,66 @@
+import { expect, describe, it, beforeAll, afterAll, mock } from "bun:test";
+import * as adapter from "adapter";
+import { disableConsoleLog, enableConsoleLog } from "core/utils";
+import { adapterTestSuite } from "adapter/adapter-test-suite";
+import { bunTestRunner } from "adapter/bun/test";
+import { omitKeys } from "core/utils";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
+
+describe("adapter", () => {
+   it("makes config", async () => {
+      expect(omitKeys(await adapter.makeConfig({}), ["connection"])).toEqual({});
+      expect(
+         omitKeys(await adapter.makeConfig({}, { env: { TEST: "test" } }), ["connection"]),
+      ).toEqual({});
+
+      // merges everything returned from `app` with the config
+      expect(
+         omitKeys(
+            await adapter.makeConfig(
+               { app: (a) => ({ config: { server: { cors: { origin: a.env.TEST } } } }) },
+               { env: { TEST: "test" } },
+            ),
+            ["connection"],
+         ),
+      ).toEqual({
+         config: { server: { cors: { origin: "test" } } },
+      });
+   });
+
+   it("allows all properties in app function", async () => {
+      const called = mock(() => null);
+      const config = await adapter.makeConfig(
+         {
+            app: (env) => ({
+               connection: { url: "test" },
+               config: { server: { cors: { origin: "test" } } },
+               options: {
+                  mode: "db",
+               },
+               onBuilt: () => {
+                  called();
+                  expect(env).toEqual({ foo: "bar" });
+               },
+            }),
+         },
+         { foo: "bar" },
+      );
+      expect(config.connection).toEqual({ url: "test" });
+      expect(config.config).toEqual({ server: { cors: { origin: "test" } } });
+      expect(config.options).toEqual({ mode: "db" });
+      await config.onBuilt?.(null as any);
+      expect(called).toHaveBeenCalled();
+   });
+
+   adapterTestSuite(bunTestRunner, {
+      makeApp: adapter.createFrameworkApp,
+      label: "framework app",
+   });
+
+   adapterTestSuite(bunTestRunner, {
+      makeApp: adapter.createRuntimeApp,
+      label: "runtime app",
+   });
+});

app/__test__/api/Api.spec.ts

@@ -42,7 +42,6 @@ describe("Api", async () => {
       expect(api.isAuthVerified()).toBe(false);
 
       const params = api.getParams();
-      console.log(params);
       expect(params.token).toBe(token);
       expect(params.token_transport).toBe("cookie");
       expect(params.host).toBe("http://example.com");

app/__test__/api/DataApi.spec.ts

@@ -1,11 +1,12 @@
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { Guard } from "../../src/auth";
-import { parse } from "../../src/core/utils";
+import { Guard } from "../../src/auth/authorize/Guard";
 import { DataApi } from "../../src/data/api/DataApi";
 import { DataController } from "../../src/data/api/DataController";
 import { dataConfigSchema } from "../../src/data/data-schema";
 import * as proto from "../../src/data/prototype";
-import { disableConsoleLog, enableConsoleLog, schemaToEm } from "../helper";
+import { schemaToEm } from "../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+import { parse } from "core/utils/schema";
 
 beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
@@ -64,6 +65,15 @@ describe("DataApi", () => {
          const res = await req;
          expect(res.data).toEqual(payload as any);
       }
+
+      {
+         // make sure sort is working
+         const req = await api.readMany("posts", {
+            select: ["title"],
+            sort: "-id",
+         });
+         expect(req.data).toEqual(payload.reverse() as any);
+      }
    });
 
    it("updates many", async () => {
@@ -143,7 +153,7 @@ describe("DataApi", () => {
       const oneBy = api.readOneBy("posts", { where: { title: "baz" }, select: ["title"] });
       const oneByRes = await oneBy;
       expect(oneByRes.data).toEqual({ title: "baz" } as any);
-      expect(oneByRes.body.meta.count).toEqual(1);
+      expect(oneByRes.body.meta.items).toEqual(1);
    });
 
    it("exists/count", async () => {
@@ -192,7 +202,7 @@ describe("DataApi", () => {
       {
          // create many
          const res = await api.createMany("posts", payload);
-         expect(res.data.length).toEqual(4);
+         expect(res.data?.length).toEqual(4);
          expect(res.ok).toBeTrue();
       }
 

app/__test__/api/MediaApi.spec.ts

@@ -1,8 +1,8 @@
 /// <reference types="@types/bun" />
 import { describe, expect, it } from "bun:test";
 import { Hono } from "hono";
-import { getFileFromContext, isFile, isReadableStream } from "../../src/core/utils";
-import { MediaApi } from "../../src/media/api/MediaApi";
+import { getFileFromContext, isFile, isReadableStream } from "core/utils";
+import { MediaApi } from "media/api/MediaApi";
 import { assetsPath, assetsTmpPath } from "../helper";
 
 const mockedBackend = new Hono()
@@ -39,10 +39,28 @@ describe("MediaApi", () => {
       // @ts-ignore tests
       const api = new MediaApi({
          token: "token",
+         token_transport: "header",
       });
       expect(api.getUploadHeaders().get("Authorization")).toBe("Bearer token");
    });
 
+   it("should return empty headers if not using `header` transport", () => {
+      expect(
+         new MediaApi({
+            token_transport: "cookie",
+         })
+            .getUploadHeaders()
+            .has("Authorization"),
+      ).toBe(false);
+      expect(
+         new MediaApi({
+            token_transport: "none",
+         })
+            .getUploadHeaders()
+            .has("Authorization"),
+      ).toBe(false);
+   });
+
    it("should get file: native", async () => {
       const name = "image.png";
       const path = `${assetsTmpPath}/${name}`;
@@ -103,8 +121,12 @@ describe("MediaApi", () => {
    });
 
    it("should upload file in various ways", async () => {
-      // @ts-ignore tests
-      const api = new MediaApi({}, mockedBackend.request);
+      const api = new MediaApi(
+         {
+            upload_fetcher: mockedBackend.request,
+         },
+         mockedBackend.request,
+      );
       const file = Bun.file(`${assetsPath}/image.png`);
 
       async function matches(req: Promise<any>, filename: string) {

app/__test__/app/App.spec.ts

@@ -1,9 +1,23 @@
-import { describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
 import type { ModuleBuildContext } from "../../src";
-import { type App, createApp } from "../../src/App";
-import * as proto from "../../src/data/prototype";
+import { App, createApp } from "core/test/utils";
+import * as proto from "data/prototype";
+import { DbModuleManager } from "modules/db/DbModuleManager";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
 
 describe("App", () => {
+   test("use db mode by default", async () => {
+      const app = createApp();
+      await app.build();
+
+      expect(app.mode).toBe("db");
+      expect(app.isReadOnly()).toBe(false);
+      expect(app.modules instanceof DbModuleManager).toBe(true);
+   });
+
    test("seed includes ctx and app", async () => {
       const called = mock(() => null);
       await createApp({
@@ -20,6 +34,8 @@ describe("App", () => {
                   "guard",
                   "flags",
                   "logger",
+                  "mcp",
+                  "helper",
                ]);
             },
          },
@@ -27,7 +43,7 @@ describe("App", () => {
       expect(called).toHaveBeenCalled();
 
       const app = createApp({
-         initialConfig: {
+         config: {
             data: proto
                .em({
                   todos: proto.entity("todos", {
@@ -51,4 +67,104 @@ describe("App", () => {
       expect(todos[0]?.title).toBe("ctx");
       expect(todos[1]?.title).toBe("api");
    });
+
+   test("lifecycle events are triggered", async () => {
+      const firstBoot = mock(() => null);
+      const configUpdate = mock(() => null);
+      const appBuilt = mock(() => null);
+      const appRequest = mock(() => null);
+      const beforeResponse = mock(() => null);
+
+      const app = createApp();
+
+      app.emgr.onEvent(
+         App.Events.AppFirstBoot,
+         (event) => {
+            expect(event).toBeInstanceOf(App.Events.AppFirstBoot);
+            expect(event.params.app.version()).toBe(app.version());
+            firstBoot();
+         },
+         "sync",
+      );
+      app.emgr.onEvent(
+         App.Events.AppBuiltEvent,
+         (event) => {
+            expect(event).toBeInstanceOf(App.Events.AppBuiltEvent);
+            expect(event.params.app.version()).toBe(app.version());
+            appBuilt();
+         },
+         "sync",
+      );
+      app.emgr.onEvent(
+         App.Events.AppConfigUpdatedEvent,
+         () => {
+            configUpdate();
+         },
+         "sync",
+      );
+      app.emgr.onEvent(
+         App.Events.AppRequest,
+         (event) => {
+            expect(event).toBeInstanceOf(App.Events.AppRequest);
+            expect(event.params.app.version()).toBe(app.version());
+            expect(event.params.request).toBeInstanceOf(Request);
+            appRequest();
+         },
+         "sync",
+      );
+      app.emgr.onEvent(
+         App.Events.AppBeforeResponse,
+         (event) => {
+            expect(event).toBeInstanceOf(App.Events.AppBeforeResponse);
+            expect(event.params.app.version()).toBe(app.version());
+            expect(event.params.response).toBeInstanceOf(Response);
+            beforeResponse();
+         },
+         "sync",
+      );
+
+      await app.build();
+      expect(firstBoot).toHaveBeenCalled();
+      expect(appBuilt).toHaveBeenCalled();
+      //expect(configUpdate).toHaveBeenCalled();
+      expect(appRequest).not.toHaveBeenCalled();
+      expect(beforeResponse).not.toHaveBeenCalled();
+   });
+
+   test("emgr exec modes", async () => {
+      const called = mock(() => null);
+      const app = createApp({
+         options: {
+            asyncEventsMode: "sync",
+         },
+      });
+
+      // register async listener
+      app.emgr.onEvent(App.Events.AppFirstBoot, async () => {
+         called();
+      });
+
+      await app.build();
+      await app.server.request(new Request("http://localhost"));
+
+      // expect async listeners to be executed sync after request
+      expect(called).toHaveBeenCalled();
+   });
+
+   test("getMcpClient", async () => {
+      const app = createApp({
+         config: {
+            server: {
+               mcp: {
+                  enabled: true,
+               },
+            },
+         },
+      });
+      await app.build();
+      const client = app.getMcpClient();
+      const res = await client.listTools();
+      expect(res).toBeDefined();
+      expect(res?.tools.length).toBeGreaterThan(0);
+   });
 });

app/__test__/app/AppServer.spec.ts

@@ -0,0 +1,47 @@
+import { AppServer, serverConfigSchema } from "modules/server/AppServer";
+import { describe, test, expect } from "bun:test";
+
+describe("AppServer", () => {
+   test("config", () => {
+      {
+         const server = new AppServer();
+         expect(server).toBeDefined();
+         expect(server.config).toEqual({
+            cors: {
+               allow_credentials: true,
+               origin: "*",
+               allow_methods: ["GET", "POST", "PATCH", "PUT", "DELETE"],
+               allow_headers: ["Content-Type", "Content-Length", "Authorization", "Accept"],
+            },
+            mcp: {
+               enabled: false,
+               path: "/api/system/mcp",
+               logLevel: "warning",
+            },
+         });
+      }
+
+      {
+         const server = new AppServer({
+            cors: {
+               origin: "https",
+               allow_methods: ["GET", "POST"],
+            },
+         });
+         expect(server).toBeDefined();
+         expect(server.config).toEqual({
+            cors: {
+               allow_credentials: true,
+               origin: "https",
+               allow_methods: ["GET", "POST"],
+               allow_headers: ["Content-Type", "Content-Length", "Authorization", "Accept"],
+            },
+            mcp: {
+               enabled: false,
+               path: "/api/system/mcp",
+               logLevel: "warning",
+            },
+         });
+      }
+   });
+});

app/__test__/app/code-only.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, mock, test } from "bun:test";
+import { createApp as internalCreateApp, type CreateAppConfig } from "bknd";
+import { getDummyConnection } from "../../__test__/helper";
+import { ModuleManager } from "modules/ModuleManager";
+import { em, entity, text } from "data/prototype";
+
+async function createApp(config: CreateAppConfig = {}) {
+   const app = internalCreateApp({
+      connection: getDummyConnection().dummyConnection,
+      ...config,
+      options: {
+         ...config.options,
+         mode: "code",
+      },
+   });
+   await app.build();
+   return app;
+}
+
+describe("code-only", () => {
+   test("should create app with correct manager", async () => {
+      const app = await createApp();
+      await app.build();
+
+      expect(app.version()).toBeDefined();
+      expect(app.modules).toBeInstanceOf(ModuleManager);
+   });
+
+   test("should not perform database syncs", async () => {
+      const app = await createApp({
+         config: {
+            data: em({
+               test: entity("test", {
+                  name: text(),
+               }),
+            }).toJSON(),
+         },
+      });
+      expect(app.em.entities.map((e) => e.name)).toEqual(["test"]);
+      expect(
+         await app.em.connection.kysely
+            .selectFrom("sqlite_master")
+            .where("type", "=", "table")
+            .selectAll()
+            .execute(),
+      ).toEqual([]);
+
+      // only perform when explicitly forced
+      await app.em.schema().sync({ force: true });
+      expect(
+         await app.em.connection.kysely
+            .selectFrom("sqlite_master")
+            .where("type", "=", "table")
+            .selectAll()
+            .execute()
+            .then((r) => r.map((r) => r.name)),
+      ).toEqual(["test", "sqlite_sequence"]);
+   });
+
+   test("should not perform seeding", async () => {
+      const called = mock(() => null);
+      const app = await createApp({
+         config: {
+            data: em({
+               test: entity("test", {
+                  name: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            seed: async (ctx) => {
+               called();
+               await ctx.em.mutator("test").insertOne({ name: "test" });
+            },
+         },
+      });
+      await app.em.schema().sync({ force: true });
+      expect(called).not.toHaveBeenCalled();
+      expect(
+         await app.em
+            .repo("test")
+            .findMany({})
+            .then((r) => r.data),
+      ).toEqual([]);
+   });
+
+   test("should sync and perform seeding", async () => {
+      const called = mock(() => null);
+      const app = await createApp({
+         config: {
+            data: em({
+               test: entity("test", {
+                  name: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            seed: async (ctx) => {
+               called();
+               await ctx.em.mutator("test").insertOne({ name: "test" });
+            },
+         },
+      });
+
+      await app.em.schema().sync({ force: true });
+      await app.options?.seed?.({
+         ...app.modules.ctx(),
+         app: app,
+      });
+      expect(called).toHaveBeenCalled();
+      expect(
+         await app.em
+            .repo("test")
+            .findMany({})
+            .then((r) => r.data),
+      ).toEqual([{ id: 1, name: "test" }]);
+   });
+
+   test("should not allow to modify config", async () => {
+      const app = await createApp();
+      // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+      expect(app.modules.hasOwnProperty("mutateConfigSafe")).toBe(false);
+      expect(() => {
+         app.modules.configs().auth.enabled = true;
+      }).toThrow();
+   });
+});

app/__test__/app/mcp/mcp.auth.test.ts

@@ -0,0 +1,227 @@
+import { describe, test, expect, beforeEach, beforeAll, afterAll } from "bun:test";
+import { type App, createApp, createMcpToolCaller } from "core/test/utils";
+import { disableConsoleLog, enableConsoleLog } from "core/utils";
+import type { McpServer } from "bknd/utils";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
+
+/**
+ * - [x] auth_me
+ * - [x] auth_strategies
+ * - [x] auth_user_create
+ * - [x] auth_user_token
+ * - [x] auth_user_password_change
+ * - [x] auth_user_password_test
+ * - [x] config_auth_get
+ * - [x] config_auth_update
+ * - [x] config_auth_strategies_get
+ * - [x] config_auth_strategies_add
+ * - [x] config_auth_strategies_update
+ * - [x] config_auth_strategies_remove
+ * - [x] config_auth_roles_get
+ * - [x] config_auth_roles_add
+ * - [x] config_auth_roles_update
+ * - [x] config_auth_roles_remove
+ */
+describe("mcp auth", async () => {
+   let app: App;
+   let server: McpServer;
+   beforeEach(async () => {
+      app = createApp({
+         config: {
+            auth: {
+               enabled: true,
+               jwt: {
+                  secret: "secret",
+               },
+            },
+            server: {
+               mcp: {
+                  enabled: true,
+               },
+            },
+         },
+      });
+      await app.build();
+      await app.getMcpClient().ping();
+      server = app.mcp!;
+      server.setLogLevel("error");
+      server.onNotification((message) => {
+         console.dir(message, { depth: null });
+      });
+   });
+
+   const tool = createMcpToolCaller();
+
+   test("auth_*", async () => {
+      const me = await tool(server, "auth_me", {});
+      expect(me.user).toBeNull();
+
+      // strategies
+      const strategies = await tool(server, "auth_strategies", {});
+      expect(Object.keys(strategies.strategies).length).toEqual(1);
+      expect(strategies.strategies.password.enabled).toBe(true);
+
+      // create user
+      const user = await tool(
+         server,
+         "auth_user_create",
+         {
+            email: "test@test.com",
+            password: "12345678",
+         },
+         new Headers(),
+      );
+      expect(user.email).toBe("test@test.com");
+
+      // create token
+      const token = await tool(
+         server,
+         "auth_user_token",
+         {
+            email: "test@test.com",
+         },
+         new Headers(),
+      );
+      expect(token.token).toBeDefined();
+      expect(token.user.email).toBe("test@test.com");
+
+      // me
+      const me2 = await tool(
+         server,
+         "auth_me",
+         {},
+         new Request("http://localhost", {
+            headers: new Headers({
+               Authorization: `Bearer ${token.token}`,
+            }),
+         }),
+      );
+      expect(me2.user.email).toBe("test@test.com");
+
+      // change password
+      const changePassword = await tool(
+         server,
+         "auth_user_password_change",
+         {
+            email: "test@test.com",
+            password: "87654321",
+         },
+         new Headers(),
+      );
+      expect(changePassword.changed).toBe(true);
+
+      // test password
+      const testPassword = await tool(
+         server,
+         "auth_user_password_test",
+         {
+            email: "test@test.com",
+            password: "87654321",
+         },
+         new Headers(),
+      );
+      expect(testPassword.valid).toBe(true);
+   });
+
+   test("config_auth_{get,update}", async () => {
+      expect(await tool(server, "config_auth_get", {})).toEqual({
+         path: "",
+         secrets: false,
+         partial: false,
+         value: app.toJSON().auth,
+      });
+
+      // update
+      await tool(server, "config_auth_update", {
+         value: {
+            allow_register: false,
+         },
+      });
+      expect(app.toJSON().auth.allow_register).toBe(false);
+   });
+
+   test("config_auth_strategies_{get,add,update,remove}", async () => {
+      const strategies = await tool(server, "config_auth_strategies_get", {
+         key: "password",
+      });
+      expect(strategies).toEqual({
+         secrets: false,
+         module: "auth",
+         key: "password",
+         value: {
+            enabled: true,
+            type: "password",
+         },
+      });
+
+      // add google oauth
+      const addGoogleOauth = await tool(server, "config_auth_strategies_add", {
+         key: "google",
+         value: {
+            type: "oauth",
+            enabled: true,
+            config: {
+               name: "google",
+               type: "oidc",
+               client: {
+                  client_id: "client_id",
+                  client_secret: "client_secret",
+               },
+            },
+         },
+         return_config: true,
+      });
+      expect(addGoogleOauth.config.google.enabled).toBe(true);
+      expect(app.toJSON().auth.strategies.google?.enabled).toBe(true);
+
+      // update (disable) google oauth
+      await tool(server, "config_auth_strategies_update", {
+         key: "google",
+         value: {
+            enabled: false,
+         },
+      });
+      expect(app.toJSON().auth.strategies.google?.enabled).toBe(false);
+
+      // remove google oauth
+      await tool(server, "config_auth_strategies_remove", {
+         key: "google",
+      });
+      expect(app.toJSON().auth.strategies.google).toBeUndefined();
+   });
+
+   test("config_auth_roles_{get,add,update,remove}", async () => {
+      // add role
+      const addGuestRole = await tool(server, "config_auth_roles_add", {
+         key: "guest",
+         value: {
+            permissions: ["read", "write"],
+         },
+         return_config: true,
+      });
+      expect(addGuestRole.config.guest.permissions).toEqual(["read", "write"]);
+
+      // update role
+      await tool(server, "config_auth_roles_update", {
+         key: "guest",
+         value: {
+            permissions: ["read"],
+         },
+      });
+      expect(app.toJSON().auth.roles?.guest?.permissions).toEqual(["read"]);
+
+      // get role
+      const getGuestRole = await tool(server, "config_auth_roles_get", {
+         key: "guest",
+      });
+      expect(getGuestRole.value.permissions).toEqual(["read"]);
+
+      // remove role
+      await tool(server, "config_auth_roles_remove", {
+         key: "guest",
+      });
+      expect(app.toJSON().auth.roles?.guest).toBeUndefined();
+   });
+});

app/__test__/app/mcp/mcp.base.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { createApp } from "core/test/utils";
+import { registries } from "index";
+import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
+
+describe("mcp", () => {
+   it("should have tools", async () => {
+      registries.media.register("local", StorageLocalAdapter);
+
+      const app = createApp({
+         config: {
+            auth: {
+               enabled: true,
+            },
+            media: {
+               enabled: true,
+               adapter: {
+                  type: "local",
+                  config: {
+                     path: "./",
+                  },
+               },
+            },
+            server: {
+               mcp: {
+                  enabled: true,
+               },
+            },
+         },
+      });
+      await app.build();
+
+      // expect mcp to not be loaded yet
+      expect(app.mcp).toBeNull();
+
+      // after first request, mcp should be loaded
+      await app.getMcpClient().listTools();
+      expect(app.mcp?.tools.length).toBeGreaterThan(0);
+   });
+});

app/__test__/app/mcp/mcp.data.test.ts

@@ -0,0 +1,347 @@
+import { describe, test, expect, beforeEach, beforeAll, afterAll } from "bun:test";
+import { type App, createApp, createMcpToolCaller } from "core/test/utils";
+import { getSystemMcp } from "modules/mcp/system-mcp";
+import { pickKeys, type McpServer } from "bknd/utils";
+import { entity, text } from "bknd";
+import { disableConsoleLog, enableConsoleLog } from "core/utils";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
+
+/**
+ * - [ ] data_sync
+ * - [x] data_entity_fn_count
+ * - [x] data_entity_fn_exists
+ * - [x] data_entity_read_one
+ * - [x] data_entity_read_many
+ * - [x] data_entity_insert
+ * - [x] data_entity_update_many
+ * - [x] data_entity_update_one
+ * - [x] data_entity_delete_one
+ * - [x] data_entity_delete_many
+ * - [x] data_entity_info
+ * - [ ] config_data_get
+ * - [ ] config_data_update
+ * - [x] config_data_entities_get
+ * - [x] config_data_entities_add
+ * - [x] config_data_entities_update
+ * - [x] config_data_entities_remove
+ * - [x] config_data_relations_add
+ * - [x] config_data_relations_get
+ * - [x] config_data_relations_update
+ * - [x] config_data_relations_remove
+ * - [x] config_data_indices_get
+ * - [x] config_data_indices_add
+ * - [x] config_data_indices_update
+ * - [x] config_data_indices_remove
+ */
+describe("mcp data", async () => {
+   let app: App;
+   let server: McpServer;
+   beforeEach(async () => {
+      const time = performance.now();
+      app = createApp({
+         config: {
+            server: {
+               mcp: {
+                  enabled: true,
+               },
+            },
+         },
+      });
+      await app.build();
+      await app.getMcpClient().ping();
+      server = app.mcp!;
+      server.setLogLevel("error");
+      server.onNotification((message) => {
+         console.dir(message, { depth: null });
+      });
+   });
+
+   const tool = createMcpToolCaller();
+
+   test("config_data_entities_{add,get,update,remove}", async () => {
+      const result = await tool(server, "config_data_entities_add", {
+         key: "test",
+         return_config: true,
+         value: {},
+      });
+      expect(result.success).toBe(true);
+      expect(result.module).toBe("data");
+      expect(result.config.test?.type).toEqual("regular");
+
+      const entities = Object.keys(app.toJSON().data.entities ?? {});
+      expect(entities).toContain("test");
+
+      {
+         // get
+         const result = await tool(server, "config_data_entities_get", {
+            key: "test",
+         });
+         expect(result.module).toBe("data");
+         expect(result.key).toBe("test");
+         expect(result.value.type).toEqual("regular");
+      }
+
+      {
+         // update
+         const result = await tool(server, "config_data_entities_update", {
+            key: "test",
+            return_config: true,
+            value: {
+               config: {
+                  name: "Test",
+               },
+            },
+         });
+         expect(result.success).toBe(true);
+         expect(result.module).toBe("data");
+         expect(result.config.test.config?.name).toEqual("Test");
+         expect(app.toJSON().data.entities?.test?.config?.name).toEqual("Test");
+      }
+
+      {
+         // remove
+         const result = await tool(server, "config_data_entities_remove", {
+            key: "test",
+         });
+         expect(result.success).toBe(true);
+         expect(result.module).toBe("data");
+         expect(app.toJSON().data.entities?.test).toBeUndefined();
+      }
+   });
+
+   test("config_data_relations_{add,get,update,remove}", async () => {
+      // create posts and comments
+      await tool(server, "config_data_entities_add", {
+         key: "posts",
+         value: {},
+      });
+      await tool(server, "config_data_entities_add", {
+         key: "comments",
+         value: {},
+      });
+
+      expect(Object.keys(app.toJSON().data.entities ?? {})).toEqual(["posts", "comments"]);
+
+      // create relation
+      await tool(server, "config_data_relations_add", {
+         key: "", // doesn't matter
+         value: {
+            type: "n:1",
+            source: "comments",
+            target: "posts",
+         },
+      });
+
+      const config = app.toJSON().data;
+      expect(
+         pickKeys((config.relations?.n1_comments_posts as any) ?? {}, ["type", "source", "target"]),
+      ).toEqual({
+         type: "n:1",
+         source: "comments",
+         target: "posts",
+      });
+
+      expect(config.entities?.comments?.fields?.posts_id?.type).toBe("relation");
+
+      {
+         // info
+         const postsInfo = await tool(server, "data_entity_info", {
+            entity: "posts",
+         });
+         expect(postsInfo.fields).toEqual(["id"]);
+         expect(postsInfo.relations.all.length).toBe(1);
+
+         const commentsInfo = await tool(server, "data_entity_info", {
+            entity: "comments",
+         });
+         expect(commentsInfo.fields).toEqual(["id", "posts_id"]);
+         expect(commentsInfo.relations.all.length).toBe(1);
+      }
+
+      // update
+      await tool(server, "config_data_relations_update", {
+         key: "n1_comments_posts",
+         value: {
+            config: {
+               with_limit: 10,
+            },
+         },
+      });
+      expect((app.toJSON().data.relations?.n1_comments_posts?.config as any)?.with_limit).toBe(10);
+
+      // delete
+      await tool(server, "config_data_relations_remove", {
+         key: "n1_comments_posts",
+      });
+      expect(app.toJSON().data.relations?.n1_comments_posts).toBeUndefined();
+   });
+
+   test("config_data_indices_update", async () => {
+      expect(server.tools.map((t) => t.name).includes("config_data_indices_update")).toBe(false);
+   });
+
+   test("config_data_indices_{add,get,remove}", async () => {
+      // create posts and comments
+      await tool(server, "config_data_entities_add", {
+         key: "posts",
+         value: entity("posts", {
+            title: text(),
+            content: text(),
+         }).toJSON(),
+      });
+
+      // add index on title
+      await tool(server, "config_data_indices_add", {
+         key: "", // auto generated
+         value: {
+            entity: "posts",
+            fields: ["title"],
+         },
+      });
+
+      expect(app.toJSON().data.indices?.idx_posts_title).toEqual({
+         entity: "posts",
+         fields: ["title"],
+         unique: false,
+      });
+
+      // delete
+      await tool(server, "config_data_indices_remove", {
+         key: "idx_posts_title",
+      });
+      expect(app.toJSON().data.indices?.idx_posts_title).toBeUndefined();
+   });
+
+   test("data_entity_*", async () => {
+      // create posts and comments
+      await tool(server, "config_data_entities_add", {
+         key: "posts",
+         value: entity("posts", {
+            title: text(),
+            content: text(),
+         }).toJSON(),
+      });
+      await tool(server, "config_data_entities_add", {
+         key: "comments",
+         value: entity("comments", {
+            content: text(),
+         }).toJSON(),
+      });
+
+      // insert a few posts
+      for (let i = 0; i < 10; i++) {
+         await tool(server, "data_entity_insert", {
+            entity: "posts",
+            json: {
+               title: `Post ${i}`,
+            },
+         });
+      }
+      // insert a few comments
+      for (let i = 0; i < 5; i++) {
+         await tool(server, "data_entity_insert", {
+            entity: "comments",
+            json: {
+               content: `Comment ${i}`,
+            },
+         });
+      }
+
+      const result = await tool(server, "data_entity_read_many", {
+         entity: "posts",
+         limit: 5,
+      });
+      expect(result.data.length).toBe(5);
+      expect(result.meta.items).toBe(5);
+      expect(result.meta.total).toBe(10);
+      expect(result.data[0].title).toBe("Post 0");
+
+      {
+         // count
+         const result = await tool(server, "data_entity_fn_count", {
+            entity: "posts",
+         });
+         expect(result.count).toBe(10);
+      }
+
+      {
+         // exists
+         const res = await tool(server, "data_entity_fn_exists", {
+            entity: "posts",
+            json: {
+               id: result.data[0].id,
+            },
+         });
+         expect(res.exists).toBe(true);
+
+         const res2 = await tool(server, "data_entity_fn_exists", {
+            entity: "posts",
+            json: {
+               id: "123",
+            },
+         });
+         expect(res2.exists).toBe(false);
+      }
+
+      // update
+      await tool(server, "data_entity_update_one", {
+         entity: "posts",
+         id: result.data[0].id,
+         json: {
+            title: "Post 0 updated",
+         },
+      });
+      const result2 = await tool(server, "data_entity_read_one", {
+         entity: "posts",
+         id: result.data[0].id,
+      });
+      expect(result2.data.title).toBe("Post 0 updated");
+
+      // delete the second post
+      await tool(server, "data_entity_delete_one", {
+         entity: "posts",
+         id: result.data[1].id,
+      });
+      const result3 = await tool(server, "data_entity_read_many", {
+         entity: "posts",
+         limit: 2,
+      });
+      expect(result3.data.map((p) => p.id)).toEqual([1, 3]);
+
+      // update many
+      await tool(server, "data_entity_update_many", {
+         entity: "posts",
+         update: {
+            title: "Post updated",
+         },
+         where: {
+            title: { $isnull: 0 },
+         },
+      });
+      const result4 = await tool(server, "data_entity_read_many", {
+         entity: "posts",
+         limit: 10,
+      });
+      expect(result4.data.length).toBe(9);
+      expect(result4.data.map((p) => p.title)).toEqual(
+         Array.from({ length: 9 }, () => "Post updated"),
+      );
+
+      // delete many
+      await tool(server, "data_entity_delete_many", {
+         entity: "posts",
+         json: {
+            title: { $isnull: 0 },
+         },
+      });
+      const result5 = await tool(server, "data_entity_read_many", {
+         entity: "posts",
+         limit: 10,
+      });
+      expect(result5.data.length).toBe(0);
+      expect(result5.meta.items).toBe(0);
+      expect(result5.meta.total).toBe(0);
+   });
+});

app/__test__/app/mcp/mcp.media.test.ts

@@ -0,0 +1,119 @@
+import { describe, test, expect, beforeAll, beforeEach, afterAll } from "bun:test";
+import { type App, createApp, createMcpToolCaller } from "core/test/utils";
+import { getSystemMcp } from "modules/mcp/system-mcp";
+import { registries } from "index";
+import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { disableConsoleLog, enableConsoleLog } from "core/utils";
+import type { McpServer } from "bknd/utils";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
+
+/**
+ * - [x] config_media_get
+ * - [x] config_media_update
+ * - [x] config_media_adapter_get
+ * - [x] config_media_adapter_update
+ */
+describe("mcp media", async () => {
+   let app: App;
+   let server: McpServer;
+   beforeEach(async () => {
+      registries.media.register("local", StorageLocalAdapter);
+      app = createApp({
+         config: {
+            media: {
+               enabled: true,
+               adapter: {
+                  type: "local",
+                  config: {
+                     path: "./",
+                  },
+               },
+            },
+            server: {
+               mcp: {
+                  enabled: true,
+               },
+            },
+         },
+      });
+      await app.build();
+      await app.getMcpClient().ping();
+      server = app.mcp!;
+      server.setLogLevel("error");
+      server.onNotification((message) => {
+         console.dir(message, { depth: null });
+      });
+   });
+
+   const tool = createMcpToolCaller();
+
+   test("config_media_{get,update}", async () => {
+      const result = await tool(server, "config_media_get", {});
+      expect(result).toEqual({
+         path: "",
+         secrets: false,
+         partial: false,
+         value: app.toJSON().media,
+      });
+
+      // partial
+      expect((await tool(server, "config_media_get", { path: "adapter" })).value).toEqual({
+         type: "local",
+         config: {
+            path: "./",
+         },
+      });
+
+      // update
+      await tool(server, "config_media_update", {
+         value: {
+            storage: {
+               body_max_size: 1024 * 1024 * 10,
+            },
+         },
+         return_config: true,
+      });
+      expect(app.toJSON().media.storage.body_max_size).toBe(1024 * 1024 * 10);
+   });
+
+   test("config_media_adapter_{get,update}", async () => {
+      const result = await tool(server, "config_media_adapter_get", {});
+      expect(result).toEqual({
+         secrets: false,
+         value: app.toJSON().media.adapter,
+      });
+
+      // update
+      await tool(server, "config_media_adapter_update", {
+         value: {
+            type: "local",
+            config: {
+               path: "./subdir",
+            },
+         },
+      });
+      const adapter = app.toJSON().media.adapter as any;
+      expect(adapter.config.path).toBe("./subdir");
+      expect(adapter.type).toBe("local");
+
+      // set to s3
+      {
+         await tool(server, "config_media_adapter_update", {
+            value: {
+               type: "s3",
+               config: {
+                  access_key: "123",
+                  secret_access_key: "456",
+                  url: "https://example.com/what",
+               },
+            },
+         });
+
+         const adapter = app.toJSON(true).media.adapter as any;
+         expect(adapter.type).toBe("s3");
+         expect(adapter.config.url).toBe("https://example.com/what");
+      }
+   });
+});

app/__test__/app/mcp/mcp.server.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { type App, createApp, createMcpToolCaller } from "core/test/utils";
+import type { McpServer } from "bknd/utils";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
+
+/**
+ * - [x] config_server_get
+ * - [x] config_server_update
+ */
+describe("mcp system", async () => {
+   let app: App;
+   let server: McpServer;
+   beforeAll(async () => {
+      app = createApp({
+         config: {
+            server: {
+               mcp: {
+                  enabled: true,
+               },
+            },
+         },
+      });
+      await app.build();
+      await app.getMcpClient().ping();
+      server = app.mcp!;
+   });
+
+   const tool = createMcpToolCaller();
+
+   test("config_server_get", async () => {
+      const result = await tool(server, "config_server_get", {});
+      expect(JSON.parse(JSON.stringify(result))).toEqual({
+         path: "",
+         secrets: false,
+         partial: false,
+         value: JSON.parse(JSON.stringify(app.toJSON().server)),
+      });
+   });
+
+   test("config_server_get2", async () => {
+      const result = await tool(server, "config_server_get", {});
+      expect(JSON.parse(JSON.stringify(result))).toEqual({
+         path: "",
+         secrets: false,
+         partial: false,
+         value: JSON.parse(JSON.stringify(app.toJSON().server)),
+      });
+   });
+
+   test("config_server_update", async () => {
+      const original = JSON.parse(JSON.stringify(app.toJSON().server));
+      const result = await tool(server, "config_server_update", {
+         value: {
+            cors: {
+               origin: "http://localhost",
+            },
+         },
+         return_config: true,
+      });
+
+      expect(JSON.parse(JSON.stringify(result))).toEqual({
+         success: true,
+         module: "server",
+         config: {
+            ...original,
+            cors: {
+               ...original.cors,
+               origin: "http://localhost",
+            },
+         },
+      });
+      expect(app.toJSON().server.cors.origin).toBe("http://localhost");
+   });
+});

app/__test__/app/mcp/mcp.system.test.ts

@@ -0,0 +1,57 @@
+import { AppEvents } from "App";
+import { describe, test, expect, beforeAll, mock } from "bun:test";
+import { type App, createApp, createMcpToolCaller } from "core/test/utils";
+import type { McpServer } from "bknd/utils";
+
+/**
+ * - [x] system_config
+ * - [x] system_build
+ * - [x] system_ping
+ * - [x] system_info
+ */
+describe("mcp system", async () => {
+   let app: App;
+   let server: McpServer;
+   beforeAll(async () => {
+      app = createApp({
+         config: {
+            server: {
+               mcp: {
+                  enabled: true,
+               },
+            },
+         },
+      });
+      await app.build();
+      await app.getMcpClient().ping();
+      server = app.mcp!;
+   });
+
+   const tool = createMcpToolCaller();
+
+   test("system_ping", async () => {
+      const result = await tool(server, "system_ping", {});
+      expect(result).toEqual({ pong: true });
+   });
+
+   test("system_info", async () => {
+      const result = await tool(server, "system_info", {});
+      expect(Object.keys(result).length).toBeGreaterThan(0);
+      expect(Object.keys(result)).toContainValues(["version", "runtime", "connection"]);
+   });
+
+   test("system_build", async () => {
+      const called = mock(() => null);
+
+      app.emgr.onEvent(AppEvents.AppBuiltEvent, () => void called(), { once: true });
+
+      const result = await tool(server, "system_build", {});
+      expect(called).toHaveBeenCalledTimes(1);
+      expect(result.success).toBe(true);
+   });
+
+   test("system_config", async () => {
+      const result = await tool(server, "system_config", {});
+      expect(result).toEqual(app.toJSON());
+   });
+});

app/__test__/app/plugins/sync-config.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, mock, beforeAll, afterAll } from "bun:test";
+import { createApp } from "core/test/utils";
+import { syncConfig } from "plugins/dev/sync-config.plugin";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
+
+describe("syncConfig", () => {
+   it("should only sync if enabled", async () => {
+      const called = mock(() => null);
+      const app = createApp();
+      await app.build();
+
+      await syncConfig({
+         write: () => {
+            called();
+         },
+         enabled: false,
+         includeFirstBoot: false,
+      })(app).onBuilt?.();
+      expect(called).not.toHaveBeenCalled();
+
+      await syncConfig({
+         write: () => {
+            called();
+         },
+         enabled: false,
+         includeFirstBoot: true,
+      })(app).onBuilt?.();
+      expect(called).not.toHaveBeenCalled();
+
+      await syncConfig({
+         write: () => {
+            called();
+         },
+         enabled: true,
+         includeFirstBoot: true,
+      })(app).onBuilt?.();
+      expect(called).toHaveBeenCalledTimes(1);
+   });
+
+   it("should respect secrets", async () => {
+      const called = mock(() => null);
+      const app = createApp({
+         config: {
+            auth: {
+               enabled: true,
+               jwt: {
+                  secret: "test",
+               },
+            },
+         },
+      });
+      await app.build();
+
+      await syncConfig({
+         write: async (config) => {
+            called();
+            expect(config.auth.jwt.secret).toBe("test");
+         },
+         enabled: true,
+         includeSecrets: true,
+         includeFirstBoot: true,
+      })(app).onBuilt?.();
+
+      await syncConfig({
+         write: async (config) => {
+            called();
+            // it's an important test, because the `jwt` part is omitted if secrets=false in general app.toJSON()
+            // but it's required to get the app running
+            expect(config.auth.jwt.secret).toBe("");
+         },
+         enabled: true,
+         includeSecrets: false,
+         includeFirstBoot: true,
+      })(app).onBuilt?.();
+      expect(called).toHaveBeenCalledTimes(2);
+   });
+});

app/__test__/app/repro.spec.ts

@@ -1,7 +1,12 @@
-import { describe, expect, test } from "bun:test";
-import { createApp, registries } from "../../src";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { registries } from "../../src";
+import { createApp } from "core/test/utils";
 import * as proto from "../../src/data/prototype";
-import { StorageLocalAdapter } from "../../src/media/storage/adapters/StorageLocalAdapter";
+import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
 
 describe("repros", async () => {
    /**
@@ -87,7 +92,7 @@ describe("repros", async () => {
             fns.relation(schema.product_likes).manyToOne(schema.users);
          },
       );
-      const app = createApp({ initialConfig: { data: schema.toJSON() } });
+      const app = createApp({ config: { data: schema.toJSON() } });
       await app.build();
 
       const info = (await (await app.server.request("/api/data/info/products")).json()) as any;

app/__test__/auth/Authenticator.spec.ts

@@ -1,46 +1,3 @@
 import { describe, expect, test } from "bun:test";
-import { Authenticator, type User, type UserPool } from "../../src/auth";
-import { cookieConfig } from "../../src/auth/authenticate/Authenticator";
-import { PasswordStrategy } from "../../src/auth/authenticate/strategies/PasswordStrategy";
-import * as hash from "../../src/auth/utils/hash";
-import { Default, parse } from "../../src/core/utils";
 
-/*class MemoryUserPool implements UserPool {
-   constructor(private users: User[] = []) {}
-
-   async findBy(prop: "id" | "email" | "username", value: string | number) {
-      return this.users.find((user) => user[prop] === value);
-   }
-
-   async create(user: Pick<User, "email" | "password">) {
-      const id = this.users.length + 1;
-      const newUser = { ...user, id, username: user.email };
-      this.users.push(newUser);
-      return newUser;
-   }
-}*/
-
-describe("Authenticator", async () => {
-   test("cookie options", async () => {
-      console.log("parsed", parse(cookieConfig, undefined));
-      console.log(Default(cookieConfig, {}));
-   });
-   /*const userpool = new MemoryUserPool([
-      { id: 1, email: "d", username: "test", password: await hash.sha256("test") },
-   ]);
-
-   test("sha256 login", async () => {
-      const auth = new Authenticator(userpool, {
-         password: new PasswordStrategy({
-            hashing: "sha256",
-         }),
-      });
-
-      const { token } = await auth.login("password", { email: "d", password: "test" });
-      expect(token).toBeDefined();
-
-      const { iat, ...decoded } = decodeJwt<any>(token);
-      expect(decoded).toEqual({ id: 1, email: "d", username: "test" });
-      expect(await auth.verify(token)).toBe(true);
-   });*/
-});
+describe("Authenticator", async () => {});

app/__test__/auth/authorize/authorize.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { Guard } from "../../../src/auth";
+import { Guard } from "../../../src/auth/authorize/Guard";
 
 describe("authorize", () => {
    test("basic", async () => {

app/__test__/auth/strategies/OAuthStrategy.spec.ts

@@ -3,8 +3,10 @@ import { OAuthStrategy } from "../../../src/auth/authenticate/strategies";
 
 const ALL_TESTS = !!process.env.ALL_TESTS;
 
+// @todo: add mock response
 describe("OAuthStrategy", async () => {
-   const strategy = new OAuthStrategy({
+   return;
+   /*const strategy = new OAuthStrategy({
       type: "oidc",
       client: {
          client_id: process.env.OAUTH_CLIENT_ID!,
@@ -21,6 +23,7 @@ describe("OAuthStrategy", async () => {
 
       const server = Bun.serve({
          fetch: async (req) => {
+            console.log("req", req.method, req.url);
             const url = new URL(req.url);
             if (url.pathname === "/auth/google/callback") {
                console.log("req", req);
@@ -42,5 +45,5 @@ describe("OAuthStrategy", async () => {
       console.log("request", request);
 
       await new Promise((resolve) => setTimeout(resolve, 100000));
-   });
+   });*/
 });

app/__test__/core/EventManager.spec.ts

@@ -1,6 +1,6 @@
 import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
 import { Event, EventManager, InvalidEventReturn, NoParamEvent } from "../../src/core/events";
-import { disableConsoleLog, enableConsoleLog } from "../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
 
 beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
@@ -70,6 +70,9 @@ describe("EventManager", async () => {
       new SpecialEvent({ foo: "bar" });
       new InformationalEvent();
 
+      // execute asyncs
+      await emgr.executeAsyncs();
+
       expect(call).toHaveBeenCalledTimes(2);
       expect(delayed).toHaveBeenCalled();
    });
@@ -80,15 +83,11 @@ describe("EventManager", async () => {
          call();
          return Promise.all(p);
       };
-      const emgr = new EventManager(
-         { InformationalEvent },
-         {
-            asyncExecutor,
-         },
-      );
+      const emgr = new EventManager({ InformationalEvent });
 
       emgr.onEvent(InformationalEvent, async () => {});
       await emgr.emit(new InformationalEvent());
+      await emgr.executeAsyncs(asyncExecutor);
       expect(call).toHaveBeenCalled();
    });
 
@@ -125,6 +124,9 @@ describe("EventManager", async () => {
       const e2 = await emgr.emit(new ReturnEvent({ foo: "bar" }));
       expect(e2.returned).toBe(true);
       expect(e2.params.foo).toBe("bar-1-0");
+
+      await emgr.executeAsyncs();
+
       expect(onInvalidReturn).toHaveBeenCalled();
       expect(asyncEventCallback).toHaveBeenCalled();
    });

app/__test__/core/Registry.spec.ts

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import type { TObject, TString } from "@sinclair/typebox";
-import { Registry } from "../../src/core/registry/Registry";
-import { type TSchema, Type } from "../../src/core/utils";
+import { Registry } from "core/registry/Registry";
+import { s } from "core/utils/schema";
 
 type Constructor<T> = new (...args: any[]) => T;
 
@@ -12,7 +11,7 @@ class What {
       return null;
    }
    getType() {
-      return Type.Object({ type: Type.String() });
+      return s.object({ type: s.string() });
    }
 }
 class What2 extends What {}
@@ -20,7 +19,7 @@ class NotAllowed {}
 
 type Test1 = {
    cls: new (...args: any[]) => What;
-   schema: TObject<{ type: TString }>;
+   schema: s.ObjectSchema<{ type: s.StringSchema }>;
    enabled: boolean;
 };
 
@@ -29,7 +28,7 @@ describe("Registry", () => {
       const registry = new Registry<Test1>().set({
          first: {
             cls: What,
-            schema: Type.Object({ type: Type.String(), what: Type.String() }),
+            schema: s.object({ type: s.string(), what: s.string() }),
             enabled: true,
          },
       } satisfies Record<string, Test1>);
@@ -38,7 +37,7 @@ describe("Registry", () => {
       expect(item).toBeDefined();
       expect(item?.cls).toBe(What);
 
-      const second = Type.Object({ type: Type.String(), what: Type.String() });
+      const second = s.object({ type: s.string(), what: s.string() });
       registry.add("second", {
          cls: What2,
          schema: second,
@@ -47,7 +46,7 @@ describe("Registry", () => {
       // @ts-ignore
       expect(registry.get("second").schema).toEqual(second);
 
-      const third = Type.Object({ type: Type.String({ default: "1" }), what22: Type.String() });
+      const third = s.object({ type: s.string({ default: "1" }), what22: s.string() });
       registry.add("third", {
          // @ts-expect-error
          cls: NotAllowed,
@@ -57,7 +56,7 @@ describe("Registry", () => {
       // @ts-ignore
       expect(registry.get("third").schema).toEqual(third);
 
-      const fourth = Type.Object({ type: Type.Number(), what22: Type.String() });
+      const fourth = s.object({ type: s.number(), what22: s.string() });
       registry.add("fourth", {
          cls: What,
          // @ts-expect-error
@@ -82,6 +81,8 @@ describe("Registry", () => {
       registry.register("what2", What2);
       expect(registry.get("what2")).toBeDefined();
       expect(registry.get("what2").cls).toBe(What2);
-      expect(registry.get("what2").schema).toEqual(What2.prototype.getType());
+      expect(JSON.stringify(registry.get("what2").schema)).toEqual(
+         JSON.stringify(What2.prototype.getType()),
+      );
    });
 });

app/__test__/core/cache/CloudflareKvCache.native-spec.ts

@@ -1,57 +0,0 @@
-import * as assert from "node:assert/strict";
-import { createWriteStream } from "node:fs";
-import { after, beforeEach, describe, test } from "node:test";
-import { Miniflare } from "miniflare";
-import {
-   CloudflareKVCacheItem,
-   CloudflareKVCachePool,
-} from "../../../src/core/cache/adapters/CloudflareKvCache";
-import { runTests } from "./cache-test-suite";
-
-// https://github.com/nodejs/node/issues/44372#issuecomment-1736530480
-console.log = async (message: any) => {
-   const tty = createWriteStream("/dev/tty");
-   const msg = typeof message === "string" ? message : JSON.stringify(message, null, 2);
-   return tty.write(`${msg}\n`);
-};
-
-describe("CloudflareKv", async () => {
-   let mf: Miniflare;
-   runTests({
-      createCache: async () => {
-         if (mf) {
-            await mf.dispose();
-         }
-
-         mf = new Miniflare({
-            modules: true,
-            script: "export default { async fetch() { return new Response(null); } }",
-            kvNamespaces: ["TEST"],
-         });
-         const kv = await mf.getKVNamespace("TEST");
-         return new CloudflareKVCachePool(kv as any);
-      },
-      createItem: (key, value) => new CloudflareKVCacheItem(key, value),
-      tester: {
-         test,
-         beforeEach,
-         expect: (actual?: any) => {
-            return {
-               toBe(expected: any) {
-                  assert.equal(actual, expected);
-               },
-               toEqual(expected: any) {
-                  assert.deepEqual(actual, expected);
-               },
-               toBeUndefined() {
-                  assert.equal(actual, undefined);
-               },
-            };
-         },
-      },
-   });
-
-   after(async () => {
-      await mf?.dispose();
-   });
-});

app/__test__/core/cache/MemoryCache.spec.ts

@@ -1,15 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-import { MemoryCache, MemoryCacheItem } from "../../../src/core/cache/adapters/MemoryCache";
-import { runTests } from "./cache-test-suite";
-
-describe("MemoryCache", () => {
-   runTests({
-      createCache: async () => new MemoryCache(),
-      createItem: (key, value) => new MemoryCacheItem(key, value),
-      tester: {
-         test,
-         beforeEach,
-         expect,
-      },
-   });
-});

app/__test__/core/cache/cache-test-suite.ts

@@ -1,84 +0,0 @@
-//import { beforeEach as bunBeforeEach, expect as bunExpect, test as bunTest } from "bun:test";
-import type { ICacheItem, ICachePool } from "../../../src/core/cache/cache-interface";
-
-export type TestOptions = {
-   createCache: () => Promise<ICachePool>;
-   createItem: (key: string, value: any) => ICacheItem;
-   tester: {
-      test: (name: string, fn: () => Promise<void>) => void;
-      beforeEach: (fn: () => Promise<void>) => void;
-      expect: (actual?: any) => {
-         toBe(expected: any): void;
-         toEqual(expected: any): void;
-         toBeUndefined(): void;
-      };
-   };
-};
-
-export function runTests({ createCache, createItem, tester }: TestOptions) {
-   let cache: ICachePool<string>;
-   const { test, beforeEach, expect } = tester;
-
-   beforeEach(async () => {
-      cache = await createCache();
-   });
-
-   test("getItem returns correct item", async () => {
-      const item = createItem("key1", "value1");
-      await cache.save(item);
-      const retrievedItem = await cache.get("key1");
-      expect(retrievedItem.value()).toEqual(item.value());
-   });
-
-   test("getItem returns new item when key does not exist", async () => {
-      const retrievedItem = await cache.get("key1");
-      expect(retrievedItem.key()).toEqual("key1");
-      expect(retrievedItem.value()).toBeUndefined();
-   });
-
-   test("getItems returns correct items", async () => {
-      const item1 = createItem("key1", "value1");
-      const item2 = createItem("key2", "value2");
-      await cache.save(item1);
-      await cache.save(item2);
-      const retrievedItems = await cache.getMany(["key1", "key2"]);
-      expect(retrievedItems.get("key1")?.value()).toEqual(item1.value());
-      expect(retrievedItems.get("key2")?.value()).toEqual(item2.value());
-   });
-
-   test("hasItem returns true when item exists and is a hit", async () => {
-      const item = createItem("key1", "value1");
-      await cache.save(item);
-      expect(await cache.has("key1")).toBe(true);
-   });
-
-   test("clear and deleteItem correctly clear the cache and delete items", async () => {
-      const item = createItem("key1", "value1");
-      await cache.save(item);
-
-      if (cache.supports().clear) {
-         await cache.clear();
-      } else {
-         await cache.delete("key1");
-      }
-
-      expect(await cache.has("key1")).toBe(false);
-   });
-
-   test("save correctly saves items to the cache", async () => {
-      const item = createItem("key1", "value1");
-      await cache.save(item);
-      expect(await cache.has("key1")).toBe(true);
-   });
-
-   test("putItem correctly puts items in the cache ", async () => {
-      await cache.put("key1", "value1", { ttl: 60 });
-      const item = await cache.get("key1");
-      expect(item.value()).toEqual("value1");
-      expect(item.hit()).toBe(true);
-   });
-
-   /*test("commit returns true", async () => {
-      expect(await cache.commit()).toBe(true);
-   });*/
-}

app/__test__/core/object/SchemaObject.spec.ts

@@ -1,11 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { SchemaObject } from "../../../src/core";
-import { Type } from "../../../src/core/utils";
+import { s } from "core/utils/schema";
+import { SchemaObject } from "core/object/SchemaObject";
 
 describe("SchemaObject", async () => {
    test("basic", async () => {
       const m = new SchemaObject(
-         Type.Object({ a: Type.String({ default: "b" }) }),
+         s.strictObject({ a: s.string({ default: "b" }) }),
          { a: "test" },
          {
             forceParse: true,
@@ -23,19 +23,19 @@ describe("SchemaObject", async () => {
 
    test("patch", async () => {
       const m = new SchemaObject(
-         Type.Object({
-            s: Type.Object(
+         s.strictObject({
+            s: s.strictObject(
                {
-                  a: Type.String({ default: "b" }),
-                  b: Type.Object(
+                  a: s.string({ default: "b" }),
+                  b: s.strictObject(
                      {
-                        c: Type.String({ default: "d" }),
-                        e: Type.String({ default: "f" }),
+                        c: s.string({ default: "d" }),
+                        e: s.string({ default: "f" }),
                      },
                      { default: {} },
                   ),
                },
-               { default: {}, additionalProperties: false },
+               { default: {} },
             ),
          }),
       );
@@ -44,7 +44,7 @@ describe("SchemaObject", async () => {
       await m.patch("s.a", "c");
 
       // non-existing path on no additional properties
-      expect(() => m.patch("s.s.s", "c")).toThrow();
+      expect(m.patch("s.s.s", "c")).rejects.toThrow();
       // wrong type
       expect(() => m.patch("s.a", 1)).toThrow();
 
@@ -58,8 +58,8 @@ describe("SchemaObject", async () => {
 
    test("patch array", async () => {
       const m = new SchemaObject(
-         Type.Object({
-            methods: Type.Array(Type.String(), { default: ["GET", "PATCH"] }),
+         s.strictObject({
+            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
          }),
       );
       expect(m.get()).toEqual({ methods: ["GET", "PATCH"] });
@@ -75,13 +75,13 @@ describe("SchemaObject", async () => {
 
    test("remove", async () => {
       const m = new SchemaObject(
-         Type.Object({
-            s: Type.Object(
+         s.object({
+            s: s.object(
                {
-                  a: Type.String({ default: "b" }),
-                  b: Type.Object(
+                  a: s.string({ default: "b" }),
+                  b: s.object(
                      {
-                        c: Type.String({ default: "d" }),
+                        c: s.string({ default: "d" }),
                      },
                      { default: {} },
                   ),
@@ -107,8 +107,8 @@ describe("SchemaObject", async () => {
 
    test("set", async () => {
       const m = new SchemaObject(
-         Type.Object({
-            methods: Type.Array(Type.String(), { default: ["GET", "PATCH"] }),
+         s.strictObject({
+            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
          }),
       );
       expect(m.get()).toEqual({ methods: ["GET", "PATCH"] });
@@ -124,8 +124,8 @@ describe("SchemaObject", async () => {
       let called = false;
       let result: any;
       const m = new SchemaObject(
-         Type.Object({
-            methods: Type.Array(Type.String(), { default: ["GET", "PATCH"] }),
+         s.strictObject({
+            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
          }),
          undefined,
          {
@@ -145,8 +145,8 @@ describe("SchemaObject", async () => {
    test("listener: onBeforeUpdate", async () => {
       let called = false;
       const m = new SchemaObject(
-         Type.Object({
-            methods: Type.Array(Type.String(), { default: ["GET", "PATCH"] }),
+         s.strictObject({
+            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
          }),
          undefined,
          {
@@ -167,7 +167,7 @@ describe("SchemaObject", async () => {
    });
 
    test("throwIfRestricted", async () => {
-      const m = new SchemaObject(Type.Object({}), undefined, {
+      const m = new SchemaObject(s.strictObject({}), undefined, {
          restrictPaths: ["a.b"],
       });
 
@@ -179,13 +179,13 @@ describe("SchemaObject", async () => {
 
    test("restriction bypass", async () => {
       const m = new SchemaObject(
-         Type.Object({
-            s: Type.Object(
+         s.strictObject({
+            s: s.strictObject(
                {
-                  a: Type.String({ default: "b" }),
-                  b: Type.Object(
+                  a: s.string({ default: "b" }),
+                  b: s.strictObject(
                      {
-                        c: Type.String({ default: "d" }),
+                        c: s.string({ default: "d" }),
                      },
                      { default: {} },
                   ),
@@ -205,7 +205,21 @@ describe("SchemaObject", async () => {
       expect(m.get()).toEqual({ s: { a: "b", b: { c: "e" } } });
    });
 
-   const dataEntitiesSchema = Type.Object(
+   const dataEntitiesSchema = s.strictObject({
+      entities: s.record(
+         s.object({
+            fields: s.record(
+               s.object({
+                  type: s.string(),
+                  config: s.object({}).optional(),
+               }),
+            ),
+            config: s.record(s.string()).optional(),
+         }),
+      ),
+   });
+
+   /* const dataEntitiesSchema = Type.Object(
       {
          entities: Type.Object(
             {},
@@ -230,7 +244,7 @@ describe("SchemaObject", async () => {
       {
          additionalProperties: false,
       },
-   );
+   ); */
    test("patch safe object, overwrite", async () => {
       const data = {
          entities: {

app/__test__/core/object/object-query.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { type ObjectQuery, convert, validate } from "../../../src/core/object/query/object-query";
+import { type ObjectQuery, convert, validate } from "core/object/query/object-query";
 
 describe("object-query", () => {
    const q: ObjectQuery = { name: "Michael" };

app/__test__/core/utils.spec.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { Perf, datetimeStringUTC, isBlob, ucFirst } from "../../src/core/utils";
+import { Perf, ucFirst } from "../../src/core/utils";
 import * as utils from "../../src/core/utils";
+import { assetsPath } from "../helper";
 
 async function wait(ms: number) {
    return new Promise((resolve) => {
@@ -75,57 +76,6 @@ describe("Core Utils", async () => {
          const result3 = utils.encodeSearch(obj3, { encode: true });
          expect(result3).toBe("id=123&name=%7B%22test%22%3A%22test%22%7D");
       });
-
-      describe("guards", () => {
-         const types = {
-            blob: new Blob(),
-            file: new File([""], "file.txt"),
-            stream: new ReadableStream(),
-            arrayBuffer: new ArrayBuffer(10),
-            arrayBufferView: new Uint8Array(new ArrayBuffer(10)),
-         };
-
-         const fns = [
-            [utils.isReadableStream, "stream"],
-            [utils.isBlob, "blob", ["stream", "arrayBuffer", "arrayBufferView"]],
-            [utils.isFile, "file", ["stream", "arrayBuffer", "arrayBufferView"]],
-            [utils.isArrayBuffer, "arrayBuffer"],
-            [utils.isArrayBufferView, "arrayBufferView"],
-         ] as const;
-
-         const additional = [0, 0.0, "", null, undefined, {}, []];
-
-         for (const [fn, type, _to_test] of fns) {
-            test(`is${ucFirst(type)}`, () => {
-               const to_test = _to_test ?? (Object.keys(types) as string[]);
-               for (const key of to_test) {
-                  const value = types[key as keyof typeof types];
-                  const result = fn(value);
-                  expect(result).toBe(key === type);
-               }
-
-               for (const value of additional) {
-                  const result = fn(value);
-                  expect(result).toBe(false);
-               }
-            });
-         }
-      });
-
-      test("getContentName", () => {
-         const name = "test.json";
-         const text = "attachment; filename=" + name;
-         const headers = new Headers({
-            "Content-Disposition": text,
-         });
-         const request = new Request("http://example.com", {
-            headers,
-         });
-
-         expect(utils.getContentName(text)).toBe(name);
-         expect(utils.getContentName(headers)).toBe(name);
-         expect(utils.getContentName(request)).toBe(name);
-      });
    });
 
    describe("perf", async () => {
@@ -246,13 +196,83 @@ describe("Core Utils", async () => {
       });
    });
 
+   describe("file", async () => {
+      describe("type guards", () => {
+         const types = {
+            blob: new Blob(),
+            file: new File([""], "file.txt"),
+            stream: new ReadableStream(),
+            arrayBuffer: new ArrayBuffer(10),
+            arrayBufferView: new Uint8Array(new ArrayBuffer(10)),
+         };
+
+         const fns = [
+            [utils.isReadableStream, "stream"],
+            [utils.isBlob, "blob", ["stream", "arrayBuffer", "arrayBufferView"]],
+            [utils.isFile, "file", ["stream", "arrayBuffer", "arrayBufferView"]],
+            [utils.isArrayBuffer, "arrayBuffer"],
+            [utils.isArrayBufferView, "arrayBufferView"],
+         ] as const;
+
+         const additional = [0, 0.0, "", null, undefined, {}, []];
+
+         for (const [fn, type, _to_test] of fns) {
+            test(`is${ucFirst(type)}`, () => {
+               const to_test = _to_test ?? (Object.keys(types) as string[]);
+               for (const key of to_test) {
+                  const value = types[key as keyof typeof types];
+                  const result = fn(value);
+                  expect(result).toBe(key === type);
+               }
+
+               for (const value of additional) {
+                  const result = fn(value);
+                  expect(result).toBe(false);
+               }
+            });
+         }
+      });
+
+      test("getContentName", () => {
+         const name = "test.json";
+         const text = "attachment; filename=" + name;
+         const headers = new Headers({
+            "Content-Disposition": text,
+         });
+         const request = new Request("http://example.com", {
+            headers,
+         });
+
+         expect(utils.getContentName(text)).toBe(name);
+         expect(utils.getContentName(headers)).toBe(name);
+         expect(utils.getContentName(request)).toBe(name);
+      });
+
+      test("detectImageDimensions", async () => {
+         // wrong
+         // @ts-expect-error
+         expect(utils.detectImageDimensions(new ArrayBuffer(), "text/plain")).rejects.toThrow();
+
+         // successful ones
+         const getFile = (name: string): File => Bun.file(`${assetsPath}/${name}`) as any;
+         expect(await utils.detectImageDimensions(getFile("image.png"))).toEqual({
+            width: 362,
+            height: 387,
+         });
+         expect(await utils.detectImageDimensions(getFile("image.jpg"))).toEqual({
+            width: 453,
+            height: 512,
+         });
+      });
+   });
+
    describe("dates", () => {
-      test.only("formats local time", () => {
+      test("formats local time", () => {
          expect(utils.datetimeStringUTC("2025-02-21T16:48:25.841Z")).toBe("2025-02-21 16:48:25");
-         console.log(utils.datetimeStringUTC(new Date()));
+         /*console.log(utils.datetimeStringUTC(new Date()));
          console.log(utils.datetimeStringUTC());
          console.log(new Date());
-         console.log("timezone", Intl.DateTimeFormat().resolvedOptions().timeZone);
+         console.log("timezone", Intl.DateTimeFormat().resolvedOptions().timeZone); */
       });
    });
 });

app/__test__/data/DataController.spec.ts

@@ -1,72 +1,24 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 
-import { Guard } from "../../src/auth";
-import { parse } from "../../src/core/utils";
-import {
-   Entity,
-   type EntityData,
-   EntityManager,
-   ManyToOneRelation,
-   type MutatorResponse,
-   type RepositoryResponse,
-   TextField,
-} from "../../src/data";
+import { Guard } from "../../src/auth/authorize/Guard";
+import { parse } from "core/utils/schema";
+
 import { DataController } from "../../src/data/api/DataController";
 import { dataConfigSchema } from "../../src/data/data-schema";
-import { disableConsoleLog, enableConsoleLog, getDummyConnection } from "../helper";
+import { getDummyConnection } from "../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+import type { RepositoryResultJSON } from "data/entities/query/RepositoryResult";
+import type { MutatorResultJSON } from "data/entities/mutation/MutatorResult";
+import { Entity, EntityManager, type EntityData } from "data/entities";
+import { TextField } from "data/fields";
+import { ManyToOneRelation } from "data/relations";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
-beforeAll(() => disableConsoleLog(["log", "warn"]));
+beforeAll(() => disableConsoleLog());
 afterAll(async () => (await afterAllCleanup()) && enableConsoleLog());
 
 const dataConfig = parse(dataConfigSchema, {});
 describe("[data] DataController", async () => {
-   test("repoResult", async () => {
-      const em = new EntityManager<any>([], dummyConnection);
-      const ctx: any = { em, guard: new Guard() };
-      const controller = new DataController(ctx, dataConfig);
-
-      const res = controller.repoResult({
-         entity: null as any,
-         data: [] as any,
-         sql: "",
-         parameters: [] as any,
-         result: [] as any,
-         meta: {
-            total: 0,
-            count: 0,
-            items: 0,
-         },
-      });
-
-      expect(res).toEqual({
-         meta: {
-            total: 0,
-            count: 0,
-            items: 0,
-         },
-         data: [],
-      });
-   });
-
-   test("mutatorResult", async () => {
-      const em = new EntityManager([], dummyConnection);
-      const ctx: any = { em, guard: new Guard() };
-      const controller = new DataController(ctx, dataConfig);
-
-      const res = controller.mutatorResult({
-         entity: null as any,
-         data: [] as any,
-         sql: "",
-         parameters: [] as any,
-         result: [] as any,
-      });
-
-      expect(res).toEqual({
-         data: [],
-      });
-   });
-
    describe("getController", async () => {
       const users = new Entity("users", [
          new TextField("name", { required: true }),
@@ -120,8 +72,7 @@ describe("[data] DataController", async () => {
                method: "POST",
                body: JSON.stringify(_user),
             });
-            //console.log("res", { _user }, res);
-            const result = (await res.json()) as MutatorResponse;
+            const result = (await res.json()) as MutatorResultJSON;
             const { id, ...data } = result.data as any;
 
             expect(res.status).toBe(201);
@@ -135,7 +86,7 @@ describe("[data] DataController", async () => {
                method: "POST",
                body: JSON.stringify(_post),
             });
-            const result = (await res.json()) as MutatorResponse;
+            const result = (await res.json()) as MutatorResultJSON;
             const { id, ...data } = result.data as any;
 
             expect(res.status).toBe(201);
@@ -146,13 +97,13 @@ describe("[data] DataController", async () => {
 
       test("/:entity (read many)", async () => {
          const res = await app.request("/entity/users");
-         const data = (await res.json()) as RepositoryResponse;
+         const data = (await res.json()) as RepositoryResultJSON;
 
-         expect(data.meta.total).toBe(3);
-         expect(data.meta.count).toBe(3);
+         //expect(data.meta.total).toBe(3);
+         //expect(data.meta.count).toBe(3);
          expect(data.meta.items).toBe(3);
          expect(data.data.length).toBe(3);
-         expect(data.data[0].name).toBe("foo");
+         expect(data.data[0]?.name).toBe("foo");
       });
 
       test("/:entity/query (func query)", async () => {
@@ -165,33 +116,32 @@ describe("[data] DataController", async () => {
                where: { bio: { $isnull: 1 } },
             }),
          });
-         const data = (await res.json()) as RepositoryResponse;
+         const data = (await res.json()) as RepositoryResultJSON;
 
-         expect(data.meta.total).toBe(3);
-         expect(data.meta.count).toBe(1);
+         //expect(data.meta.total).toBe(3);
+         //expect(data.meta.count).toBe(1);
          expect(data.meta.items).toBe(1);
          expect(data.data.length).toBe(1);
-         expect(data.data[0].name).toBe("bar");
+         expect(data.data[0]?.name).toBe("bar");
       });
 
       test("/:entity (read many, paginated)", async () => {
          const res = await app.request("/entity/users?limit=1&offset=2");
-         const data = (await res.json()) as RepositoryResponse;
+         const data = (await res.json()) as RepositoryResultJSON;
 
-         expect(data.meta.total).toBe(3);
-         expect(data.meta.count).toBe(3);
+         //expect(data.meta.total).toBe(3);
+         //expect(data.meta.count).toBe(3);
          expect(data.meta.items).toBe(1);
          expect(data.data.length).toBe(1);
-         expect(data.data[0].name).toBe("baz");
+         expect(data.data[0]?.name).toBe("baz");
       });
 
       test("/:entity/:id (read one)", async () => {
          const res = await app.request("/entity/users/3");
-         const data = (await res.json()) as RepositoryResponse<EntityData>;
-         console.log("data", data);
+         const data = (await res.json()) as RepositoryResultJSON<EntityData>;
 
-         expect(data.meta.total).toBe(3);
-         expect(data.meta.count).toBe(1);
+         //expect(data.meta.total).toBe(3);
+         //expect(data.meta.count).toBe(1);
          expect(data.meta.items).toBe(1);
          expect(data.data).toEqual({ id: 3, ...fixtures.users[2] });
       });
@@ -201,7 +151,7 @@ describe("[data] DataController", async () => {
             method: "PATCH",
             body: JSON.stringify({ name: "new name" }),
          });
-         const { data } = (await res.json()) as MutatorResponse;
+         const { data } = (await res.json()) as MutatorResultJSON;
 
          expect(res.ok).toBe(true);
          expect(data as any).toEqual({ id: 3, ...fixtures.users[2], name: "new name" });
@@ -209,27 +159,26 @@ describe("[data] DataController", async () => {
 
       test("/:entity/:id/:reference (read references)", async () => {
          const res = await app.request("/entity/users/1/posts");
-         const data = (await res.json()) as RepositoryResponse;
-         console.log("data", data);
+         const data = (await res.json()) as RepositoryResultJSON;
 
-         expect(data.meta.total).toBe(2);
-         expect(data.meta.count).toBe(1);
+         //expect(data.meta.total).toBe(2);
+         //expect(data.meta.count).toBe(1);
          expect(data.meta.items).toBe(1);
          expect(data.data.length).toBe(1);
-         expect(data.data[0].content).toBe("post 1");
+         expect(data.data[0]?.content).toBe("post 1");
       });
 
       test("/:entity/:id (delete one)", async () => {
          const res = await app.request("/entity/posts/2", {
             method: "DELETE",
          });
-         const { data } = (await res.json()) as RepositoryResponse<EntityData>;
+         const { data } = (await res.json()) as RepositoryResultJSON<EntityData>;
          expect(data).toEqual({ id: 2, ...fixtures.posts[1] });
 
          // verify
          const res2 = await app.request("/entity/posts");
-         const data2 = (await res2.json()) as RepositoryResponse;
-         expect(data2.meta.total).toBe(1);
+         const data2 = (await res2.json()) as RepositoryResultJSON;
+         //expect(data2.meta.total).toBe(1);
       });
    });
 });

app/__test__/data/data.test.ts

@@ -1,12 +1,6 @@
 import { afterAll, describe, expect, test } from "bun:test";
-import {
-   Entity,
-   EntityManager,
-   NumberField,
-   PrimaryField,
-   Repository,
-   TextField,
-} from "../../src/data";
+import { Entity, EntityManager } from "data/entities";
+import { TextField, PrimaryField, NumberField } from "data/fields";
 import { getDummyConnection } from "./helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -34,19 +28,12 @@ describe("some tests", async () => {
 
    test("findId", async () => {
       const query = await em.repository(users).findId(1);
-      /*const { result, total, count, time } = query;
-      console.log("query", query.result, {
-         result,
-         total,
-         count,
-         time,
-      });*/
 
       expect(query.sql).toBe(
          'select "users"."id" as "id", "users"."username" as "username", "users"."email" as "email" from "users" where "id" = ? limit ?',
       );
       expect(query.parameters).toEqual([1, 1]);
-      expect(query.result).toEqual([]);
+      expect(query.data).toBeUndefined();
    });
 
    test("findMany", async () => {
@@ -56,7 +43,7 @@ describe("some tests", async () => {
          'select "users"."id" as "id", "users"."username" as "username", "users"."email" as "email" from "users" order by "users"."id" asc limit ? offset ?',
       );
       expect(query.parameters).toEqual([10, 0]);
-      expect(query.result).toEqual([]);
+      expect(query.data).toEqual([]);
    });
 
    test("findMany with number", async () => {
@@ -66,7 +53,7 @@ describe("some tests", async () => {
          'select "posts"."id" as "id", "posts"."title" as "title", "posts"."content" as "content", "posts"."created_at" as "created_at", "posts"."likes" as "likes" from "posts" order by "posts"."id" asc limit ? offset ?',
       );
       expect(query.parameters).toEqual([10, 0]);
-      expect(query.result).toEqual([]);
+      expect(query.data).toEqual([]);
    });
 
    test("try adding an existing field name", async () => {
@@ -110,4 +97,18 @@ describe("some tests", async () => {
          new EntityManager([entity, entity2], connection);
       }).toThrow();
    });
+
+   test("primary uuid", async () => {
+      const entity = new Entity("users", [
+         new PrimaryField("id", { format: "uuid" }),
+         new TextField("username"),
+      ]);
+      const em = new EntityManager([entity], getDummyConnection().dummyConnection);
+      await em.schema().sync({ force: true });
+
+      const mutator = em.mutator(entity);
+      const data = await mutator.insertOne({ username: "test" });
+      expect(data.data.id).toBeDefined();
+      expect(data.data.id).toBeString();
+   });
 });

app/__test__/data/helper.ts

@@ -2,7 +2,7 @@ import { unlink } from "node:fs/promises";
 import type { SqliteDatabase } from "kysely";
 // @ts-ignore
 import Database from "libsql";
-import { SqliteLocalConnection } from "../../src/data";
+import { SqliteLocalConnection } from "data/connection/sqlite/SqliteLocalConnection";
 
 export function getDummyDatabase(memory: boolean = true): {
    dummyDb: SqliteDatabase;

app/__test__/data/mutation.relation.test.ts

@@ -1,13 +1,10 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import {
-   Entity,
-   EntityManager,
-   ManyToOneRelation,
-   NumberField,
-   SchemaManager,
-   TextField,
-} from "../../src/data";
+import { Entity } from "data/entities";
+import { EntityManager } from "data/entities/EntityManager";
+import { ManyToOneRelation } from "data/relations";
+import { NumberField, TextField } from "data/fields";
+import { SchemaManager } from "data/schema/SchemaManager";
 import { getDummyConnection } from "./helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();

app/__test__/data/mutation.simple.test.ts

@@ -1,7 +1,8 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager, Mutator, NumberField, TextField } from "../../src/data";
-import { TransformPersistFailedException } from "../../src/data/errors";
+import { Entity, EntityManager } from "data/entities";
+import { NumberField, TextField } from "data/fields";
+import { TransformPersistFailedException } from "data/errors";
 import { getDummyConnection } from "./helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -45,7 +46,7 @@ describe("Mutator simple", async () => {
          },
       });
 
-      expect(query.result).toEqual([{ id: 1, label: "test", count: 1 }]);
+      expect(query.data).toEqual([{ id: 1, label: "test", count: 1 }]);
    });
 
    test("update inserted row", async () => {
@@ -87,7 +88,7 @@ describe("Mutator simple", async () => {
       expect(mutation.data).toEqual({ id, label: "new label", count: 100 });
 
       const query2 = await em.repository(items).findId(id);
-      expect(query2.result.length).toBe(0);
+      expect(query2.data).toBeUndefined();
    });
 
    test("validation: insert incomplete row", async () => {
@@ -177,13 +178,13 @@ describe("Mutator simple", async () => {
    });
 
    test("insertMany", async () => {
-      const oldCount = (await em.repo(items).count()).count;
+      const oldCount = (await em.repo(items).count()).data.count;
       const inserts = [{ label: "insert 1" }, { label: "insert 2" }];
       const { data } = await em.mutator(items).insertMany(inserts);
 
       expect(data.length).toBe(2);
       expect(data.map((d) => ({ label: d.label }))).toEqual(inserts);
-      const newCount = (await em.repo(items).count()).count;
+      const newCount = (await em.repo(items).count()).data.count;
       expect(newCount).toBe(oldCount + inserts.length);
 
       const { data: data2 } = await em.repo(items).findMany({ offset: oldCount });

app/__test__/data/polymorphic.test.ts

@@ -1,6 +1,8 @@
 import { afterAll, expect as bunExpect, describe, test } from "bun:test";
-import { stripMark } from "../../src/core/utils";
-import { Entity, EntityManager, PolymorphicRelation, TextField } from "../../src/data";
+import { stripMark } from "core/utils/schema";
+import { Entity, EntityManager } from "data/entities";
+import { TextField } from "data/fields";
+import { PolymorphicRelation } from "data/relations";
 import { getDummyConnection } from "./helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();

app/__test__/data/prototype.test.ts

@@ -2,19 +2,20 @@ import { describe, expect, test } from "bun:test";
 import {
    BooleanField,
    DateField,
-   Entity,
-   EntityIndex,
-   EntityManager,
    EnumField,
    JsonField,
+   NumberField,
+   TextField,
+   EntityIndex,
+} from "data/fields";
+import { Entity, EntityManager } from "data/entities";
+import {
    ManyToManyRelation,
    ManyToOneRelation,
-   NumberField,
    OneToOneRelation,
    PolymorphicRelation,
-   TextField,
-} from "../../src/data";
-import { DummyConnection } from "../../src/data/connection/DummyConnection";
+} from "data/relations";
+import { DummyConnection } from "data/connection/DummyConnection";
 import {
    FieldPrototype,
    type FieldSchema,
@@ -32,8 +33,8 @@ import {
    number,
    relation,
    text,
-} from "../../src/data/prototype";
-import { MediaField } from "../../src/media/MediaField";
+} from "data/prototype";
+import { MediaField } from "media/MediaField";
 
 describe("prototype", () => {
    test("...", () => {
@@ -101,7 +102,8 @@ describe("prototype", () => {
 
       type Posts = Schema<typeof posts2>;
 
-      expect(posts1.toJSON()).toEqual(posts2.toJSON());
+      // @todo: check
+      //expect(posts1.toJSON()).toEqual(posts2.toJSON());
    });
 
    test("test example", async () => {
@@ -295,9 +297,9 @@ describe("prototype", () => {
          new Entity("posts", [new TextField("name"), new TextField("slug", { required: true })]),
          new Entity("comments", [new TextField("some")]),
          new Entity("users", [new TextField("email")]),
-      ];
+      ] as const;
       const _em2 = new EntityManager(
-         es,
+         [...es],
          new DummyConnection(),
          [new ManyToOneRelation(es[0], es[1]), new ManyToOneRelation(es[0], es[2])],
          [

app/__test__/data/relations.test.ts

@@ -1,13 +1,14 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager, TextField } from "../../src/data";
+import { Entity, EntityManager } from "data/entities";
+import { TextField } from "data/fields";
 import {
    ManyToManyRelation,
    ManyToOneRelation,
    OneToOneRelation,
    PolymorphicRelation,
    RelationField,
-} from "../../src/data/relations";
+} from "data/relations";
 import { getDummyConnection } from "./helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -77,7 +78,7 @@ describe("Relations", async () => {
       const em = new EntityManager(entities, dummyConnection, relations);
 
       // verify naming
-      const rel = em.relations.all[0];
+      const rel = em.relations.all[0]!;
       expect(rel.source.entity.name).toBe(posts.name);
       expect(rel.source.reference).toBe(posts.name);
       expect(rel.target.entity.name).toBe(users.name);
@@ -89,11 +90,11 @@ describe("Relations", async () => {
       // verify low level relation
       expect(em.relationsOf(users.name).length).toBe(1);
       expect(em.relationsOf(users.name).length).toBe(1);
-      expect(em.relationsOf(users.name)[0].source.entity).toBe(posts);
+      expect(em.relationsOf(users.name)[0]!.source.entity).toBe(posts);
       expect(posts.field("author_id")).toBeInstanceOf(RelationField);
       expect(em.relationsOf(users.name).length).toBe(1);
       expect(em.relationsOf(users.name).length).toBe(1);
-      expect(em.relationsOf(users.name)[0].source.entity).toBe(posts);
+      expect(em.relationsOf(users.name)[0]!.source.entity).toBe(posts);
 
       // verify high level relation (from users)
       const userPostsRel = em.relationOf(users.name, "posts");
@@ -191,7 +192,7 @@ describe("Relations", async () => {
       const em = new EntityManager(entities, dummyConnection, relations);
 
       // verify naming
-      const rel = em.relations.all[0];
+      const rel = em.relations.all[0]!;
       expect(rel.source.entity.name).toBe(users.name);
       expect(rel.source.reference).toBe(users.name);
       expect(rel.target.entity.name).toBe(settings.name);
@@ -202,8 +203,8 @@ describe("Relations", async () => {
 
       expect(em.relationsOf(users.name).length).toBe(1);
       expect(em.relationsOf(users.name).length).toBe(1);
-      expect(em.relationsOf(users.name)[0].source.entity).toBe(users);
-      expect(em.relationsOf(users.name)[0].target.entity).toBe(settings);
+      expect(em.relationsOf(users.name)[0]!.source.entity).toBe(users);
+      expect(em.relationsOf(users.name)[0]!.target.entity).toBe(settings);
 
       // verify high level relation (from users)
       const userSettingRel = em.relationOf(users.name, settings.name);
@@ -323,7 +324,7 @@ describe("Relations", async () => {
       );
 
       // mutation info
-      expect(relations[0].helper(posts.name)!.getMutationInfo()).toEqual({
+      expect(relations[0]!.helper(posts.name)!.getMutationInfo()).toEqual({
          reference: "categories",
          local_field: undefined,
          $set: false,
@@ -334,7 +335,7 @@ describe("Relations", async () => {
          cardinality: undefined,
          relation_type: "m:n",
       });
-      expect(relations[0].helper(categories.name)!.getMutationInfo()).toEqual({
+      expect(relations[0]!.helper(categories.name)!.getMutationInfo()).toEqual({
          reference: "posts",
          local_field: undefined,
          $set: false,

app/__test__/data/specs/Entity.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { Entity, NumberField, TextField } from "../../../src/data";
+import { Entity } from "data/entities";
+import { NumberField, TextField } from "data/fields";
 
 describe("[data] Entity", async () => {
    const entity = new Entity("test", [
@@ -46,15 +47,4 @@ describe("[data] Entity", async () => {
       entity.addField(field);
       expect(entity.getField("new_field")).toBe(field);
    });
-
-   // @todo: move this to ClientApp
-   /*test("serialize and deserialize", async () => {
-      const json = entity.toJSON();
-      //sconsole.log("json", json.fields);
-      const newEntity = Entity.deserialize(json);
-      //console.log("newEntity", newEntity.toJSON().fields);
-      expect(newEntity).toBeInstanceOf(Entity);
-      expect(json).toEqual(newEntity.toJSON());
-      expect(json.fields).toEqual(newEntity.toJSON().fields);
-   });*/
 });

app/__test__/data/specs/EntityManager.spec.ts

@@ -1,12 +1,8 @@
 import { afterAll, describe, expect, test } from "bun:test";
-import {
-   Entity,
-   EntityManager,
-   ManyToManyRelation,
-   ManyToOneRelation,
-   SchemaManager,
-} from "../../../src/data";
-import { UnableToConnectException } from "../../../src/data/errors";
+import { Entity, EntityManager } from "data/entities";
+import { ManyToManyRelation, ManyToOneRelation } from "data/relations";
+import { SchemaManager } from "data/schema/SchemaManager";
+import { UnableToConnectException } from "data/errors";
 import { getDummyConnection } from "../helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -47,8 +43,8 @@ describe("[data] EntityManager", async () => {
       em.addRelation(new ManyToOneRelation(posts, users));
       expect(em.relations.all.length).toBe(1);
       expect(em.relations.all[0]).toBeInstanceOf(ManyToOneRelation);
-      expect(em.relationsOf("users")).toEqual([em.relations.all[0]]);
-      expect(em.relationsOf("posts")).toEqual([em.relations.all[0]]);
+      expect(em.relationsOf("users")).toEqual([em.relations.all[0]!]);
+      expect(em.relationsOf("posts")).toEqual([em.relations.all[0]!]);
       expect(em.hasRelations("users")).toBe(true);
       expect(em.hasRelations("posts")).toBe(true);
       expect(em.relatedEntitiesOf("users")).toEqual([posts]);

app/__test__/data/specs/JoinBuilder.spec.ts

@@ -1,10 +1,15 @@
-import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager, ManyToOneRelation, TextField } from "../../../src/data";
-import { JoinBuilder } from "../../../src/data/entities/query/JoinBuilder";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { Entity, EntityManager } from "data/entities";
+import { ManyToOneRelation } from "data/relations";
+import { TextField } from "data/fields";
+import { JoinBuilder } from "data/entities/query/JoinBuilder";
 import { getDummyConnection } from "../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
-afterAll(afterAllCleanup);
+afterAll(async () => (await afterAllCleanup()) && enableConsoleLog());
 
 describe("[data] JoinBuilder", async () => {
    test("missing relation", async () => {

app/__test__/data/specs/Mutator.spec.ts

@@ -1,22 +1,24 @@
-import { afterAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { EventManager } from "../../../src/core/events";
+import { Entity, EntityManager } from "data/entities";
 import {
-   Entity,
-   EntityManager,
    ManyToOneRelation,
-   MutatorEvents,
-   NumberField,
    OneToOneRelation,
-   type RelationField,
+   RelationField,
    RelationMutator,
-   TextField,
-} from "../../../src/data";
-import * as proto from "../../../src/data/prototype";
-import { getDummyConnection } from "../helper";
+} from "data/relations";
+import { NumberField, TextField } from "data/fields";
+import * as proto from "data/prototype";
+import { getDummyConnection } from "../../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+import { MutatorEvents } from "data/events";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
 afterAll(afterAllCleanup);
 
+beforeAll(() => disableConsoleLog());
+afterAll(async () => (await afterAllCleanup()) && enableConsoleLog());
+
 describe("[data] Mutator (base)", async () => {
    const entity = new Entity("items", [
       new TextField("label", { required: true }),
@@ -288,14 +290,17 @@ describe("[data] Mutator (Events)", async () => {
 
    test("events were fired", async () => {
       const { data } = await mutator.insertOne({ label: "test" });
+      await mutator.emgr.executeAsyncs();
       expect(events.has(MutatorEvents.MutatorInsertBefore.slug)).toBeTrue();
       expect(events.has(MutatorEvents.MutatorInsertAfter.slug)).toBeTrue();
 
       await mutator.updateOne(data.id, { label: "test2" });
+      await mutator.emgr.executeAsyncs();
       expect(events.has(MutatorEvents.MutatorUpdateBefore.slug)).toBeTrue();
       expect(events.has(MutatorEvents.MutatorUpdateAfter.slug)).toBeTrue();
 
       await mutator.deleteOne(data.id);
+      await mutator.emgr.executeAsyncs();
       expect(events.has(MutatorEvents.MutatorDeleteBefore.slug)).toBeTrue();
       expect(events.has(MutatorEvents.MutatorDeleteAfter.slug)).toBeTrue();
    });

app/__test__/data/specs/Repository.spec.ts

@@ -1,20 +1,18 @@
-import { afterAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { Kysely, Transaction } from "kysely";
-import { Perf } from "../../../src/core/utils";
-import {
-   Entity,
-   EntityManager,
-   LibsqlConnection,
-   ManyToOneRelation,
-   RepositoryEvents,
-   TextField,
-} from "../../../src/data";
+import { TextField } from "data/fields";
+import { em as $em, entity as $entity, text as $text } from "data/prototype";
+import { Entity, EntityManager } from "data/entities";
+import { ManyToOneRelation } from "data/relations";
+import { RepositoryEvents } from "data/events";
 import { getDummyConnection } from "../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
 
 type E = Kysely<any> | Transaction<any>;
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
-afterAll(afterAllCleanup);
+beforeAll(() => disableConsoleLog());
+afterAll(async () => (await afterAllCleanup()) && enableConsoleLog());
 
 async function sleep(ms: number) {
    return new Promise((resolve) => {
@@ -23,120 +21,6 @@ async function sleep(ms: number) {
 }
 
 describe("[Repository]", async () => {
-   test.skip("bulk", async () => {
-      //const connection = dummyConnection;
-      //const connection = getLocalLibsqlConnection();
-      const credentials = null as any; // @todo: determine what to do here
-      const connection = new LibsqlConnection(credentials);
-
-      const em = new EntityManager([], connection);
-      /*const emLibsql = new EntityManager([], {
-         url: connection.url.replace("https", "libsql"),
-         authToken: connection.authToken,
-      });*/
-      const table = "posts";
-
-      const client = connection.getClient();
-      if (!client) {
-         console.log("Cannot perform test without libsql connection");
-         return;
-      }
-
-      const conn = em.connection.kysely;
-      const selectQ = (e: E) => e.selectFrom(table).selectAll().limit(2);
-      const countQ = (e: E) => e.selectFrom(table).select(e.fn.count("*").as("count"));
-
-      async function executeTransaction(em: EntityManager<any>) {
-         return await em.connection.kysely.transaction().execute(async (e) => {
-            const res = await selectQ(e).execute();
-            const count = await countQ(e).execute();
-
-            return [res, count];
-         });
-      }
-
-      async function executeBatch(em: EntityManager<any>) {
-         const queries = [selectQ(conn), countQ(conn)];
-         return await em.connection.batchQuery(queries);
-      }
-
-      async function executeSingleKysely(em: EntityManager<any>) {
-         const res = await selectQ(conn).execute();
-         const count = await countQ(conn).execute();
-         return [res, count];
-      }
-
-      async function executeSingleClient(em: EntityManager<any>) {
-         const q1 = selectQ(conn).compile();
-         const res = await client.execute({
-            sql: q1.sql,
-            args: q1.parameters as any,
-         });
-
-         const q2 = countQ(conn).compile();
-         const count = await client.execute({
-            sql: q2.sql,
-            args: q2.parameters as any,
-         });
-         return [res, count];
-      }
-
-      const transaction = await executeTransaction(em);
-      const batch = await executeBatch(em);
-
-      expect(batch).toEqual(transaction as any);
-
-      const testperf = false;
-      if (testperf) {
-         const times = 5;
-
-         const exec = async (
-            name: string,
-            fn: (em: EntityManager<any>) => Promise<any>,
-            em: EntityManager<any>,
-         ) => {
-            const res = await Perf.execute(() => fn(em), times);
-            await sleep(1000);
-            const info = {
-               name,
-               total: res.total.toFixed(2),
-               avg: (res.total / times).toFixed(2),
-               first: res.marks[0].time.toFixed(2),
-               last: res.marks[res.marks.length - 1].time.toFixed(2),
-            };
-            console.log(info.name, info, res.marks);
-            return info;
-         };
-
-         const data: any[] = [];
-         data.push(await exec("transaction.http", executeTransaction, em));
-         data.push(await exec("bulk.http", executeBatch, em));
-         data.push(await exec("singleKy.http", executeSingleKysely, em));
-         data.push(await exec("singleCl.http", executeSingleClient, em));
-
-         /*data.push(await exec("transaction.libsql", executeTransaction, emLibsql));
-         data.push(await exec("bulk.libsql", executeBatch, emLibsql));
-         data.push(await exec("singleKy.libsql", executeSingleKysely, emLibsql));
-         data.push(await exec("singleCl.libsql", executeSingleClient, emLibsql));*/
-
-         console.table(data);
-         /**
-          * ┌───┬────────────────────┬────────┬────────┬────────┬────────┐
-          * │   │ name               │ total  │ avg    │ first  │ last   │
-          * ├───┼────────────────────┼────────┼────────┼────────┼────────┤
-          * │ 0 │ transaction.http   │ 681.29 │ 136.26 │ 136.46 │ 396.09 │
-          * │ 1 │ bulk.http          │ 164.82 │ 32.96  │ 32.95  │ 99.91  │
-          * │ 2 │ singleKy.http      │ 330.01 │ 66.00  │ 65.86  │ 195.41 │
-          * │ 3 │ singleCl.http      │ 326.17 │ 65.23  │ 61.32  │ 198.08 │
-          * │ 4 │ transaction.libsql │ 856.79 │ 171.36 │ 132.31 │ 595.24 │
-          * │ 5 │ bulk.libsql        │ 180.63 │ 36.13  │ 35.39  │ 107.71 │
-          * │ 6 │ singleKy.libsql    │ 347.11 │ 69.42  │ 65.00  │ 207.14 │
-          * │ 7 │ singleCl.libsql    │ 328.60 │ 65.72  │ 62.19  │ 195.04 │
-          * └───┴────────────────────┴────────┴────────┴────────┴────────┘
-          */
-      }
-   });
-
    test("count & exists", async () => {
       const items = new Entity("items", [new TextField("label")]);
       const em = new EntityManager([items], dummyConnection);
@@ -157,25 +41,88 @@ describe("[Repository]", async () => {
       // count all
       const res = await em.repository(items).count();
       expect(res.sql).toBe('select count(*) as "count" from "items"');
-      expect(res.count).toBe(3);
+      expect(res.data.count).toBe(3);
+
+      //
+      {
+         const res = await em.repository(items).findMany();
+         expect(res.count).toBe(3);
+      }
+
+      {
+         const res = await em
+            .repository(items, {
+               includeCounts: true,
+            })
+            .findMany();
+         expect(res.count).toBe(3);
+      }
 
       // count filtered
-      const res2 = await em.repository(items).count({ label: { $in: ["a", "b"] } });
+      const res2 = await em
+         .repository(items, {
+            includeCounts: true,
+         })
+         .count({ label: { $in: ["a", "b"] } });
 
       expect(res2.sql).toBe('select count(*) as "count" from "items" where "label" in (?, ?)');
       expect(res2.parameters).toEqual(["a", "b"]);
-      expect(res2.count).toBe(2);
+      expect(res2.data.count).toBe(2);
 
       // check exists
       const res3 = await em.repository(items).exists({ label: "a" });
-      expect(res3.exists).toBe(true);
+      expect(res3.data.exists).toBe(true);
 
       const res4 = await em.repository(items).exists({ label: "d" });
-      expect(res4.exists).toBe(false);
+      expect(res4.data.exists).toBe(false);
 
       // for now, allow empty filter
       const res5 = await em.repository(items).exists({});
-      expect(res5.exists).toBe(true);
+      expect(res5.data.exists).toBe(true);
+   });
+
+   test("option: silent", async () => {
+      const em = $em({
+         items: $entity("items", {
+            label: $text(),
+         }),
+      }).proto.withConnection(getDummyConnection().dummyConnection);
+
+      // should throw because table doesn't exist
+      expect(em.repo("items").findMany({})).rejects.toThrow(/no such table/);
+      // should silently return empty result
+      em.repo("items", { silent: true })
+         .findMany({})
+         .then((r) => r.data);
+      expect(
+         em
+            .repo("items", { silent: true })
+            .findMany({})
+            .then((r) => r.data),
+      ).resolves.toEqual([]);
+   });
+
+   test("option: includeCounts", async () => {
+      const em = $em({
+         items: $entity("items", {
+            label: $text(),
+         }),
+      }).proto.withConnection(getDummyConnection().dummyConnection);
+      await em.schema().sync({ force: true });
+
+      expect(
+         em
+            .repo("items", { includeCounts: true })
+            .findMany({})
+            .then((r) => [r.count, r.total]),
+      ).resolves.toEqual([0, 0]);
+
+      expect(
+         em
+            .repo("items", { includeCounts: false })
+            .findMany({})
+            .then((r) => [r.count, r.total]),
+      ).resolves.toEqual([undefined, undefined]);
    });
 });
 
@@ -198,24 +145,36 @@ describe("[data] Repository (Events)", async () => {
    });
 
    test("events were fired", async () => {
-      await em.repository(items).findId(1);
+      const repo = em.repository(items);
+      await repo.findId(1);
+      await repo.emgr.executeAsyncs();
       expect(events.has(RepositoryEvents.RepositoryFindOneBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindOneAfter.slug)).toBeTrue();
       events.clear();
 
-      await em.repository(items).findOne({ id: 1 });
+      await repo.findOne({ id: 1 });
+      await repo.emgr.executeAsyncs();
       expect(events.has(RepositoryEvents.RepositoryFindOneBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindOneAfter.slug)).toBeTrue();
       events.clear();
 
-      await em.repository(items).findMany({ where: { id: 1 } });
+      await repo.findMany({ where: { id: 1 } });
+      await repo.emgr.executeAsyncs();
       expect(events.has(RepositoryEvents.RepositoryFindManyBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindManyAfter.slug)).toBeTrue();
       events.clear();
 
-      await em.repository(items).findManyByReference(1, "categories");
+      await repo.findManyByReference(1, "categories");
+      await repo.emgr.executeAsyncs();
       expect(events.has(RepositoryEvents.RepositoryFindManyBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindManyAfter.slug)).toBeTrue();
       events.clear();
+
+      // check find one on findMany with limit 1
+      await repo.findMany({ where: { id: 1 }, limit: 1 });
+      await repo.emgr.executeAsyncs();
+      expect(events.has(RepositoryEvents.RepositoryFindOneBefore.slug)).toBeTrue();
+      expect(events.has(RepositoryEvents.RepositoryFindOneAfter.slug)).toBeTrue();
+      events.clear();
    });
 });

app/__test__/data/specs/SchemaManager.spec.ts

@@ -1,7 +1,9 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import { randomString } from "../../../src/core/utils";
-import { Entity, EntityIndex, EntityManager, SchemaManager, TextField } from "../../../src/data";
+import { randomString } from "core/utils";
+import { Entity, EntityManager } from "data/entities";
+import { TextField, EntityIndex } from "data/fields";
+import { SchemaManager } from "data/schema/SchemaManager";
 import { getDummyConnection } from "../helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();

app/__test__/data/specs/WhereBuilder.spec.ts

@@ -1,25 +1,18 @@
-import { describe, expect, test } from "bun:test";
-import { Value, _jsonp } from "../../src/core/utils";
-import { type RepoQuery, WhereBuilder, type WhereQuery, querySchema } from "../../src/data";
-import type { RepoQueryIn } from "../../src/data/server/data-query-impl";
-import { getDummyConnection } from "./helper";
+import { describe, test, expect } from "bun:test";
+import { getDummyConnection } from "../helper";
+import { WhereBuilder, type WhereQuery } from "data/entities/query/WhereBuilder";
 
-const decode = (input: RepoQueryIn, expected: RepoQuery) => {
-   const result = Value.Decode(querySchema, input);
-   expect(result).toEqual(expected);
-};
-
-describe("data-query-impl", () => {
-   function qb() {
-      const c = getDummyConnection();
-      const kysely = c.dummyConnection.kysely;
-      return kysely.selectFrom("t").selectAll();
-   }
-   function compile(q: WhereQuery) {
-      const { sql, parameters } = WhereBuilder.addClause(qb(), q).compile();
-      return { sql, parameters };
-   }
+function qb() {
+   const c = getDummyConnection();
+   const kysely = c.dummyConnection.kysely;
+   return kysely.selectFrom("t").selectAll();
+}
+function compile(q: WhereQuery) {
+   const { sql, parameters } = WhereBuilder.addClause(qb(), q).compile();
+   return { sql, parameters };
+}
 
+describe("WhereBuilder", () => {
    test("single validation", () => {
       const tests: [WhereQuery, string, any[]][] = [
          [{ name: "Michael", age: 40 }, '("name" = ? and "age" = ?)', ["Michael", 40]],
@@ -94,64 +87,4 @@ describe("data-query-impl", () => {
          expect(keys).toEqual(expectedKeys);
       }
    });
-
-   test("with", () => {
-      decode({ with: ["posts"] }, { with: { posts: {} } });
-      decode({ with: { posts: {} } }, { with: { posts: {} } });
-      decode({ with: { posts: { limit: 1 } } }, { with: { posts: { limit: 1 } } });
-      decode(
-         {
-            with: {
-               posts: {
-                  with: {
-                     images: {
-                        select: ["id"],
-                     },
-                  },
-               },
-            },
-         },
-         {
-            with: {
-               posts: {
-                  with: {
-                     images: {
-                        select: ["id"],
-                     },
-                  },
-               },
-            },
-         },
-      );
-
-      // over http
-      {
-         const output = { with: { images: {} } };
-         decode({ with: "images" }, output);
-         decode({ with: '["images"]' }, output);
-         decode({ with: ["images"] }, output);
-         decode({ with: { images: {} } }, output);
-      }
-
-      {
-         const output = { with: { images: {}, comments: {} } };
-         decode({ with: "images,comments" }, output);
-         decode({ with: ["images", "comments"] }, output);
-         decode({ with: '["images", "comments"]' }, output);
-         decode({ with: { images: {}, comments: {} } }, output);
-      }
-   });
-});
-
-describe("data-query-impl: Typebox", () => {
-   test("sort", async () => {
-      const _dflt = { sort: { by: "id", dir: "asc" } };
-
-      decode({ sort: "" }, _dflt);
-      decode({ sort: "name" }, { sort: { by: "name", dir: "asc" } });
-      decode({ sort: "-name" }, { sort: { by: "name", dir: "desc" } });
-      decode({ sort: "-posts.name" }, { sort: { by: "posts.name", dir: "desc" } });
-      decode({ sort: "-1name" }, _dflt);
-      decode({ sort: { by: "name", dir: "desc" } }, { sort: { by: "name", dir: "desc" } });
-   });
 });

app/__test__/data/specs/WithBuilder.spec.ts

@@ -1,16 +1,15 @@
-import { describe, expect, test } from "bun:test";
-import {
-   Entity,
-   EntityManager,
-   ManyToManyRelation,
-   ManyToOneRelation,
-   PolymorphicRelation,
-   TextField,
-   WithBuilder,
-} from "../../../src/data";
-import * as proto from "../../../src/data/prototype";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { Entity, EntityManager } from "data/entities";
+import { ManyToManyRelation, ManyToOneRelation, PolymorphicRelation } from "data/relations";
+import { TextField } from "data/fields";
+import * as proto from "data/prototype";
+import { WithBuilder } from "data/entities/query/WithBuilder";
 import { schemaToEm } from "../../helper";
 import { getDummyConnection } from "../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
 
 const { dummyConnection } = getDummyConnection();
 
@@ -89,9 +88,9 @@ describe("[data] WithBuilder", async () => {
       const res2 = qb2.compile();
 
       expect(res2.sql).toBe(
-         'select (select json_object(\'id\', "obj"."id", \'username\', "obj"."username") from (select "users"."id" as "id", "users"."username" as "username" from "users" as "author" where "author"."id" = "posts"."author_id" order by "users"."id" asc limit ? offset ?) as obj) as "author" from "posts"',
+         'select (select json_object(\'id\', "obj"."id", \'username\', "obj"."username") from (select "users"."id" as "id", "users"."username" as "username" from "users" as "author" where "author"."id" = "posts"."author_id" order by "users"."id" asc limit ?) as obj) as "author" from "posts"',
       );
-      expect(res2.parameters).toEqual([1, 0]);
+      expect(res2.parameters).toEqual([1]);
    });
 
    test("test with empty join", async () => {
@@ -194,9 +193,9 @@ describe("[data] WithBuilder", async () => {
       );
       const res = qb.compile();
       expect(res.sql).toBe(
-         'select (select json_object(\'id\', "obj"."id", \'path\', "obj"."path") from (select "media"."id" as "id", "media"."path" as "path" from "media" where "media"."reference" = ? and "categories"."id" = "media"."entity_id" order by "media"."id" asc limit ? offset ?) as obj) as "single" from "categories"',
+         'select (select json_object(\'id\', "obj"."id", \'path\', "obj"."path") from (select "media"."id" as "id", "media"."path" as "path" from "media" where "media"."reference" = ? and "categories"."id" = "media"."entity_id" order by "media"."id" asc limit ?) as obj) as "single" from "categories"',
       );
-      expect(res.parameters).toEqual(["categories.single", 1, 0]);
+      expect(res.parameters).toEqual(["categories.single", 1]);
 
       const qb2 = WithBuilder.addClause(
          em,
@@ -273,9 +272,9 @@ describe("[data] WithBuilder", async () => {
 
          //prettyPrintQb(qb);
          expect(qb.compile().sql).toBe(
-            'select (select json_object(\'id\', "obj"."id", \'username\', "obj"."username", \'avatar\', "obj"."avatar") from (select "users"."id" as "id", "users"."username" as "username", (select json_object(\'id\', "obj"."id", \'path\', "obj"."path") from (select "media"."id" as "id", "media"."path" as "path" from "media" where "media"."reference" = ? and "users"."id" = "media"."entity_id" order by "media"."id" asc limit ? offset ?) as obj) as "avatar" from "users" as "users" where "users"."id" = "posts"."users_id" order by "users"."username" asc limit ? offset ?) as obj) as "users" from "posts"',
+            'select (select json_object(\'id\', "obj"."id", \'username\', "obj"."username", \'avatar\', "obj"."avatar") from (select "users"."id" as "id", "users"."username" as "username", (select json_object(\'id\', "obj"."id", \'path\', "obj"."path") from (select "media"."id" as "id", "media"."path" as "path" from "media" where "media"."reference" = ? and "users"."id" = "media"."entity_id" order by "media"."id" asc limit ?) as obj) as "avatar" from "users" as "users" where "users"."id" = "posts"."users_id" order by "users"."username" asc limit ?) as obj) as "users" from "posts"',
          );
-         expect(qb.compile().parameters).toEqual(["users.avatar", 1, 0, 1, 0]);
+         expect(qb.compile().parameters).toEqual(["users.avatar", 1, 1]);
       });
 
       test("compiles with many", async () => {
@@ -315,9 +314,9 @@ describe("[data] WithBuilder", async () => {
          );
 
          expect(qb.compile().sql).toBe(
-            'select (select coalesce(json_group_array(json_object(\'id\', "agg"."id", \'posts_id\', "agg"."posts_id", \'users_id\', "agg"."users_id", \'users\', "agg"."users")), \'[]\') from (select "comments"."id" as "id", "comments"."posts_id" as "posts_id", "comments"."users_id" as "users_id", (select json_object(\'username\', "obj"."username") from (select "users"."username" as "username" from "users" as "users" where "users"."id" = "comments"."users_id" order by "users"."id" asc limit ? offset ?) as obj) as "users" from "comments" as "comments" where "comments"."posts_id" = "posts"."id" order by "comments"."id" asc limit ? offset ?) as agg) as "comments" from "posts"',
+            'select (select coalesce(json_group_array(json_object(\'id\', "agg"."id", \'posts_id\', "agg"."posts_id", \'users_id\', "agg"."users_id", \'users\', "agg"."users")), \'[]\') from (select "comments"."id" as "id", "comments"."posts_id" as "posts_id", "comments"."users_id" as "users_id", (select json_object(\'username\', "obj"."username") from (select "users"."username" as "username" from "users" as "users" where "users"."id" = "comments"."users_id" order by "users"."id" asc limit ?) as obj) as "users" from "comments" as "comments" where "comments"."posts_id" = "posts"."id" order by "comments"."id" asc limit ? offset ?) as agg) as "comments" from "posts"',
          );
-         expect(qb.compile().parameters).toEqual([1, 0, 12, 0]);
+         expect(qb.compile().parameters).toEqual([1, 12, 0]);
       });
 
       test("returns correct result", async () => {

app/__test__/data/specs/connection/Connection.spec.ts

@@ -1,5 +1,5 @@
 import { afterAll, describe, expect, test } from "bun:test";
-import { EntityManager } from "../../../../src/data";
+import { EntityManager } from "data/entities/EntityManager";
 import { getDummyConnection } from "../../helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();

app/__test__/data/specs/fields/BooleanField.spec.ts

@@ -1,9 +1,10 @@
+import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { BooleanField } from "../../../../src/data";
-import { runBaseFieldTests, transformPersist } from "./inc";
+import { BooleanField } from "data/fields";
+import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
 
 describe("[data] BooleanField", async () => {
-   runBaseFieldTests(BooleanField, { defaultValue: true, schemaType: "boolean" });
+   fieldTestSuite(bunTestRunner, BooleanField, { defaultValue: true, schemaType: "boolean" });
 
    test("transformRetrieve", async () => {
       const field = new BooleanField("test");

app/__test__/data/specs/fields/DateField.spec.ts

@@ -1,9 +1,15 @@
-import { describe, expect, test } from "bun:test";
-import { DateField } from "../../../../src/data";
-import { runBaseFieldTests } from "./inc";
+import { describe, test } from "bun:test";
+import { DateField } from "data/fields";
+import { fieldTestSuite } from "data/fields/field-test-suite";
+import { bunTestRunner } from "adapter/bun/test";
 
 describe("[data] DateField", async () => {
-   runBaseFieldTests(DateField, { defaultValue: new Date(), schemaType: "date" });
+   fieldTestSuite(
+      bunTestRunner,
+      DateField,
+      { defaultValue: new Date(), schemaType: "date" },
+      { type: "date" },
+   );
 
    // @todo: add datefield tests
    test("week", async () => {

app/__test__/data/specs/fields/EnumField.spec.ts

@@ -1,13 +1,16 @@
+import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { EnumField } from "../../../../src/data";
-import { runBaseFieldTests, transformPersist } from "./inc";
+import { EnumField } from "data/fields";
+import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
 
 function options(strings: string[]) {
    return { type: "strings", values: strings };
 }
 
 describe("[data] EnumField", async () => {
-   runBaseFieldTests(
+   fieldTestSuite(
+      bunTestRunner,
+      // @ts-ignore
       EnumField,
       { defaultValue: "a", schemaType: "text" },
       { options: options(["a", "b", "c"]) },
@@ -15,11 +18,13 @@ describe("[data] EnumField", async () => {
 
    test("yields if default value is not a valid option", async () => {
       expect(
+         // @ts-ignore
          () => new EnumField("test", { options: options(["a", "b"]), default_value: "c" }),
       ).toThrow();
    });
 
    test("transformPersist (config)", async () => {
+      // @ts-ignore
       const field = new EnumField("test", { options: options(["a", "b", "c"]) });
 
       expect(transformPersist(field, null)).resolves.toBeUndefined();
@@ -29,6 +34,7 @@ describe("[data] EnumField", async () => {
 
    test("transformRetrieve", async () => {
       const field = new EnumField("test", {
+         // @ts-ignore
          options: options(["a", "b", "c"]),
          default_value: "a",
          required: true,

app/__test__/data/specs/fields/Field.spec.ts

@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test";
-import { Default, stripMark } from "../../../../src/core/utils";
 import { baseFieldConfigSchema, Field } from "../../../../src/data/fields/Field";
-import { runBaseFieldTests } from "./inc";
+import { fieldTestSuite } from "data/fields/field-test-suite";
+import { bunTestRunner } from "adapter/bun/test";
+import { stripMark } from "core/utils/schema";
 
 describe("[data] Field", async () => {
    class FieldSpec extends Field {
@@ -19,10 +20,10 @@ describe("[data] Field", async () => {
       });
    });
 
-   runBaseFieldTests(FieldSpec, { defaultValue: "test", schemaType: "text" });
+   fieldTestSuite(bunTestRunner, FieldSpec, { defaultValue: "test", schemaType: "text" });
 
    test("default config", async () => {
-      const config = Default(baseFieldConfigSchema, {});
+      const config = baseFieldConfigSchema.template({});
       expect(stripMark(new FieldSpec("test").config)).toEqual(config as any);
    });
 

app/__test__/data/specs/fields/FieldIndex.spec.ts

@@ -1,19 +1,14 @@
 import { describe, expect, test } from "bun:test";
-import { Type } from "../../../../src/core/utils";
-import {
-   Entity,
-   EntityIndex,
-   type EntityManager,
-   Field,
-   type SchemaResponse,
-} from "../../../../src/data";
+import { Entity } from "data/entities";
+import { Field, EntityIndex } from "data/fields";
+import { s } from "core/utils/schema";
 
 class TestField extends Field {
    protected getSchema(): any {
-      return Type.Any();
+      return s.any();
    }
 
-   schema(em: EntityManager<any>): SchemaResponse {
+   override schema() {
       return undefined as any;
    }
 }
@@ -28,11 +23,4 @@ describe("FieldIndex", async () => {
       expect(index.name).toEqual("idx_test_name");
       expect(index.unique).toEqual(false);
    });
-
-   test("it fails on non-unique", async () => {
-      const field = new TestField("name", { required: false });
-
-      expect(() => new EntityIndex(entity, [field], true)).toThrowError();
-      expect(() => new EntityIndex(entity, [field])).toBeDefined();
-   });
 });

app/__test__/data/specs/fields/JsonField.spec.ts

@@ -1,10 +1,11 @@
+import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { JsonField } from "../../../../src/data";
-import { runBaseFieldTests, transformPersist } from "./inc";
+import { JsonField } from "data/fields";
+import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
 
 describe("[data] JsonField", async () => {
    const field = new JsonField("test");
-   runBaseFieldTests(JsonField, {
+   fieldTestSuite(bunTestRunner, JsonField, {
       defaultValue: { a: 1 },
       sampleValues: ["string", { test: 1 }, 1],
       schemaType: "text",

app/__test__/data/specs/fields/JsonSchemaField.spec.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
-import { JsonSchemaField } from "../../../../src/data";
-import { runBaseFieldTests } from "./inc";
+import { JsonSchemaField } from "data/fields";
+import { fieldTestSuite } from "data/fields/field-test-suite";
 
 describe("[data] JsonSchemaField", async () => {
-   runBaseFieldTests(JsonSchemaField, { defaultValue: {}, schemaType: "text" });
+   // @ts-ignore
+   fieldTestSuite({ expect, test }, JsonSchemaField, { defaultValue: {}, schemaType: "text" });
 
    // @todo: add JsonSchemaField tests
 });

app/__test__/data/specs/fields/NumberField.spec.ts

@@ -1,6 +1,7 @@
+import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { NumberField } from "../../../../src/data";
-import { runBaseFieldTests, transformPersist } from "./inc";
+import { NumberField } from "data/fields";
+import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
 
 describe("[data] NumberField", async () => {
    test("transformPersist (config)", async () => {
@@ -15,5 +16,5 @@ describe("[data] NumberField", async () => {
       expect(transformPersist(field2, 10000)).resolves.toBe(10000);
    });
 
-   runBaseFieldTests(NumberField, { defaultValue: 12, schemaType: "integer" });
+   fieldTestSuite(bunTestRunner, NumberField, { defaultValue: 12, schemaType: "integer" });
 });

app/__test__/data/specs/fields/PrimaryField.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { PrimaryField } from "../../../../src/data";
+import { PrimaryField } from "data/fields";
 
 describe("[data] PrimaryField", async () => {
    const field = new PrimaryField("primary");
@@ -39,4 +39,28 @@ describe("[data] PrimaryField", async () => {
       expect(field.transformPersist(1)).rejects.toThrow();
       expect(field.transformRetrieve(1)).toBe(1);
    });
+
+   test("format", () => {
+      const uuid = new PrimaryField("uuid", { format: "uuid" });
+      expect(uuid.format).toBe("uuid");
+      expect(uuid.fieldType).toBe("text");
+      expect(uuid.getNewValue()).toBeString();
+      expect(uuid.toType()).toEqual({
+         required: true,
+         comment: undefined,
+         type: "Generated<string>",
+         import: [{ package: "kysely", name: "Generated" }],
+      });
+
+      const integer = new PrimaryField("integer", { format: "integer" });
+      expect(integer.format).toBe("integer");
+      expect(integer.fieldType).toBe("integer");
+      expect(integer.getNewValue()).toBeUndefined();
+      expect(integer.toType()).toEqual({
+         required: true,
+         comment: undefined,
+         type: "Generated<number>",
+         import: [{ package: "kysely", name: "Generated" }],
+      });
+   });
 });

app/__test__/data/specs/fields/TextField.spec.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { TextField } from "../../../../src/data";
-import { runBaseFieldTests, transformPersist } from "./inc";
+import { TextField } from "data/fields";
+import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
+import { bunTestRunner } from "adapter/bun/test";
 
 describe("[data] TextField", async () => {
    test("transformPersist (config)", async () => {
@@ -11,5 +12,5 @@ describe("[data] TextField", async () => {
       expect(transformPersist(field, "abc")).resolves.toBe("abc");
    });
 
-   runBaseFieldTests(TextField, { defaultValue: "abc", schemaType: "text" });
+   fieldTestSuite(bunTestRunner, TextField, { defaultValue: "abc", schemaType: "text" });
 });

app/__test__/data/specs/relations/EntityRelation.spec.ts

@@ -1,11 +1,13 @@
 import { describe, expect, it, test } from "bun:test";
-import { Entity, type EntityManager } from "../../../../src/data";
+import { Entity, type EntityManager } from "data/entities";
 import {
    type BaseRelationConfig,
    EntityRelation,
    EntityRelationAnchor,
+   ManyToManyRelation,
    RelationTypes,
-} from "../../../../src/data/relations";
+} from "data/relations";
+import * as proto from "data/prototype";
 
 class TestEntityRelation extends EntityRelation {
    constructor(config?: BaseRelationConfig) {
@@ -24,11 +26,11 @@ class TestEntityRelation extends EntityRelation {
       return this;
    }
 
-   buildWith(a: any, b: any, c: any): any {
+   buildWith(): any {
       return;
    }
 
-   buildJoin(a: any, b: any): any {
+   buildJoin(): any {
       return;
    }
 }
@@ -75,4 +77,15 @@ describe("[data] EntityRelation", async () => {
       const relation2 = new TestEntityRelation({ required: true });
       expect(relation2.required).toBe(true);
    });
+
+   it("correctly produces the relation name", async () => {
+      const relation = new ManyToManyRelation(new Entity("apps"), new Entity("organizations"));
+      expect(relation.getName()).not.toContain(",");
+      expect(relation.getName()).toBe("mn_apps_organizations");
+
+      const relation2 = new ManyToManyRelation(new Entity("apps"), new Entity("organizations"), {
+         connectionTableMappedName: "appOrganizations",
+      });
+      expect(relation2.getName()).toBe("mn_apps_organizations_appOrganizations");
+   });
 });

app/__test__/debug/jsonv-resolution.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "bun:test";
+import * as sDirect from "jsonv-ts";
+import { s as sFromBknd } from "bknd/utils";
+
+describe("jsonv-ts resolution", () => {
+   it("should resolve to a single instance", () => {
+      const sameNamespace = sDirect === (sFromBknd as unknown as typeof sDirect);
+      // If this fails, two instances are being loaded via different specifiers/paths
+      expect(sameNamespace).toBe(true);
+   });
+
+   it("should resolve specifiers to a single package path", async () => {
+      const base = await import.meta.resolve("jsonv-ts");
+      const hono = await import.meta.resolve("jsonv-ts/hono");
+      const mcp = await import.meta.resolve("jsonv-ts/mcp");
+      expect(typeof base).toBe("string");
+      expect(typeof hono).toBe("string");
+      expect(typeof mcp).toBe("string");
+      // They can be different files (subpath exports), but they should share the same package root
+      const pkgRoot = (p: string) => p.slice(0, p.lastIndexOf("jsonv-ts") + "jsonv-ts".length);
+      expect(pkgRoot(base)).toBe(pkgRoot(hono));
+      expect(pkgRoot(base)).toBe(pkgRoot(mcp));
+   });
+});

app/__test__/flows/FetchTask.spec.ts

@@ -41,7 +41,7 @@ beforeAll(() =>
 );
 afterAll(unmockFetch);
 
-describe("FetchTask", async () => {
+describe.skip("FetchTask", async () => {
    test("Simple fetch", async () => {
       const task = new FetchTask("Fetch Something", {
          url: "https://jsonplaceholder.typicode.com/todos/1",

app/__test__/flows/SubWorkflowTask.spec.ts

@@ -1,7 +1,23 @@
 import { describe, expect, test } from "bun:test";
-import { Flow, LogTask, RenderTask, SubFlowTask } from "../../src/flows";
+import { Flow, LogTask, SubFlowTask, RenderTask, Task } from "../../src/flows";
+import { s } from "core/utils/schema";
 
-describe("SubFlowTask", async () => {
+export class StringifyTask<Output extends string> extends Task<
+   typeof StringifyTask.schema,
+   Output
+> {
+   type = "stringify";
+
+   static override schema = s.object({
+      input: s.string().optional(),
+   });
+
+   async execute() {
+      return JSON.stringify(this.params.input) as Output;
+   }
+}
+
+describe.skip("SubFlowTask", async () => {
    test("Simple Subflow", async () => {
       const subTask = new RenderTask("render", {
          render: "subflow",
@@ -22,8 +38,6 @@ describe("SubFlowTask", async () => {
 
       const execution = flow.createExecution();
       await execution.start();
-      /*console.log(execution.logs);
-      console.log(execution.getResponse());*/
 
       expect(execution.getResponse()).toEqual("Subflow output: subflow");
    });
@@ -40,8 +54,8 @@ describe("SubFlowTask", async () => {
          loop: true,
          input: [1, 2, 3],
       });
-      const task3 = new RenderTask("render2", {
-         render: `Subflow output: {{ sub.output | join: ", " }}`,
+      const task3 = new StringifyTask("stringify", {
+         input: "{{ sub.output }}",
       });
 
       const flow = new Flow("test", [task, task2, task3], []);
@@ -51,41 +65,6 @@ describe("SubFlowTask", async () => {
       const execution = flow.createExecution();
       await execution.start();
 
-      console.log("errors", execution.getErrors());
-
-      /*console.log(execution.logs);
-      console.log(execution.getResponse());*/
-
-      expect(execution.getResponse()).toEqual("Subflow output: run 1, run 2, run 3");
-   });
-
-   test("Simple loop from flow input", async () => {
-      const subTask = new RenderTask("render", {
-         render: "run {{ flow.output }}",
-      });
-
-      const subflow = new Flow("subflow", [subTask]);
-
-      const task = new LogTask("log");
-      const task2 = new SubFlowTask("sub", {
-         flow: subflow,
-         loop: true,
-         input: "{{ flow.output | json }}",
-      });
-      const task3 = new RenderTask("render2", {
-         render: `Subflow output: {{ sub.output | join: ", " }}`,
-      });
-
-      const flow = new Flow("test", [task, task2, task3], []);
-      flow.task(task).asInputFor(task2);
-      flow.task(task2).asInputFor(task3);
-
-      const execution = flow.createExecution();
-      await execution.start([4, 5, 6]);
-
-      /*console.log(execution.logs);
-      console.log(execution.getResponse());*/
-
-      expect(execution.getResponse()).toEqual("Subflow output: run 4, run 5, run 6");
+      expect(execution.getResponse()).toEqual('"run 1,run 2,run 3"');
    });
 });

app/__test__/flows/Task.spec.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { Type } from "../../src/core/utils";
 import { Task } from "../../src/flows";
 import { dynamic } from "../../src/flows/tasks/Task";
+import { s } from "core/utils/schema";
 
-describe("Task", async () => {
+describe.skip("Task", async () => {
    test("resolveParams: template with parse", async () => {
       const result = await Task.resolveParams(
-         Type.Object({ test: dynamic(Type.Number()) }),
+         s.object({ test: dynamic(s.number()) }),
          {
             test: "{{ some.path }}",
          },
@@ -22,7 +22,7 @@ describe("Task", async () => {
 
    test("resolveParams: with string", async () => {
       const result = await Task.resolveParams(
-         Type.Object({ test: Type.String() }),
+         s.object({ test: s.string() }),
          {
             test: "{{ some.path }}",
          },
@@ -38,7 +38,7 @@ describe("Task", async () => {
 
    test("resolveParams: with object", async () => {
       const result = await Task.resolveParams(
-         Type.Object({ test: dynamic(Type.Object({ key: Type.String(), value: Type.String() })) }),
+         s.object({ test: dynamic(s.object({ key: s.string(), value: s.string() })) }),
          {
             test: { key: "path", value: "{{ some.path }}" },
          },
@@ -51,62 +51,4 @@ describe("Task", async () => {
 
       expect(result.test).toEqual({ key: "path", value: "1/1" });
    });
-
-   test("resolveParams: with json", async () => {
-      const result = await Task.resolveParams(
-         Type.Object({
-            test: dynamic(Type.Object({ key: Type.String(), value: Type.String() })),
-         }),
-         {
-            test: "{{ some | json }}",
-         },
-         {
-            some: {
-               key: "path",
-               value: "1/1",
-            },
-         },
-      );
-
-      expect(result.test).toEqual({ key: "path", value: "1/1" });
-   });
-
-   test("resolveParams: with array", async () => {
-      const result = await Task.resolveParams(
-         Type.Object({
-            test: dynamic(Type.Array(Type.String())),
-         }),
-         {
-            test: '{{ "1,2,3" | split: "," | json }}',
-         },
-      );
-
-      expect(result.test).toEqual(["1", "2", "3"]);
-   });
-
-   test("resolveParams: boolean", async () => {
-      const result = await Task.resolveParams(
-         Type.Object({
-            test: dynamic(Type.Boolean()),
-         }),
-         {
-            test: "{{ true }}",
-         },
-      );
-
-      expect(result.test).toEqual(true);
-   });
-
-   test("resolveParams: float", async () => {
-      const result = await Task.resolveParams(
-         Type.Object({
-            test: dynamic(Type.Number(), Number.parseFloat),
-         }),
-         {
-            test: "{{ 3.14 }}",
-         },
-      );
-
-      expect(result.test).toEqual(3.14);
-   });
 });

app/__test__/flows/inputs.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { Hono } from "hono";
 import { Event, EventManager } from "../../src/core/events";
-import { type Static, type StaticDecode, Type, parse } from "../../src/core/utils";
+import { s, parse } from "core/utils/schema";
 import { EventTrigger, Flow, HttpTrigger, type InputsMap, Task } from "../../src/flows";
 import { dynamic } from "../../src/flows/tasks/Task";
 
@@ -14,15 +14,15 @@ class Passthrough extends Task {
    }
 }
 
-type OutputIn = Static<typeof OutputParamTask.schema>;
-type OutputOut = StaticDecode<typeof OutputParamTask.schema>;
+type OutputIn = s.Static<typeof OutputParamTask.schema>;
+type OutputOut = s.StaticCoerced<typeof OutputParamTask.schema>;
 
 class OutputParamTask extends Task<typeof OutputParamTask.schema> {
    type = "output-param";
 
-   static override schema = Type.Object({
+   static override schema = s.strictObject({
       number: dynamic(
-         Type.Number({
+         s.number({
             title: "Output number",
          }),
          Number.parseInt,
@@ -43,7 +43,7 @@ class PassthroughFlowInput extends Task {
    }
 }
 
-describe("Flow task inputs", async () => {
+describe.skip("Flow task inputs", async () => {
    test("types", async () => {
       const schema = OutputParamTask.schema;
 

app/__test__/flows/trigger.test.ts

@@ -30,7 +30,7 @@ class ExecTask extends Task {
    }
 }
 
-describe("Flow trigger", async () => {
+describe.skip("Flow trigger", async () => {
    test("manual trigger", async () => {
       let called = false;
 

app/__test__/flows/workflow-basic.test.ts

@@ -1,7 +1,8 @@
 // eslint-disable-next-line import/no-unresolved
 import { describe, expect, test } from "bun:test";
 import { isEqual } from "lodash-es";
-import { type Static, Type, _jsonp, withDisabledConsole } from "../../src/core/utils";
+import { _jsonp, withDisabledConsole } from "../../src/core/utils";
+import { s } from "core/utils/schema";
 import { Condition, ExecutionEvent, FetchTask, Flow, LogTask, Task } from "../../src/flows";
 
 /*beforeAll(disableConsoleLog);
@@ -10,19 +11,19 @@ afterAll(enableConsoleLog);*/
 class ExecTask extends Task<typeof ExecTask.schema> {
    type = "exec";
 
-   static override schema = Type.Object({
-      delay: Type.Number({ default: 10 }),
+   static override schema = s.object({
+      delay: s.number({ default: 10 }),
    });
 
    constructor(
       name: string,
-      params: Static<typeof ExecTask.schema>,
+      params: s.Static<typeof ExecTask.schema>,
       private func: () => Promise<any>,
    ) {
       super(name, params);
    }
 
-   override clone(name: string, params: Static<typeof ExecTask.schema>) {
+   override clone(name: string, params: s.Static<typeof ExecTask.schema>) {
       return new ExecTask(name, params, this.func);
    }
 
@@ -77,7 +78,7 @@ function getObjectDiff(obj1, obj2) {
    return diff;
 }
 
-describe("Flow tests", async () => {
+describe.skip("Flow tests", async () => {
    test("Simple single task", async () => {
       const simple = getTask(0);
 

app/__test__/helper.ts

@@ -2,11 +2,12 @@ import { unlink } from "node:fs/promises";
 import type { SelectQueryBuilder, SqliteDatabase } from "kysely";
 import Database from "libsql";
 import { format as sqlFormat } from "sql-formatter";
-import { type Connection, EntityManager, SqliteLocalConnection } from "../src/data";
 import type { em as protoEm } from "../src/data/prototype";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { slugify } from "core/utils/strings";
+import { slugify } from "bknd/utils";
+import { type Connection, SqliteLocalConnection } from "data/connection";
+import { EntityManager } from "data/entities/EntityManager";
 
 export function getDummyDatabase(memory: boolean = true): {
    dummyDb: SqliteDatabase;
@@ -38,25 +39,6 @@ export function getLocalLibsqlConnection() {
    return { url: "http://127.0.0.1:8080" };
 }
 
-type ConsoleSeverity = "log" | "warn" | "error";
-const _oldConsoles = {
-   log: console.log,
-   warn: console.warn,
-   error: console.error,
-};
-
-export function disableConsoleLog(severities: ConsoleSeverity[] = ["log", "warn"]) {
-   severities.forEach((severity) => {
-      console[severity] = () => null;
-   });
-}
-
-export function enableConsoleLog() {
-   Object.entries(_oldConsoles).forEach(([severity, fn]) => {
-      console[severity as ConsoleSeverity] = fn;
-   });
-}
-
 export function compileQb(qb: SelectQueryBuilder<any, any, any>) {
    const { sql, parameters } = qb.compile();
    return { sql, parameters };
@@ -64,7 +46,7 @@ export function compileQb(qb: SelectQueryBuilder<any, any, any>) {
 
 export function prettyPrintQb(qb: SelectQueryBuilder<any, any, any>) {
    const { sql, parameters } = qb.compile();
-   console.log("$", sqlFormat(sql), "\n[params]", parameters);
+   console.info("$", sqlFormat(sql), "\n[params]", parameters);
 }
 
 export function schemaToEm(s: ReturnType<typeof protoEm>, conn?: Connection): EntityManager<any> {
@@ -78,6 +60,7 @@ export const assetsTmpPath = `${import.meta.dir}/_assets/tmp`;
 export async function enableFetchLogging() {
    const originalFetch = global.fetch;
 
+   // @ts-ignore
    global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
       const response = await originalFetch(input, init);
       const url = input instanceof URL || typeof input === "string" ? input : input.url;

app/__test__/integration/auth.integration.test.ts

@@ -1,12 +1,9 @@
-import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
-import { App, createApp } from "../../src";
-import type { AuthResponse } from "../../src/auth";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { App, createApp, type AuthResponse } from "../../src";
 import { auth } from "../../src/auth/middlewares";
 import { randomString, secureRandomString, withDisabledConsole } from "../../src/core/utils";
-import { disableConsoleLog, enableConsoleLog, getDummyConnection } from "../helper";
-
-const { dummyConnection, afterAllCleanup } = getDummyConnection();
-afterEach(afterAllCleanup);
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+import { getDummyConnection } from "../helper";
 
 beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
@@ -66,9 +63,10 @@ const configs = {
 };
 
 function createAuthApp() {
+   const { dummyConnection } = getDummyConnection();
    const app = createApp({
       connection: dummyConnection,
-      initialConfig: {
+      config: {
          auth: configs.auth,
       },
    });
@@ -151,8 +149,8 @@ describe("integration auth", () => {
 
       const { data: users } = await app.em.repository("users").findMany();
       expect(users.length).toBe(2);
-      expect(users[0].email).toBe(configs.users.normal.email);
-      expect(users[1].email).toBe(configs.users.admin.email);
+      expect(users[0]?.email).toBe(configs.users.normal.email);
+      expect(users[1]?.email).toBe(configs.users.admin.email);
    });
 
    it("should log you in with API", async () => {
@@ -223,7 +221,7 @@ describe("integration auth", () => {
 
       app.server.get("/get", auth(), async (c) => {
          return c.json({
-            user: c.get("auth").user ?? null,
+            user: c.get("auth")?.user ?? null,
          });
       });
       app.server.get("/wait", auth(), async (c) => {
@@ -242,7 +240,7 @@ describe("integration auth", () => {
       {
          await new Promise((r) => setTimeout(r, 10));
          const res = await app.server.request("/get");
-         const data = await res.json();
+         const data = (await res.json()) as any;
          expect(data.user).toBe(null);
          expect(await $fns.me()).toEqual({ user: null as any });
       }

app/__test__/integration/config.integration.test.ts

@@ -1,6 +1,10 @@
-import { describe, expect, it } from "bun:test";
-import { createApp } from "../../src";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { createApp } from "core/test/utils";
 import { Api } from "../../src/Api";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
 
 describe("integration config", () => {
    it("should create an entity", async () => {
@@ -13,9 +17,8 @@ describe("integration config", () => {
 
       // create entity
       await api.system.addConfig("data", "entities.posts", {
-         name: "posts",
          config: { sort_field: "id", sort_dir: "asc" },
-         fields: { id: { type: "primary", name: "id" }, asdf: { type: "text" } },
+         fields: { id: { type: "primary" }, asdf: { type: "text" } },
          type: "regular",
       });
 

app/__test__/media/MediaController.spec.ts

@@ -1,21 +1,25 @@
 /// <reference types="@types/bun" />
 
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { createApp, registries } from "../../src";
+import { registries } from "../../src";
+import { createApp } from "core/test/utils";
 import { mergeObject, randomString } from "../../src/core/utils";
 import type { TAppMediaConfig } from "../../src/media/media-schema";
-import { StorageLocalAdapter } from "../../src/media/storage/adapters/StorageLocalAdapter";
-import { assetsPath, assetsTmpPath, disableConsoleLog, enableConsoleLog } from "../helper";
+import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { assetsPath, assetsTmpPath } from "../helper";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
 
 beforeAll(() => {
+   //disableConsoleLog();
    registries.media.register("local", StorageLocalAdapter);
 });
+afterAll(enableConsoleLog);
 
 const path = `${assetsPath}/image.png`;
 
 async function makeApp(mediaOverride: Partial<TAppMediaConfig> = {}) {
    const app = createApp({
-      initialConfig: {
+      config: {
          media: mergeObject(
             {
                enabled: true,
@@ -39,11 +43,8 @@ function makeName(ext: string) {
    return randomString(10) + "." + ext;
 }
 
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
 describe("MediaController", () => {
-   test.only("accepts direct", async () => {
+   test("accepts direct", async () => {
       const app = await makeApp();
 
       const file = Bun.file(path);
@@ -53,7 +54,6 @@ describe("MediaController", () => {
          body: file,
       });
       const result = (await res.json()) as any;
-      console.log(result);
       expect(result.name).toBe(name);
 
       const destFile = Bun.file(assetsTmpPath + "/" + name);
@@ -94,4 +94,38 @@ describe("MediaController", () => {
       expect(res.status).toBe(413);
       expect(await Bun.file(assetsTmpPath + "/" + name).exists()).toBe(false);
    });
+
+   test("audio files", async () => {
+      const app = await makeApp();
+      const file = Bun.file(`${assetsPath}/test.mp3`);
+      const name = makeName("mp3");
+      const res = await app.server.request("/api/media/upload/" + name, {
+         method: "POST",
+         body: file,
+      });
+      const result = (await res.json()) as any;
+      expect(result.data.mime_type).toStartWith("audio/mpeg");
+      expect(result.name).toBe(name);
+
+      const destFile = Bun.file(assetsTmpPath + "/" + name);
+      expect(destFile.exists()).resolves.toBe(true);
+      await destFile.delete();
+   });
+
+   test("text files", async () => {
+      const app = await makeApp();
+      const file = Bun.file(`${assetsPath}/test.txt`);
+      const name = makeName("txt");
+      const res = await app.server.request("/api/media/upload/" + name, {
+         method: "POST",
+         body: file,
+      });
+      const result = (await res.json()) as any;
+      expect(result.data.mime_type).toStartWith("text/plain");
+      expect(result.name).toBe(name);
+
+      const destFile = Bun.file(assetsTmpPath + "/" + name);
+      expect(destFile.exists()).resolves.toBe(true);
+      await destFile.delete();
+   });
 });

app/__test__/media/Storage.spec.ts

@@ -1,8 +1,9 @@
 import { describe, expect, test } from "bun:test";
-import { type FileBody, Storage, type StorageAdapter } from "../../src/media/storage/Storage";
+import { type FileBody, Storage } from "../../src/media/storage/Storage";
 import * as StorageEvents from "../../src/media/storage/events";
+import { StorageAdapter } from "media/storage/StorageAdapter";
 
-class TestAdapter implements StorageAdapter {
+class TestAdapter extends StorageAdapter {
    files: Record<string, FileBody> = {};
 
    getName() {
@@ -61,7 +62,7 @@ describe("Storage", async () => {
    test("uploads a file", async () => {
       const {
          meta: { type, size },
-      } = await storage.uploadFile("hello", "world.txt");
+      } = await storage.uploadFile("hello" as any, "world.txt");
       expect({ type, size }).toEqual({ type: "text/plain", size: 0 });
    });
 
@@ -71,6 +72,7 @@ describe("Storage", async () => {
    });
 
    test("events were fired", async () => {
+      await storage.emgr.executeAsyncs();
       expect(events.has(StorageEvents.FileUploadedEvent.slug)).toBeTrue();
       expect(events.has(StorageEvents.FileDeletedEvent.slug)).toBeTrue();
       // @todo: file access must be tested in controllers

app/__test__/media/StorageR2Adapter.native-spec.ts

@@ -1,34 +0,0 @@
-import * as assert from "node:assert/strict";
-import { createWriteStream } from "node:fs";
-import { test } from "node:test";
-import { Miniflare } from "miniflare";
-
-// https://github.com/nodejs/node/issues/44372#issuecomment-1736530480
-console.log = async (message: any) => {
-   const tty = createWriteStream("/dev/tty");
-   const msg = typeof message === "string" ? message : JSON.stringify(message, null, 2);
-   return tty.write(`${msg}\n`);
-};
-
-test("what", async () => {
-   const mf = new Miniflare({
-      modules: true,
-      script: "export default { async fetch() { return new Response(null); } }",
-      r2Buckets: ["BUCKET"],
-   });
-
-   const bucket = await mf.getR2Bucket("BUCKET");
-   console.log(await bucket.put("count", "1"));
-
-   const object = await bucket.get("count");
-   if (object) {
-      /*const headers = new Headers();
-      object.writeHttpMetadata(headers);
-      headers.set("etag", object.httpEtag);*/
-      console.log("yo -->", await object.text());
-
-      assert.strictEqual(await object.text(), "1");
-   }
-
-   await mf.dispose();
-});

app/__test__/media/adapters/StorageCloudinaryAdapter.spec.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { randomString } from "../../../src/core/utils";
-import { StorageCloudinaryAdapter } from "../../../src/media";
-
-import { config } from "dotenv";
-const dotenvOutput = config({ path: `${import.meta.dir}/../../../.env` });
-const {
-   CLOUDINARY_CLOUD_NAME,
-   CLOUDINARY_API_KEY,
-   CLOUDINARY_API_SECRET,
-   CLOUDINARY_UPLOAD_PRESET,
-} = dotenvOutput.parsed!;
-
-const ALL_TESTS = !!process.env.ALL_TESTS;
-
-describe.skipIf(ALL_TESTS)("StorageCloudinaryAdapter", () => {
-   if (ALL_TESTS) return;
-
-   const adapter = new StorageCloudinaryAdapter({
-      cloud_name: CLOUDINARY_CLOUD_NAME as string,
-      api_key: CLOUDINARY_API_KEY as string,
-      api_secret: CLOUDINARY_API_SECRET as string,
-      upload_preset: CLOUDINARY_UPLOAD_PRESET as string,
-   });
-
-   const file = Bun.file(`${import.meta.dir}/icon.png`);
-   const _filename = randomString(10);
-   const filename = `${_filename}.png`;
-
-   test("object exists", async () => {
-      expect(await adapter.objectExists("7fCTBi6L8c.png")).toBeTrue();
-      process.exit();
-   });
-
-   test("puts object", async () => {
-      expect(await adapter.objectExists(filename)).toBeFalse();
-
-      const result = await adapter.putObject(filename, file);
-      console.log("result", result);
-      expect(result).toBeDefined();
-      expect(result?.name).toBe(filename);
-   });
-
-   test("object exists", async () => {
-      await Bun.sleep(10000);
-      const one = await adapter.objectExists(_filename);
-      const two = await adapter.objectExists(filename);
-      expect(await adapter.objectExists(filename)).toBeTrue();
-   });
-
-   test("object meta", async () => {
-      const result = await adapter.getObjectMeta(filename);
-      console.log("objectMeta:result", result);
-      expect(result).toBeDefined();
-      expect(result.type).toBe("image/png");
-      expect(result.size).toBeGreaterThan(0);
-   });
-
-   test("list objects", async () => {
-      const result = await adapter.listObjects();
-      console.log("listObjects:result", result);
-   });
-});

app/__test__/media/adapters/StorageLocalAdapter.spec.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { randomString } from "../../../src/core/utils";
-import { StorageLocalAdapter } from "../../../src/media/storage/adapters/StorageLocalAdapter";
-import { assetsPath, assetsTmpPath } from "../../helper";
-
-describe("StorageLocalAdapter", () => {
-   const adapter = new StorageLocalAdapter({
-      path: assetsTmpPath,
-   });
-
-   const file = Bun.file(`${assetsPath}/image.png`);
-   const _filename = randomString(10);
-   const filename = `${_filename}.png`;
-
-   let objects = 0;
-
-   test("puts an object", async () => {
-      objects = (await adapter.listObjects()).length;
-      expect(await adapter.putObject(filename, file as unknown as File)).toBeString();
-   });
-
-   test("lists objects", async () => {
-      expect((await adapter.listObjects()).length).toBe(objects + 1);
-   });
-
-   test("file exists", async () => {
-      expect(await adapter.objectExists(filename)).toBeTrue();
-   });
-
-   test("gets an object", async () => {
-      const res = await adapter.getObject(filename, new Headers());
-      expect(res.ok).toBeTrue();
-      // @todo: check the content
-   });
-
-   test("gets object meta", async () => {
-      expect(await adapter.getObjectMeta(filename)).toEqual({
-         type: file.type, // image/png
-         size: file.size,
-      });
-   });
-
-   test("deletes an object", async () => {
-      expect(await adapter.deleteObject(filename)).toBeUndefined();
-      expect(await adapter.objectExists(filename)).toBeFalse();
-   });
-});

app/__test__/media/adapters/StorageS3Adapter.spec.ts

@@ -1,109 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { randomString } from "../../../src/core/utils";
-import { StorageS3Adapter } from "../../../src/media";
-
-import { config } from "dotenv";
-//import { enableFetchLogging } from "../../helper";
-const dotenvOutput = config({ path: `${import.meta.dir}/../../../.env` });
-const { R2_ACCESS_KEY, R2_SECRET_ACCESS_KEY, R2_URL, AWS_ACCESS_KEY, AWS_SECRET_KEY, AWS_S3_URL } =
-   dotenvOutput.parsed!;
-
-// @todo: mock r2/s3 responses for faster tests
-const ALL_TESTS = !!process.env.ALL_TESTS;
-console.log("ALL_TESTS?", ALL_TESTS);
-
-/* 
-// @todo: preparation to mock s3 calls + replace fast-xml-parser
-let cleanup: () => void;
-beforeAll(async () => {
-   cleanup = await enableFetchLogging();
-});
-afterAll(() => {
-   cleanup();
-}); */
-
-describe.skipIf(ALL_TESTS)("StorageS3Adapter", async () => {
-   if (ALL_TESTS) return;
-
-   const versions = [
-      [
-         "r2",
-         new StorageS3Adapter({
-            access_key: R2_ACCESS_KEY as string,
-            secret_access_key: R2_SECRET_ACCESS_KEY as string,
-            url: R2_URL as string,
-         }),
-      ],
-      [
-         "s3",
-         new StorageS3Adapter({
-            access_key: AWS_ACCESS_KEY as string,
-            secret_access_key: AWS_SECRET_KEY as string,
-            url: AWS_S3_URL as string,
-         }),
-      ],
-   ] as const;
-
-   const _conf = {
-      adapters: ["r2", "s3"],
-      tests: [
-         "listObjects",
-         "putObject",
-         "objectExists",
-         "getObject",
-         "deleteObject",
-         "getObjectMeta",
-      ],
-   };
-
-   const file = Bun.file(`${import.meta.dir}/icon.png`);
-   const filename = `${randomString(10)}.png`;
-
-   // single (dev)
-   //_conf = { adapters: [/*"r2",*/ "s3"], tests: [/*"putObject",*/ "listObjects"] };
-
-   function disabled(test: (typeof _conf.tests)[number]) {
-      return !_conf.tests.includes(test);
-   }
-
-   // @todo: add mocked fetch for faster tests
-   describe.each(versions)("StorageS3Adapter for %s", async (name, adapter) => {
-      if (!_conf.adapters.includes(name) || ALL_TESTS) {
-         console.log("Skipping", name);
-         return;
-      }
-
-      let objects = 0;
-
-      test.skipIf(disabled("putObject"))("puts an object", async () => {
-         objects = (await adapter.listObjects()).length;
-         expect(await adapter.putObject(filename, file as any)).toBeString();
-      });
-
-      test.skipIf(disabled("listObjects"))("lists objects", async () => {
-         expect((await adapter.listObjects()).length).toBe(objects + 1);
-      });
-
-      test.skipIf(disabled("objectExists"))("file exists", async () => {
-         expect(await adapter.objectExists(filename)).toBeTrue();
-      });
-
-      test.skipIf(disabled("getObject"))("gets an object", async () => {
-         const res = await adapter.getObject(filename, new Headers());
-         expect(res.ok).toBeTrue();
-         // @todo: check the content
-      });
-
-      test.skipIf(disabled("getObjectMeta"))("gets object meta", async () => {
-         expect(await adapter.getObjectMeta(filename)).toEqual({
-            type: file.type, // image/png
-            size: file.size,
-         });
-      });
-
-      test.skipIf(disabled("deleteObject"))("deletes an object", async () => {
-         expect(await adapter.deleteObject(filename)).toBeUndefined();
-         expect(await adapter.objectExists(filename)).toBeFalse();
-      });
-   });
-});

app/__test__/media/mime-types.spec.ts

@@ -5,7 +5,9 @@ import { getRandomizedFilename } from "../../src/media/utils";
 
 describe("media/mime-types", () => {
    test("tiny resolves", () => {
-      const tests = [[".mp4", "video/mp4", ".jpg", "image/jpeg", ".zip", "application/zip"]];
+      const tests = [
+         [".mp4", "video/mp4", ".jpg", "image/jpeg", ".zip", "application/zip"],
+      ] as const;
 
       for (const [ext, mime] of tests) {
          expect(tiny.guess(ext)).toBe(mime);
@@ -69,7 +71,9 @@ describe("media/mime-types", () => {
          ["application/zip", "zip"],
          ["text/tab-separated-values", "tsv"],
          ["application/zip", "zip"],
-      ];
+         ["application/pdf", "pdf"],
+         ["audio/mpeg", "mp3"],
+      ] as const;
 
       for (const [mime, ext] of tests) {
          expect(tiny.extension(mime), `extension(): ${mime} should be ${ext}`).toBe(ext);
@@ -86,7 +90,10 @@ describe("media/mime-types", () => {
          ["image.jpeg", "jpeg"],
          ["-473Wx593H-466453554-black-MODEL.jpg", "jpg"],
          ["-473Wx593H-466453554-black-MODEL.avif", "avif"],
-      ];
+         ["file.pdf", "pdf"],
+         ["file.mp3", "mp3"],
+         ["robots.txt", "txt"],
+      ] as const;
 
       for (const [filename, ext] of tests) {
          expect(
@@ -94,5 +101,42 @@ describe("media/mime-types", () => {
             `getRandomizedFilename(): ${filename} should end with ${ext}`,
          ).toBe(ext);
       }
+
+      // make sure it keeps the extension, even if the file has a different type
+      const file = new File([""], "image.jpg", { type: "text/plain" });
+      const [, ext] = getRandomizedFilename(file).split(".");
+      expect(ext).toBe("jpg");
+   });
+
+   test("getRandomizedFilename with body", async () => {
+      // should keep "pdf"
+      const [, ext] = getRandomizedFilename(
+         new File([""], "file.pdf", { type: "application/pdf" }),
+      ).split(".");
+      expect(ext).toBe("pdf");
+
+      {
+         // no ext, should use "pdf" only for known formats
+         const [, ext] = getRandomizedFilename(
+            new File([""], "file", { type: "application/pdf" }),
+         ).split(".");
+         expect(ext).toBe("pdf");
+      }
+
+      {
+         // wrong ext, should keep the wrong one
+         const [, ext] = getRandomizedFilename(
+            new File([""], "file.what", { type: "application/pdf" }),
+         ).split(".");
+         expect(ext).toBe("what");
+      }
+
+      {
+         // txt
+         const [, ext] = getRandomizedFilename(
+            new File([""], "file.txt", { type: "text/plain" }),
+         ).split(".");
+         expect(ext).toBe("txt");
+      }
    });
 });

app/__test__/modules/AppAuth.spec.ts

@@ -1,13 +1,21 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import { createApp } from "../../src";
+import { createApp } from "core/test/utils";
 import { AuthController } from "../../src/auth/api/AuthController";
-import { em, entity, make, text } from "../../src/data";
-import { AppAuth, type ModuleBuildContext } from "../../src/modules";
-import { disableConsoleLog, enableConsoleLog } from "../helper";
-// @ts-ignore
+import { em, entity, make, text } from "data/prototype";
+import { AppAuth, type ModuleBuildContext } from "modules";
 import { makeCtx, moduleTestSuite } from "./module-test-suite";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
 
 describe("AppAuth", () => {
+   test.skip("...", () => {
+      const auth = new AppAuth({});
+      console.log(auth.toJSON());
+      console.log(auth.config);
+   });
+
    moduleTestSuite(AppAuth);
 
    let ctx: ModuleBuildContext;
@@ -69,7 +77,7 @@ describe("AppAuth", () => {
             },
             body: JSON.stringify({
                email: "some@body.com",
-               password: "123456",
+               password: "12345678",
             }),
          });
          enableConsoleLog();
@@ -81,9 +89,68 @@ describe("AppAuth", () => {
       }
    });
 
+   test("creates user on register (bcrypt)", async () => {
+      const auth = new AppAuth(
+         {
+            enabled: true,
+            strategies: {
+               password: {
+                  type: "password",
+                  config: {
+                     hashing: "bcrypt",
+                  },
+               },
+            },
+            // @ts-ignore
+            jwt: {
+               secret: "123456",
+            },
+         },
+         ctx,
+      );
+
+      await auth.build();
+      await ctx.em.schema().sync({ force: true });
+
+      // expect no users, but the query to pass
+      const res = await ctx.em.repository("users").findMany();
+      expect(res.data.length).toBe(0);
+
+      const app = new AuthController(auth).getController();
+
+      {
+         disableConsoleLog();
+         const res = await app.request("/password/register", {
+            method: "POST",
+            headers: {
+               "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+               email: "some@body.com",
+               password: "12345678",
+            }),
+         });
+         enableConsoleLog();
+         expect(res.status).toBe(200);
+
+         const { data: users } = await ctx.em.repository("users").findMany();
+         expect(users.length).toBe(1);
+         expect(users[0]?.email).toBe("some@body.com");
+      }
+
+      {
+         // check user in database
+         const rawUser = await ctx.connection.kysely
+            .selectFrom("users")
+            .selectAll()
+            .executeTakeFirstOrThrow();
+         expect(rawUser.strategy_value).toStartWith("$");
+      }
+   });
+
    test("registers auth middleware for bknd routes only", async () => {
       const app = createApp({
-         initialConfig: {
+         config: {
             auth: {
                enabled: true,
                jwt: {
@@ -94,6 +161,7 @@ describe("AppAuth", () => {
       });
 
       await app.build();
+      app.registerAdminController();
       const spy = spyOn(app.module.auth.authenticator, "requestCookieRefresh");
 
       // register custom route
@@ -103,12 +171,16 @@ describe("AppAuth", () => {
       await app.server.request("/api/system/ping");
       await app.server.request("/test");
 
+      expect(spy.mock.calls.length).toBe(0);
+
+      // admin route
+      await app.server.request("/");
       expect(spy.mock.calls.length).toBe(1);
    });
 
    test("should allow additional user fields", async () => {
       const app = createApp({
-         initialConfig: {
+         config: {
             auth: {
                entity_name: "users",
                enabled: true,
@@ -132,7 +204,7 @@ describe("AppAuth", () => {
 
    test("ensure user field configs is always correct", async () => {
       const app = createApp({
-         initialConfig: {
+         config: {
             auth: {
                enabled: true,
             },

app/__test__/modules/AppData.spec.ts

@@ -1,13 +1,51 @@
-import { describe, expect, test } from "bun:test";
-import { parse } from "../../src/core/utils";
+import { beforeEach, describe, expect, test } from "bun:test";
+import { parse } from "core/utils/schema";
 import { fieldsSchema } from "../../src/data/data-schema";
-import { AppData } from "../../src/modules";
-import { moduleTestSuite } from "./module-test-suite";
+import { AppData, type ModuleBuildContext } from "../../src/modules";
+import { makeCtx, moduleTestSuite } from "./module-test-suite";
+import * as proto from "data/prototype";
 
 describe("AppData", () => {
    moduleTestSuite(AppData);
 
+   let ctx: ModuleBuildContext;
+   beforeEach(() => {
+      ctx = makeCtx();
+   });
+
    test("field config construction", () => {
       expect(parse(fieldsSchema, { type: "text" })).toBeDefined();
    });
+
+   test("should prevent multi-deletion of entities in single request", async () => {
+      const schema = proto.em({
+         one: proto.entity("one", {
+            text: proto.text(),
+         }),
+         two: proto.entity("two", {
+            text: proto.text(),
+         }),
+         three: proto.entity("three", {
+            text: proto.text(),
+         }),
+      });
+      const check = () => {
+         const expected = ["one", "two", "three"];
+         const fromConfig = Object.keys(data.config.entities ?? {});
+         const fromEm = data.em.entities.map((e) => e.name);
+         expect(fromConfig).toEqual(expected);
+         expect(fromEm).toEqual(expected);
+      };
+
+      // auth must be enabled, otherwise default config is returned
+      const data = new AppData(schema.toJSON(), ctx);
+      await data.build();
+      check();
+
+      expect(data.schema().remove("entities")).rejects.toThrow(/more than one entity/);
+      check();
+
+      await data.setContext(makeCtx()).build();
+      check();
+   });
 });

app/__test__/modules/AppMedia.spec.ts

@@ -1,18 +1,24 @@
 import { describe, expect, test } from "bun:test";
-import { createApp, registries } from "../../src";
-import { em, entity, text } from "../../src/data";
-import { StorageLocalAdapter } from "../../src/media/storage/adapters/StorageLocalAdapter";
-import { AppMedia } from "../../src/modules";
+import { createApp } from "core/test/utils";
+import { em, entity, text } from "data/prototype";
+import { registries } from "modules/registries";
+import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { AppMedia } from "../../src/media/AppMedia";
 import { moduleTestSuite } from "./module-test-suite";
 
 describe("AppMedia", () => {
+   test.skip("...", () => {
+      const media = new AppMedia();
+      console.log(media.toJSON());
+   });
+
    moduleTestSuite(AppMedia);
 
    test("should allow additional fields", async () => {
       registries.media.register("local", StorageLocalAdapter);
 
       const app = createApp({
-         initialConfig: {
+         config: {
             media: {
                entity_name: "media",
                enabled: true,

app/__test__/modules/DbModuleManager.spec.ts

@@ -0,0 +1,76 @@
+import { it, expect, describe } from "bun:test";
+import { DbModuleManager } from "modules/db/DbModuleManager";
+import { getDummyConnection } from "../helper";
+import { TABLE_NAME } from "modules/db/migrations";
+
+describe("DbModuleManager", () => {
+   it("should extract secrets", async () => {
+      const { dummyConnection } = getDummyConnection();
+      const m = new DbModuleManager(dummyConnection, {
+         initial: {
+            auth: {
+               enabled: true,
+               jwt: {
+                  secret: "test",
+               },
+            },
+         },
+      });
+      await m.build();
+      expect(m.toJSON(true).auth.jwt.secret).toBe("test");
+      await m.save();
+   });
+
+   it("should work with initial secrets", async () => {
+      const { dummyConnection } = getDummyConnection();
+      const db = dummyConnection.kysely;
+      const m = new DbModuleManager(dummyConnection, {
+         initial: {
+            auth: {
+               enabled: true,
+               jwt: {
+                  secret: "",
+               },
+            },
+         },
+         secrets: {
+            "auth.jwt.secret": "test",
+         },
+      });
+      await m.build();
+      expect(m.toJSON(true).auth.jwt.secret).toBe("test");
+
+      const getSecrets = () =>
+         db
+            .selectFrom(TABLE_NAME)
+            .selectAll()
+            .where("type", "=", "secrets")
+            .executeTakeFirst()
+            .then((r) => r?.json);
+
+      expect(await getSecrets()).toEqual({ "auth.jwt.secret": "test" });
+
+      // also after rebuild
+      await m.build();
+      await m.save();
+      expect(await getSecrets()).toEqual({ "auth.jwt.secret": "test" });
+
+      // and ignore if already present
+      const m2 = new DbModuleManager(dummyConnection, {
+         initial: {
+            auth: {
+               enabled: true,
+               jwt: {
+                  secret: "",
+               },
+            },
+         },
+         secrets: {
+            "auth.jwt.secret": "something completely different",
+         },
+      });
+      await m2.build();
+      await m2.save();
+      expect(await getSecrets()).toEqual({ "auth.jwt.secret": "test" });
+   });
+});

app/__test__/modules/Module.spec.ts

@@ -1,23 +1,23 @@
 import { describe, expect, test } from "bun:test";
-import { type TSchema, Type, stripMark } from "../../src/core/utils";
-import { EntityManager, em, entity, index, text } from "../../src/data";
+import { s, stripMark } from "core/utils/schema";
+import { em, entity, index, text } from "data/prototype";
+import { EntityManager } from "data/entities/EntityManager";
 import { DummyConnection } from "../../src/data/connection/DummyConnection";
 import { Module } from "../../src/modules/Module";
+import { ModuleHelper } from "modules/ModuleHelper";
 
-function createModule<Schema extends TSchema>(schema: Schema) {
-   class TestModule extends Module<typeof schema> {
+function createModule<Schema extends s.Schema>(schema: Schema) {
+   return class TestModule extends Module<Schema> {
       getSchema() {
          return schema;
       }
-      toJSON() {
+      override toJSON() {
          return this.config;
       }
-      useForceParse() {
+      override useForceParse() {
          return true;
       }
-   }
-
-   return TestModule;
+   };
 }
 
 describe("Module", async () => {
@@ -25,7 +25,7 @@ describe("Module", async () => {
       test("listener", async () => {
          let result: any;
 
-         const module = createModule(Type.Object({ a: Type.String() }));
+         const module = createModule(s.object({ a: s.string() }));
          const m = new module({ a: "test" });
 
          await m.schema().set({ a: "test2" });
@@ -41,13 +41,13 @@ describe("Module", async () => {
    describe("db schema", () => {
       class M extends Module {
          override getSchema() {
-            return Type.Object({});
+            return s.object({});
          }
 
          prt = {
-            ensureEntity: this.ensureEntity.bind(this),
-            ensureIndex: this.ensureIndex.bind(this),
-            ensureSchema: this.ensureSchema.bind(this),
+            ensureEntity: this.ctx.helper.ensureEntity.bind(this.ctx.helper),
+            ensureIndex: this.ctx.helper.ensureIndex.bind(this.ctx.helper),
+            ensureSchema: this.ctx.helper.ensureSchema.bind(this.ctx.helper),
          };
 
          get em() {
@@ -62,7 +62,11 @@ describe("Module", async () => {
             _em.relations,
             _em.indices,
          );
-         return new M({} as any, { em, flags: Module.ctx_flags } as any);
+         const ctx = {
+            em,
+            flags: Module.ctx_flags,
+         };
+         return new M({} as any, { ...ctx, helper: new ModuleHelper(ctx as any) } as any);
       }
       function flat(_em: EntityManager) {
          return {
@@ -142,14 +146,9 @@ describe("Module", async () => {
 
          // this should only add the field "important"
          m.prt.ensureEntity(
-            entity(
-               "u",
-               {
-                  important: text(),
-               },
-               undefined,
-               "system",
-            ),
+            entity("u", {
+               important: text(),
+            }),
          );
 
          expect(m.ctx.flags.sync_required).toBe(true);
@@ -158,8 +157,7 @@ describe("Module", async () => {
                {
                   name: "u",
                   fields: ["id", "name", "important"],
-                  // ensured type must be present
-                  type: "system",
+                  type: "regular",
                },
                {
                   name: "p",

app/__test__/modules/ModuleManager.spec.ts

@@ -1,10 +1,18 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { Type, disableConsoleLog, enableConsoleLog, stripMark } from "../../src/core/utils";
-import { entity, text } from "../../src/data";
-import { Module } from "../../src/modules/Module";
-import { ModuleManager, getDefaultConfig } from "../../src/modules/ModuleManager";
-import { CURRENT_VERSION, TABLE_NAME } from "../../src/modules/migrations";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+import { Module } from "modules/Module";
+import { getDefaultConfig } from "modules/ModuleManager";
+import { type ConfigTable, DbModuleManager as ModuleManager } from "modules/db/DbModuleManager";
+
+import { CURRENT_VERSION, TABLE_NAME } from "modules/db/migrations";
 import { getDummyConnection } from "../helper";
+import { s, stripMark } from "core/utils/schema";
+import { Connection } from "data/connection/Connection";
+import { entity, text } from "data/prototype";
+
+beforeAll(disableConsoleLog);
+afterAll(enableConsoleLog);
 
 describe("ModuleManager", async () => {
    test("s1: no config, no build", async () => {
@@ -89,7 +97,11 @@ describe("ModuleManager", async () => {
 
       await mm2.build();
 
-      expect(stripMark(json)).toEqual(stripMark(mm2.configs()));
+      /* console.log({
+         json,
+         configs: mm2.configs(),
+      }); */
+      //expect(stripMark(json)).toEqual(stripMark(mm2.configs()));
       expect(mm2.configs().data.entities?.test).toBeDefined();
       expect(mm2.configs().data.entities?.test?.fields?.content).toBeDefined();
       expect(mm2.get("data").toJSON().entities?.test?.fields?.content).toBeDefined();
@@ -126,7 +138,7 @@ describe("ModuleManager", async () => {
       const db = c2.dummyConnection.kysely;
 
       const mm2 = new ModuleManager(c2.dummyConnection, {
-         initial: { version: version - 1, ...json },
+         initial: { version: version - 1, ...json } as any,
       });
       await mm2.syncConfigTable();
       await db
@@ -254,10 +266,10 @@ describe("ModuleManager", async () => {
    // @todo: add tests for migrations (check "backup" and new version)
 
    describe("revert", async () => {
-      const failingModuleSchema = Type.Object({
-         value: Type.Optional(Type.Number()),
+      const failingModuleSchema = s.partialObject({
+         value: s.number(),
       });
-      class FailingModule extends Module<typeof failingModuleSchema> {
+      class FailingModule extends Module<s.Static<typeof failingModuleSchema>> {
          getSchema() {
             return failingModuleSchema;
          }
@@ -380,4 +392,128 @@ describe("ModuleManager", async () => {
          expect(() => f.default()).toThrow();
       });
    });
+
+   async function getRawConfig(c: Connection) {
+      return (await c.kysely
+         .selectFrom(TABLE_NAME)
+         .selectAll()
+         .where("type", "=", "config")
+         .orderBy("version", "desc")
+         .executeTakeFirstOrThrow()) as unknown as ConfigTable;
+   }
+
+   async function getDiffs(c: Connection, opts?: { dir?: "asc" | "desc"; limit?: number }) {
+      return await c.kysely
+         .selectFrom(TABLE_NAME)
+         .selectAll()
+         .where("type", "=", "diff")
+         .orderBy("version", opts?.dir ?? "desc")
+         .$if(!!opts?.limit, (b) => b.limit(opts!.limit!))
+         .execute();
+   }
+
+   describe("diffs", () => {
+      test("never empty", async () => {
+         const { dummyConnection: c } = getDummyConnection();
+         const mm = new ModuleManager(c);
+         await mm.build();
+         await mm.save();
+         expect(await getDiffs(c)).toHaveLength(0);
+      });
+
+      test("has timestamps", async () => {
+         const { dummyConnection: c } = getDummyConnection();
+         const mm = new ModuleManager(c);
+         await mm.build();
+
+         await mm.get("data").schema().patch("basepath", "/api/data2");
+         await mm.save();
+
+         const config = await getRawConfig(c);
+         const diffs = await getDiffs(c);
+
+         expect(config.json.data.basepath).toBe("/api/data2");
+         expect(diffs).toHaveLength(1);
+         expect(diffs[0]!.created_at).toBeDefined();
+         expect(diffs[0]!.updated_at).toBeDefined();
+      });
+   });
+
+   describe("validate & revert", () => {
+      const schema = s.object({
+         value: s.array(s.number()),
+      });
+      type SampleSchema = s.Static<typeof schema>;
+      class Sample extends Module<SampleSchema> {
+         getSchema() {
+            return schema;
+         }
+         override async build() {
+            this.setBuilt();
+         }
+         override async onBeforeUpdate(from: SampleSchema, to: SampleSchema) {
+            if (to.value.length > 3) {
+               throw new Error("too many values");
+            }
+            if (to.value.includes(7)) {
+               throw new Error("contains 7");
+            }
+
+            return to;
+         }
+      }
+      class TestModuleManager extends ModuleManager {
+         constructor(...args: ConstructorParameters<typeof ModuleManager>) {
+            super(...args);
+            this.modules["module1"] = new Sample({}, this.ctx());
+         }
+      }
+      test("respects module onBeforeUpdate", async () => {
+         const { dummyConnection: c } = getDummyConnection();
+         const mm = new TestModuleManager(c);
+         await mm.build();
+
+         const m = mm.get("module1" as any) as Sample;
+
+         {
+            expect(async () => {
+               await m.schema().set({ value: [1, 2, 3, 4, 5] });
+               return mm.save();
+            }).toThrow(/too many values/);
+
+            expect(m.config.value).toHaveLength(0);
+            expect((mm.configs() as any).module1.value).toHaveLength(0);
+         }
+
+         {
+            expect(async () => {
+               await mm.mutateConfigSafe("module1" as any).set({ value: [1, 2, 3, 4, 5] });
+               return mm.save();
+            }).toThrow(/too many values/);
+
+            expect(m.config.value).toHaveLength(0);
+            expect((mm.configs() as any).module1.value).toHaveLength(0);
+         }
+
+         {
+            expect(async () => {
+               await m.schema().set({ value: [1, 7, 5] });
+               return mm.save();
+            }).toThrow(/contains 7/);
+
+            expect(m.config.value).toHaveLength(0);
+            expect((mm.configs() as any).module1.value).toHaveLength(0);
+         }
+
+         {
+            expect(async () => {
+               await mm.mutateConfigSafe("module1" as any).set({ value: [1, 7, 5] });
+               return mm.save();
+            }).toThrow(/contains 7/);
+
+            expect(m.config.value).toHaveLength(0);
+            expect((mm.configs() as any).module1.value).toHaveLength(0);
+         }
+      });
+   });
 });

app/__test__/modules/migrations/migrations.spec.ts

@@ -1,14 +1,22 @@
-import { describe, expect, test } from "bun:test";
-import { type InitialModuleConfigs, createApp } from "../../../src";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { App, type InitialModuleConfigs, createApp } from "/";
 
 import { type Kysely, sql } from "kysely";
 import { getDummyConnection } from "../../helper";
 import v7 from "./samples/v7.json";
 import v8 from "./samples/v8.json";
 import v8_2 from "./samples/v8-2.json";
+import v9 from "./samples/v9.json";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
 
 // app expects migratable config to be present in database
-async function createVersionedApp(config: InitialModuleConfigs | any) {
+async function createVersionedApp(
+   config: InitialModuleConfigs | any,
+   opts?: { beforeCreateApp?: (db: Kysely<any>) => Promise<void> },
+) {
    const { dummyConnection } = getDummyConnection();
 
    if (!("version" in config)) throw new Error("config must have a version");
@@ -34,6 +42,10 @@ async function createVersionedApp(config: InitialModuleConfigs | any) {
       })
       .execute();
 
+   if (opts?.beforeCreateApp) {
+      await opts.beforeCreateApp(db);
+   }
+
    const app = createApp({
       connection: dummyConnection,
    });
@@ -41,6 +53,19 @@ async function createVersionedApp(config: InitialModuleConfigs | any) {
    return app;
 }
 
+async function getRawConfig(
+   app: App,
+   opts?: { version?: number; types?: ("config" | "diff" | "backup" | "secrets")[] },
+) {
+   const db = app.em.connection.kysely;
+   return await db
+      .selectFrom("__bknd")
+      .selectAll()
+      .$if(!!opts?.version, (qb) => qb.where("version", "=", opts?.version))
+      .$if((opts?.types?.length ?? 0) > 0, (qb) => qb.where("type", "in", opts?.types))
+      .execute();
+}
+
 describe("Migrations", () => {
    /**
     * updated auth strategies to have "enabled" prop
@@ -78,4 +103,30 @@ describe("Migrations", () => {
       // @ts-expect-error
       expect(app.toJSON(true).server.admin).toBeUndefined();
    });
+
+   test("migration from 9 to 10", async () => {
+      expect(v9.version).toBe(9);
+
+      const app = await createVersionedApp(v9);
+
+      expect(app.version()).toBeGreaterThan(9);
+      // @ts-expect-error
+      expect(app.toJSON(true).media.adapter.config.secret_access_key).toBe(
+         "^^s3.secret_access_key^^",
+      );
+      const [config, secrets] = (await getRawConfig(app, {
+         version: 10,
+         types: ["config", "secrets"],
+      })) as any;
+
+      expect(config.json.auth.jwt.secret).toBe("");
+      expect(config.json.media.adapter.config.access_key).toBe("");
+      expect(config.json.media.adapter.config.secret_access_key).toBe("");
+
+      expect(secrets.json["auth.jwt.secret"]).toBe("^^jwt.secret^^");
+      expect(secrets.json["media.adapter.config.access_key"]).toBe("^^s3.access_key^^");
+      expect(secrets.json["media.adapter.config.secret_access_key"]).toBe(
+         "^^s3.secret_access_key^^",
+      );
+   });
 });

app/__test__/modules/migrations/samples/v9.json

@@ -0,0 +1,612 @@
+{
+  "version": 9,
+  "server": {
+    "cors": {
+      "origin": "*",
+      "allow_methods": ["GET", "POST", "PATCH", "PUT", "DELETE"],
+      "allow_headers": [
+        "Content-Type",
+        "Content-Length",
+        "Authorization",
+        "Accept"
+      ],
+      "allow_credentials": true
+    },
+    "mcp": { "enabled": false, "path": "/api/system/mcp" }
+  },
+  "data": {
+    "basepath": "/api/data",
+    "default_primary_format": "integer",
+    "entities": {
+      "media": {
+        "type": "system",
+        "fields": {
+          "id": {
+            "type": "primary",
+            "config": {
+              "format": "integer",
+              "fillable": false,
+              "required": false
+            }
+          },
+          "path": { "type": "text", "config": { "required": true } },
+          "folder": {
+            "type": "boolean",
+            "config": {
+              "default_value": false,
+              "hidden": true,
+              "fillable": ["create"],
+              "required": false
+            }
+          },
+          "mime_type": { "type": "text", "config": { "required": false } },
+          "size": { "type": "number", "config": { "required": false } },
+          "scope": {
+            "type": "text",
+            "config": {
+              "hidden": true,
+              "fillable": ["create"],
+              "required": false
+            }
+          },
+          "etag": { "type": "text", "config": { "required": false } },
+          "modified_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "reference": { "type": "text", "config": { "required": false } },
+          "entity_id": { "type": "number", "config": { "required": false } },
+          "metadata": { "type": "json", "config": { "required": false } }
+        },
+        "config": { "sort_field": "id", "sort_dir": "asc" }
+      },
+      "users": {
+        "type": "system",
+        "fields": {
+          "id": {
+            "type": "primary",
+            "config": {
+              "format": "integer",
+              "fillable": false,
+              "required": false
+            }
+          },
+          "email": { "type": "text", "config": { "required": true } },
+          "strategy": {
+            "type": "enum",
+            "config": {
+              "options": { "type": "strings", "values": ["password"] },
+              "required": true,
+              "hidden": ["update", "form"],
+              "fillable": ["create"]
+            }
+          },
+          "strategy_value": {
+            "type": "text",
+            "config": {
+              "fillable": ["create"],
+              "hidden": ["read", "table", "update", "form"],
+              "required": true
+            }
+          },
+          "role": {
+            "type": "enum",
+            "config": {
+              "options": { "type": "strings", "values": ["admin", "guest"] },
+              "required": false
+            }
+          },
+          "age": {
+            "type": "enum",
+            "config": {
+              "options": {
+                "type": "strings",
+                "values": ["18-24", "25-34", "35-44", "45-64", "65+"]
+              },
+              "required": false
+            }
+          },
+          "height": { "type": "number", "config": { "required": false } },
+          "gender": {
+            "type": "enum",
+            "config": {
+              "options": { "type": "strings", "values": ["male", "female"] },
+              "required": false
+            }
+          }
+        },
+        "config": { "sort_field": "id", "sort_dir": "asc" }
+      },
+      "avatars": {
+        "type": "regular",
+        "fields": {
+          "id": {
+            "type": "primary",
+            "config": {
+              "format": "integer",
+              "fillable": false,
+              "required": false
+            }
+          },
+          "identifier": { "type": "text", "config": { "required": false } },
+          "payload": {
+            "type": "json",
+            "config": { "required": false, "hidden": ["table"] }
+          },
+          "created_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "started_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "completed_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "input": {
+            "type": "media",
+            "config": {
+              "required": false,
+              "fillable": ["update"],
+              "hidden": false,
+              "mime_types": [],
+              "virtual": true,
+              "entity": "avatars"
+            }
+          },
+          "output": {
+            "type": "media",
+            "config": {
+              "required": false,
+              "fillable": ["update"],
+              "hidden": false,
+              "mime_types": [],
+              "virtual": true,
+              "entity": "avatars"
+            }
+          },
+          "users_id": {
+            "type": "relation",
+            "config": {
+              "label": "Users",
+              "required": false,
+              "reference": "users",
+              "target": "users",
+              "target_field": "id",
+              "target_field_type": "integer",
+              "on_delete": "set null"
+            }
+          }
+        },
+        "config": { "sort_field": "id", "sort_dir": "desc" }
+      },
+      "tryons": {
+        "type": "regular",
+        "fields": {
+          "id": {
+            "type": "primary",
+            "config": {
+              "format": "integer",
+              "fillable": false,
+              "required": false
+            }
+          },
+          "created_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "completed_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "avatars_id": {
+            "type": "relation",
+            "config": {
+              "label": "Avatars",
+              "required": false,
+              "reference": "avatars",
+              "target": "avatars",
+              "target_field": "id",
+              "target_field_type": "integer",
+              "on_delete": "set null"
+            }
+          },
+          "users_id": {
+            "type": "relation",
+            "config": {
+              "label": "Users",
+              "required": false,
+              "reference": "users",
+              "target": "users",
+              "target_field": "id",
+              "target_field_type": "integer",
+              "on_delete": "set null"
+            }
+          },
+          "output": {
+            "type": "media",
+            "config": {
+              "required": false,
+              "fillable": ["update"],
+              "hidden": false,
+              "mime_types": [],
+              "virtual": true,
+              "entity": "tryons",
+              "max_items": 1
+            }
+          },
+          "products_id": {
+            "type": "relation",
+            "config": {
+              "label": "Products",
+              "required": false,
+              "reference": "products",
+              "target": "products",
+              "target_field": "id",
+              "target_field_type": "integer",
+              "on_delete": "set null"
+            }
+          },
+          "payload": {
+            "type": "json",
+            "config": { "required": false, "hidden": ["table"] }
+          }
+        },
+        "config": { "sort_field": "id", "sort_dir": "desc" }
+      },
+      "products": {
+        "type": "regular",
+        "fields": {
+          "id": {
+            "type": "primary",
+            "config": {
+              "format": "integer",
+              "fillable": false,
+              "required": false
+            }
+          },
+          "enabled": { "type": "boolean", "config": { "required": false } },
+          "title": { "type": "text", "config": { "required": false } },
+          "url": { "type": "text", "config": { "required": false } },
+          "image": {
+            "type": "media",
+            "config": {
+              "required": false,
+              "fillable": ["update"],
+              "hidden": false,
+              "mime_types": [],
+              "virtual": true,
+              "entity": "products",
+              "max_items": 1
+            }
+          },
+          "created_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "sites_id": {
+            "type": "relation",
+            "config": {
+              "label": "Sites",
+              "required": false,
+              "reference": "sites",
+              "target": "sites",
+              "target_field": "id",
+              "target_field_type": "integer",
+              "on_delete": "set null"
+            }
+          },
+          "garment_type": {
+            "type": "enum",
+            "config": {
+              "options": {
+                "type": "strings",
+                "values": ["auto", "tops", "bottoms", "one-pieces"]
+              },
+              "required": false
+            }
+          }
+        },
+        "config": { "sort_field": "id", "sort_dir": "desc" }
+      },
+      "sites": {
+        "type": "regular",
+        "fields": {
+          "id": {
+            "type": "primary",
+            "config": {
+              "format": "integer",
+              "fillable": false,
+              "required": false
+            }
+          },
+          "origin": {
+            "type": "text",
+            "config": {
+              "pattern": "^(https?):\\/\\/([a-zA-Z0-9.-]+)(:\\d+)?$",
+              "required": true
+            }
+          },
+          "name": { "type": "text", "config": { "required": false } },
+          "active": { "type": "boolean", "config": { "required": false } },
+          "logo": {
+            "type": "media",
+            "config": {
+              "required": false,
+              "fillable": ["update"],
+              "hidden": false,
+              "mime_types": [],
+              "virtual": true,
+              "entity": "sites",
+              "max_items": 1
+            }
+          },
+          "instructions": {
+            "type": "text",
+            "config": {
+              "html_config": {
+                "element": "textarea",
+                "props": { "rows": "2" }
+              },
+              "required": false,
+              "hidden": ["table"]
+            }
+          }
+        },
+        "config": { "sort_field": "id", "sort_dir": "desc" }
+      },
+      "sessions": {
+        "type": "regular",
+        "fields": {
+          "id": {
+            "type": "primary",
+            "config": { "format": "uuid", "fillable": false, "required": false }
+          },
+          "created_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": true }
+          },
+          "claimed_at": {
+            "type": "date",
+            "config": { "type": "datetime", "required": false }
+          },
+          "url": { "type": "text", "config": { "required": false } },
+          "sites_id": {
+            "type": "relation",
+            "config": {
+              "label": "Sites",
+              "required": false,
+              "reference": "sites",
+              "target": "sites",
+              "target_field": "id",
+              "target_field_type": "integer",
+              "on_delete": "set null"
+            }
+          },
+          "users_id": {
+            "type": "relation",
+            "config": {
+              "label": "Users",
+              "required": false,
+              "reference": "users",
+              "target": "users",
+              "target_field": "id",
+              "target_field_type": "integer",
+              "on_delete": "set null"
+            }
+          }
+        },
+        "config": { "sort_field": "id", "sort_dir": "desc" }
+      }
+    },
+    "relations": {
+      "poly_avatars_media_input": {
+        "type": "poly",
+        "source": "avatars",
+        "target": "media",
+        "config": { "mappedBy": "input" }
+      },
+      "poly_avatars_media_output": {
+        "type": "poly",
+        "source": "avatars",
+        "target": "media",
+        "config": { "mappedBy": "output" }
+      },
+      "n1_avatars_users": {
+        "type": "n:1",
+        "source": "avatars",
+        "target": "users",
+        "config": {
+          "mappedBy": "",
+          "inversedBy": "",
+          "required": false,
+          "with_limit": 5
+        }
+      },
+      "n1_tryons_avatars": {
+        "type": "n:1",
+        "source": "tryons",
+        "target": "avatars",
+        "config": {
+          "mappedBy": "",
+          "inversedBy": "",
+          "required": false,
+          "with_limit": 5
+        }
+      },
+      "n1_tryons_users": {
+        "type": "n:1",
+        "source": "tryons",
+        "target": "users",
+        "config": {
+          "mappedBy": "",
+          "inversedBy": "",
+          "required": false,
+          "with_limit": 5
+        }
+      },
+      "poly_tryons_media_output": {
+        "type": "poly",
+        "source": "tryons",
+        "target": "media",
+        "config": { "mappedBy": "output", "targetCardinality": 1 }
+      },
+      "poly_products_media_image": {
+        "type": "poly",
+        "source": "products",
+        "target": "media",
+        "config": { "mappedBy": "image", "targetCardinality": 1 }
+      },
+      "n1_tryons_products": {
+        "type": "n:1",
+        "source": "tryons",
+        "target": "products",
+        "config": {
+          "mappedBy": "",
+          "inversedBy": "",
+          "required": false,
+          "with_limit": 5
+        }
+      },
+      "poly_sites_media_logo": {
+        "type": "poly",
+        "source": "sites",
+        "target": "media",
+        "config": { "mappedBy": "logo", "targetCardinality": 1 }
+      },
+      "n1_sessions_sites": {
+        "type": "n:1",
+        "source": "sessions",
+        "target": "sites",
+        "config": {
+          "mappedBy": "",
+          "inversedBy": "",
+          "required": false,
+          "with_limit": 5
+        }
+      },
+      "n1_sessions_users": {
+        "type": "n:1",
+        "source": "sessions",
+        "target": "users",
+        "config": {
+          "mappedBy": "",
+          "inversedBy": "",
+          "required": false,
+          "with_limit": 5
+        }
+      },
+      "n1_products_sites": {
+        "type": "n:1",
+        "source": "products",
+        "target": "sites",
+        "config": {
+          "mappedBy": "",
+          "inversedBy": "",
+          "required": false,
+          "with_limit": 5
+        }
+      }
+    },
+    "indices": {
+      "idx_unique_media_path": {
+        "entity": "media",
+        "fields": ["path"],
+        "unique": true
+      },
+      "idx_media_reference": {
+        "entity": "media",
+        "fields": ["reference"],
+        "unique": false
+      },
+      "idx_media_entity_id": {
+        "entity": "media",
+        "fields": ["entity_id"],
+        "unique": false
+      },
+      "idx_unique_users_email": {
+        "entity": "users",
+        "fields": ["email"],
+        "unique": true
+      },
+      "idx_users_strategy": {
+        "entity": "users",
+        "fields": ["strategy"],
+        "unique": false
+      },
+      "idx_users_strategy_value": {
+        "entity": "users",
+        "fields": ["strategy_value"],
+        "unique": false
+      },
+      "idx_sites_origin_active": {
+        "entity": "sites",
+        "fields": ["origin", "active"],
+        "unique": false
+      },
+      "idx_sites_active": {
+        "entity": "sites",
+        "fields": ["active"],
+        "unique": false
+      },
+      "idx_products_url": {
+        "entity": "products",
+        "fields": ["url"],
+        "unique": false
+      }
+    }
+  },
+  "auth": {
+    "enabled": true,
+    "basepath": "/api/auth",
+    "entity_name": "users",
+    "allow_register": true,
+    "jwt": {
+      "secret": "^^jwt.secret^^",
+      "alg": "HS256",
+      "expires": 999999999,
+      "issuer": "issuer",
+      "fields": ["id", "email", "role"]
+    },
+    "cookie": {
+      "path": "/",
+      "sameSite": "none",
+      "secure": true,
+      "httpOnly": true,
+      "expires": 604800,
+      "partitioned": false,
+      "renew": true,
+      "pathSuccess": "/admin",
+      "pathLoggedOut": "/"
+    },
+    "strategies": {
+      "password": {
+        "enabled": true,
+        "type": "password",
+        "config": { "hashing": "sha256" }
+      }
+    },
+    "guard": { "enabled": false },
+    "roles": {
+      "admin": { "implicit_allow": true },
+      "guest": { "is_default": true }
+    }
+  },
+  "media": {
+    "enabled": true,
+    "basepath": "/api/media",
+    "entity_name": "media",
+    "storage": { "body_max_size": 0 },
+    "adapter": {
+      "type": "s3",
+      "config": {
+        "access_key": "^^s3.access_key^^",
+        "secret_access_key": "^^s3.secret_access_key^^",
+        "url": "https://1234.r2.cloudflarestorage.com/bucket-name"
+      }
+    }
+  },
+  "flows": { "basepath": "/api/flows", "flows": {} }
+}

app/__test__/modules/module-test-suite.ts

@@ -1,17 +1,17 @@
 import { beforeEach, describe, expect, it } from "bun:test";
 
 import { Hono } from "hono";
-import { Guard } from "../../src/auth";
-import { DebugLogger } from "../../src/core";
-import { EventManager } from "../../src/core/events";
-import { Default, stripMark } from "../../src/core/utils";
-import { EntityManager } from "../../src/data";
-import { Module, type ModuleBuildContext } from "../../src/modules/Module";
+import { Guard } from "auth/authorize/Guard";
+import { EventManager } from "core/events";
+import { EntityManager } from "data/entities/EntityManager";
+import { Module, type ModuleBuildContext } from "modules/Module";
 import { getDummyConnection } from "../helper";
+import { ModuleHelper } from "modules/ModuleHelper";
+import { DebugLogger, McpServer } from "bknd/utils";
 
 export function makeCtx(overrides?: Partial<ModuleBuildContext>): ModuleBuildContext {
    const { dummyConnection } = getDummyConnection();
-   return {
+   const ctx = {
       connection: dummyConnection,
       server: new Hono(),
       em: new EntityManager([], dummyConnection),
@@ -19,8 +19,13 @@ export function makeCtx(overrides?: Partial<ModuleBuildContext>): ModuleBuildCon
       guard: new Guard(),
       flags: Module.ctx_flags,
       logger: new DebugLogger(false),
+      mcp: new McpServer(),
       ...overrides,
    };
+   return {
+      ...ctx,
+      helper: new ModuleHelper(ctx as any),
+   } as any;
 }
 
 export function moduleTestSuite(module: { new (): Module }) {
@@ -40,7 +45,8 @@ export function moduleTestSuite(module: { new (): Module }) {
       it("uses the default config", async () => {
          const m = new module();
          await m.setContext(ctx).build();
-         expect(stripMark(m.toJSON())).toEqual(Default(m.getSchema(), {}));
+         expect(m.toJSON()).toEqual(m.getSchema().template({}, { withOptional: true }));
+         //expect(stripMark(m.toJSON())).toEqual(Default(m.getSchema(), {}));
       });
    });
 }

app/__test__/ui/json-form.spec.ts

@@ -102,7 +102,9 @@ describe("json form", () => {
       ] satisfies [string, Exclude<JSONSchema, boolean>, boolean][];
 
       for (const [pointer, schema, output] of examples) {
-         expect(utils.isRequired(new Draft2019(schema), pointer, schema)).toBe(output);
+         expect(utils.isRequired(new Draft2019(schema), pointer, schema), `${pointer} `).toBe(
+            output,
+         );
       }
    });
 

app/__test__/vitest/base.vi-test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from "vitest";
+
+describe("Example Test Suite", () => {
+   it("should pass basic arithmetic", () => {
+      expect(1 + 1).toBe(2);
+   });
+
+   it("should handle async operations", async () => {
+      const result = await Promise.resolve(42);
+      expect(result).toBe(42);
+   });
+});

app/__test__/vitest/setup.ts

@@ -0,0 +1,8 @@
+import "@testing-library/jest-dom";
+import { afterEach } from "vitest";
+import { cleanup } from "@testing-library/react";
+
+// Automatically cleanup after each test
+afterEach(() => {
+   cleanup();
+});

app/build.cli.ts

@@ -0,0 +1,47 @@
+import pkg from "./package.json" with { type: "json" };
+import c from "picocolors";
+import { formatNumber } from "bknd/utils";
+import * as esbuild from "esbuild";
+
+const deps = Object.keys(pkg.dependencies);
+const external = ["jsonv-ts/*", "wrangler", "bknd", "bknd/*", ...deps];
+
+if (process.env.DEBUG) {
+   const result = await esbuild.build({
+      entryPoints: ["./src/cli/index.ts"],
+      outdir: "./dist/cli",
+      platform: "node",
+      minify: true,
+      format: "esm",
+      metafile: true,
+      bundle: true,
+      external,
+      define: {
+         __isDev: "0",
+         __version: JSON.stringify(pkg.version),
+      },
+   });
+   await Bun.write("./dist/cli/metafile-esm.json", JSON.stringify(result.metafile, null, 2));
+   process.exit(0);
+}
+
+const result = await Bun.build({
+   entrypoints: ["./src/cli/index.ts"],
+   target: "node",
+   outdir: "./dist/cli",
+   env: "PUBLIC_*",
+   minify: true,
+   external,
+   define: {
+      __isDev: "0",
+      __version: JSON.stringify(pkg.version),
+   },
+});
+
+for (const output of result.outputs) {
+   const size_ = await output.text();
+   console.info(
+      c.cyan(formatNumber.fileSize(size_.length)),
+      c.dim(output.path.replace(import.meta.dir + "/", "")),
+   );
+}

app/build.ts

@@ -1,5 +1,7 @@
 import { $ } from "bun";
 import * as tsup from "tsup";
+import pkg from "./package.json" with { type: "json" };
+import c from "picocolors";
 
 const args = process.argv.slice(2);
 const watch = args.includes("--watch");
@@ -8,8 +10,21 @@ const types = args.includes("--types");
 const sourcemap = args.includes("--sourcemap");
 const clean = args.includes("--clean");
 
+// silence tsup
+const oldConsole = {
+   log: console.log,
+   warn: console.warn,
+};
+console.log = () => {};
+console.warn = () => {};
+
+const define = {
+   __isDev: "0",
+   __version: JSON.stringify(pkg.version),
+};
+
 if (clean) {
-   console.log("Cleaning dist (w/o static)");
+   console.info("Cleaning dist (w/o static)");
    await $`find dist -mindepth 1 ! -path "dist/static/*" ! -path "dist/static" -exec rm -rf {} +`;
 }
 
@@ -21,11 +36,11 @@ function buildTypes() {
    Bun.spawn(["bun", "build:types"], {
       stdout: "inherit",
       onExit: () => {
-         console.log("Types built");
+         oldConsole.log(c.cyan("[Types]"), c.green("built"));
          Bun.spawn(["bun", "tsc-alias"], {
             stdout: "inherit",
             onExit: () => {
-               console.log("Types aliased");
+               oldConsole.log(c.cyan("[Types]"), c.green("aliased"));
                types_running = false;
             },
          });
@@ -33,6 +48,10 @@ function buildTypes() {
    });
 }
 
+if (types && !watch) {
+   buildTypes();
+}
+
 let watcher_timeout: any;
 function delayTypes() {
    if (!watch || !types) return;
@@ -42,42 +61,44 @@ function delayTypes() {
    watcher_timeout = setTimeout(buildTypes, 1000);
 }
 
-if (types && !watch) {
-   buildTypes();
-}
-
-function banner(title: string) {
-   console.log("");
-   console.log("=".repeat(40));
-   console.log(title.toUpperCase());
-   console.log("-".repeat(40));
-}
+const dependencies = Object.keys(pkg.dependencies);
 
 // collection of always-external packages
-const external = ["bun:test", "@libsql/client"] as const;
+const external = [
+   ...dependencies,
+   "bun:test",
+   "node:test",
+   "node:assert/strict",
+   "@libsql/client",
+   "bknd",
+   /^bknd\/.*/,
+   "jsonv-ts",
+   /^jsonv-ts\/.*/,
+] as const;
 
 /**
  * Building backend and general API
  */
 async function buildApi() {
-   banner("Building API");
    await tsup.build({
       minify,
       sourcemap,
       watch,
-      entry: ["src/index.ts", "src/data/index.ts", "src/core/index.ts", "src/core/utils/index.ts"],
+      define,
+      entry: ["src/index.ts", "src/core/utils/index.ts", "src/plugins/index.ts"],
       outDir: "dist",
       external: [...external],
       metafile: true,
+      target: "esnext",
       platform: "browser",
       format: ["esm"],
       splitting: false,
-      treeshake: true,
       loader: {
          ".svg": "dataurl",
       },
       onSuccess: async () => {
          delayTypes();
+         oldConsole.log(c.cyan("[API]"), c.green("built"));
       },
    });
 }
@@ -95,6 +116,7 @@ async function buildUi() {
       minify,
       sourcemap,
       watch,
+      define,
       external: [
          ...external,
          "react",
@@ -120,7 +142,6 @@ async function buildUi() {
       },
    } satisfies tsup.Options;
 
-   banner("Building UI");
    await tsup.build({
       ...base,
       entry: ["src/ui/index.ts", "src/ui/main.css", "src/ui/styles.css"],
@@ -128,10 +149,10 @@ async function buildUi() {
       onSuccess: async () => {
          await rewriteClient("./dist/ui/index.js");
          delayTypes();
+         oldConsole.log(c.cyan("[UI]"), c.green("built"));
       },
    });
 
-   banner("Building Client");
    await tsup.build({
       ...base,
       entry: ["src/ui/client/index.ts"],
@@ -139,6 +160,7 @@ async function buildUi() {
       onSuccess: async () => {
          await rewriteClient("./dist/ui/client/index.js");
          delayTypes();
+         oldConsole.log(c.cyan("[UI]"), "Client", c.green("built"));
       },
    });
 }
@@ -149,11 +171,11 @@ async function buildUi() {
  * - ui/client is external, and after built replaced with "bknd/client"
  */
 async function buildUiElements() {
-   banner("Building UI Elements");
    await tsup.build({
       minify,
       sourcemap,
       watch,
+      define,
       entry: ["src/ui/elements/index.ts"],
       outDir: "dist/ui/elements",
       external: [
@@ -182,6 +204,7 @@ async function buildUiElements() {
       onSuccess: async () => {
          await rewriteClient("./dist/ui/elements/index.js");
          delayTypes();
+         oldConsole.log(c.cyan("[UI]"), "Elements", c.green("built"));
       },
    });
 }
@@ -202,59 +225,99 @@ function baseConfig(adapter: string, overrides: Partial<tsup.Options> = {}): tsu
       splitting: false,
       onSuccess: async () => {
          delayTypes();
+         oldConsole.log(c.cyan("[Adapter]"), adapter || "base", c.green("built"));
       },
       ...overrides,
       define: {
-         __isDev: "0",
+         ...define,
          ...overrides.define,
       },
       external: [
          /^cloudflare*/,
-         /^@?(hono|libsql).*?/,
+         /^@?hono.*?/,
          /^(bknd|react|next|node).*?/,
          /.*\.(html)$/,
+         ...external,
          ...(Array.isArray(overrides.external) ? overrides.external : []),
       ],
    };
 }
 
 async function buildAdapters() {
-   banner("Building Adapters");
-   // base adapter handles
-   await tsup.build({
-      ...baseConfig(""),
-      entry: ["src/adapter/index.ts"],
-      outDir: "dist/adapter",
-   });
-
-   // specific adatpers
-   await tsup.build(baseConfig("react-router"));
-   await tsup.build(baseConfig("bun"));
-   await tsup.build(baseConfig("astro"));
-   await tsup.build(baseConfig("aws"));
-   await tsup.build(
-      baseConfig("cloudflare", {
-         external: [/^kysely/],
+   await Promise.all([
+      // base adapter handles
+      tsup.build({
+         ...baseConfig(""),
+         target: "esnext",
+         platform: "neutral",
+         entry: ["src/adapter/index.ts"],
+         outDir: "dist/adapter",
+         // only way to keep @vite-ignore comments
+         minify: false,
       }),
-   );
 
-   await tsup.build({
-      ...baseConfig("vite"),
-      platform: "node",
-   });
+      // specific adatpers
+      tsup.build(baseConfig("react-router")),
+      tsup.build(
+         baseConfig("bun", {
+            external: [/^bun\:.*/],
+         }),
+      ),
+      tsup.build(baseConfig("astro")),
+      tsup.build(baseConfig("aws")),
+      tsup.build(
+         baseConfig("cloudflare", {
+            external: ["wrangler", "node:process"],
+         }),
+      ),
+      tsup.build(
+         baseConfig("cloudflare/proxy", {
+            target: "esnext",
+            entry: ["src/adapter/cloudflare/proxy.ts"],
+            outDir: "dist/adapter/cloudflare",
+            metafile: false,
+            external: [/bknd/, "wrangler", "node:process"],
+         }),
+      ),
 
-   await tsup.build({
-      ...baseConfig("nextjs"),
-      platform: "node",
-   });
+      tsup.build({
+         ...baseConfig("vite"),
+         platform: "node",
+      }),
 
-   await tsup.build({
-      ...baseConfig("node"),
-      platform: "node",
-   });
+      tsup.build({
+         ...baseConfig("nextjs"),
+         platform: "node",
+      }),
+
+      tsup.build({
+         ...baseConfig("node"),
+         platform: "node",
+      }),
+
+      tsup.build({
+         ...baseConfig("sqlite/edge"),
+         entry: ["src/adapter/sqlite/edge.ts"],
+         outDir: "dist/adapter/sqlite",
+         metafile: false,
+      }),
+
+      tsup.build({
+         ...baseConfig("sqlite/node"),
+         entry: ["src/adapter/sqlite/node.ts"],
+         outDir: "dist/adapter/sqlite",
+         platform: "node",
+         metafile: false,
+      }),
+
+      tsup.build({
+         ...baseConfig("sqlite/bun"),
+         entry: ["src/adapter/sqlite/bun.ts"],
+         outDir: "dist/adapter/sqlite",
+         metafile: false,
+         external: [/^bun\:.*/],
+      }),
+   ]);
 }
 
-await buildApi();
-await buildUi();
-await buildUiElements();
-await buildAdapters();
+await Promise.all([buildApi(), buildUi(), buildUiElements(), buildAdapters()]);

app/bunfig.toml

@@ -2,4 +2,5 @@
 #registry = "http://localhost:4873"
 
 [test]
-coverageSkipTestFiles = true
+coverageSkipTestFiles = true
+console.depth = 10

app/e2e/adapters.ts

@@ -0,0 +1,218 @@
+import { $ } from "bun";
+import path from "node:path";
+import c from "picocolors";
+
+const basePath = new URL(import.meta.resolve("../../")).pathname.slice(0, -1);
+
+async function run(
+   cmd: string[] | string,
+   opts: Bun.SpawnOptions.OptionsObject & {},
+   onChunk: (chunk: string, resolve: (data: any) => void, reject: (err: Error) => void) => void,
+): Promise<{ proc: Bun.Subprocess; data: any }> {
+   return new Promise((resolve, reject) => {
+      const proc = Bun.spawn(Array.isArray(cmd) ? cmd : cmd.split(" "), {
+         ...opts,
+         stdout: "pipe",
+         stderr: "pipe",
+      });
+
+      // Read from stdout
+      const reader = (proc.stdout as ReadableStream).getReader();
+      const decoder = new TextDecoder();
+
+      // Function to read chunks
+      let resolveCalled = false;
+      (async () => {
+         try {
+            while (true) {
+               const { done, value } = await reader.read();
+               if (done) break;
+
+               const text = decoder.decode(value);
+               if (!resolveCalled) {
+                  console.info(c.dim(text.replace(/\n$/, "")));
+               }
+               onChunk(
+                  text,
+                  (data) => {
+                     resolve({ proc, data });
+                     resolveCalled = true;
+                  },
+                  reject,
+               );
+            }
+         } catch (err) {
+            reject(err);
+         }
+      })();
+
+      proc.exited.then((code) => {
+         if (code !== 0 && code !== 130) {
+            throw new Error(`Process exited with code ${code}`);
+         }
+      });
+   });
+}
+
+const adapters = {
+   node: {
+      dir: path.join(basePath, "examples/node"),
+      clean: async function () {
+         const cwd = path.relative(process.cwd(), this.dir);
+         await $`cd ${cwd} && rm -rf uploads data.db && mkdir -p uploads`;
+      },
+      start: async function () {
+         return await run(
+            "npm run start",
+            {
+               cwd: this.dir,
+            },
+            (chunk, resolve, reject) => {
+               const regex = /running on (http:\/\/.*)\n/;
+               if (regex.test(chunk)) {
+                  resolve(chunk.match(regex)?.[1]);
+               }
+            },
+         );
+      },
+   },
+   bun: {
+      dir: path.join(basePath, "examples/bun"),
+      clean: async function () {
+         const cwd = path.relative(process.cwd(), this.dir);
+         await $`cd ${cwd} && rm -rf uploads data.db && mkdir -p uploads`;
+      },
+      start: async function () {
+         return await run(
+            "npm run start",
+            {
+               cwd: this.dir,
+            },
+            (chunk, resolve, reject) => {
+               const regex = /running on (http:\/\/.*)\n/;
+               if (regex.test(chunk)) {
+                  resolve(chunk.match(regex)?.[1]);
+               }
+            },
+         );
+      },
+   },
+   cloudflare: {
+      dir: path.join(basePath, "examples/cloudflare-worker"),
+      clean: async function () {
+         const cwd = path.relative(process.cwd(), this.dir);
+         await $`cd ${cwd} && rm -rf .wrangler node_modules/.cache node_modules/.mf`;
+      },
+      start: async function () {
+         return await run(
+            "npm run dev",
+            {
+               cwd: this.dir,
+            },
+            (chunk, resolve, reject) => {
+               const regex = /Ready on (http:\/\/.*)/;
+               if (regex.test(chunk)) {
+                  resolve(chunk.match(regex)?.[1]);
+               }
+            },
+         );
+      },
+   },
+   "react-router": {
+      dir: path.join(basePath, "examples/react-router"),
+      clean: async function () {
+         const cwd = path.relative(process.cwd(), this.dir);
+         await $`cd ${cwd} && rm -rf .react-router data.db`;
+         await $`cd ${cwd} && rm -rf public/uploads && mkdir -p public/uploads`;
+      },
+      start: async function () {
+         return await run(
+            "npm run dev",
+            {
+               cwd: this.dir,
+            },
+            (chunk, resolve, reject) => {
+               const regex = /Local.*?(http:\/\/.*)\//;
+               if (regex.test(chunk)) {
+                  resolve(chunk.match(regex)?.[1]);
+               }
+            },
+         );
+      },
+   },
+   nextjs: {
+      dir: path.join(basePath, "examples/nextjs"),
+      env: "TEST_TIMEOUT=20000",
+      clean: async function () {
+         const cwd = path.relative(process.cwd(), this.dir);
+         await $`cd ${cwd} && rm -rf .nextjs data.db`;
+         await $`cd ${cwd} && rm -rf public/uploads && mkdir -p public/uploads`;
+      },
+      start: async function () {
+         return await run(
+            "npm run dev",
+            {
+               cwd: this.dir,
+            },
+            (chunk, resolve, reject) => {
+               const regex = /Local.*?(http:\/\/.*)\n/;
+               if (regex.test(chunk)) {
+                  resolve(chunk.match(regex)?.[1]);
+               }
+            },
+         );
+      },
+   },
+   astro: {
+      dir: path.join(basePath, "examples/astro"),
+      clean: async function () {
+         const cwd = path.relative(process.cwd(), this.dir);
+         await $`cd ${cwd} && rm -rf .astro data.db`;
+         await $`cd ${cwd} && rm -rf public/uploads && mkdir -p public/uploads`;
+      },
+      start: async function () {
+         return await run(
+            "npm run dev",
+            {
+               cwd: this.dir,
+            },
+            (chunk, resolve, reject) => {
+               const regex = /Local.*?(http:\/\/.*)\//;
+               if (regex.test(chunk)) {
+                  resolve(chunk.match(regex)?.[1]);
+               }
+            },
+         );
+      },
+   },
+} as const;
+
+async function testAdapter(name: keyof typeof adapters) {
+   const config = adapters[name];
+   console.info("adapter", c.cyan(name));
+   await config.clean();
+
+   const { proc, data } = await config.start();
+   console.info("proc:", proc.pid, "data:", c.cyan(data));
+   //proc.kill();process.exit(0);
+
+   const add_env = "env" in config && config.env ? config.env : "";
+   await $`TEST_URL=${data} TEST_ADAPTER=${name} ${add_env} bun run test:e2e`;
+   console.info("DONE!");
+
+   while (!proc.killed) {
+      proc.kill("SIGINT");
+      await Bun.sleep(250);
+      console.info("Waiting for process to exit...");
+   }
+}
+
+// run with: TEST_ADAPTER=astro bun run e2e/adapters.ts
+// (modify `test:e2e` to `test:e2e:ui` to see the UI)
+if (process.env.TEST_ADAPTER) {
+   await testAdapter(process.env.TEST_ADAPTER as any);
+} else {
+   for (const [name] of Object.entries(adapters)) {
+      await testAdapter(name as any);
+   }
+}