admin ui: store data canvas positions

.github/workflows/test.yml

@@ -12,28 +12,15 @@ 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: "1.2.14"
+          bun-version: latest
 
       - name: Install dependencies
         working-directory: ./app
         run: bun install
 
-      - name: Build
+      - name: Run tests
         working-directory: ./app
-        run: bun run build:ci
+        run: bun run test
-
-      - 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

@@ -30,5 +30,3 @@ packages/media/.env
 .vscode
 .git_old
 docker/tmp
-.debug
-.history

.nvmrc

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

README.md

@@ -1,4 +1,5 @@
 [![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)
 
@@ -9,30 +10,22 @@
 </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 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.shields.io/bundlejs/size/bknd?label=bknd)
+![gzipped size of bknd](https://img.badgesize.io/https://unpkg.com/bknd@latest/dist/index.js?compression=gzip&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)
 
 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 300 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 212 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.

app/.env.example

@@ -1,42 +0,0 @@
-# ===== 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

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

app/__test__/App.spec.ts

@@ -1,9 +1,6 @@
-import { afterEach, describe, test, expect } from "bun:test";
+import { afterAll, afterEach, describe, expect, test } from "bun:test";
-import { App, createApp } from "core/test/utils";
+import { App } from "../src";
 import { getDummyConnection } from "./helper";
-import { Hono } from "hono";
-import * as proto from "../src/data/prototype";
-import { pick } from "lodash-es";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
 afterEach(afterAllCleanup);
@@ -13,133 +10,18 @@ describe("App tests", async () => {
       const app = new App(dummyConnection);
       await app.build();
 
-      expect(await app.em.ping()).toBeTrue();
+      //expect(await app.data?.em.ping()).toBeTrue();
    });
 
-   test("plugins", async () => {
+   /*test.only("what", async () => {
-      const called: string[] = [];
+      const app = new App(dummyConnection, {
-      const app = createApp({
+         auth: {
-         initialConfig: {
+            enabled: true,
-            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.build();
+      await app.module.data.build();
-
+      console.log(app.em.entities.map((e) => e.name));
-      expect(app.em.entities.map((e) => e.name)).toEqual(["users", "posts", "comments"]);
+      console.log(await app.em.schema().getDiff());
-      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__/adapter/adapter.test.ts

@@ -1,77 +0,0 @@
-import { expect, describe, it, beforeAll, afterAll } 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", () => {
-      expect(omitKeys(adapter.makeConfig({}), ["connection"])).toEqual({});
-      expect(omitKeys(adapter.makeConfig({}, { env: { TEST: "test" } }), ["connection"])).toEqual(
-         {},
-      );
-
-      // merges everything returned from `app` with the config
-      expect(
-         omitKeys(
-            adapter.makeConfig(
-               { app: (a) => ({ initialConfig: { server: { cors: { origin: a.env.TEST } } } }) },
-               { env: { TEST: "test" } },
-            ),
-            ["connection"],
-         ),
-      ).toEqual({
-         initialConfig: { server: { cors: { origin: "test" } } },
-      });
-   });
-
-   /* it.only("...", async () => {
-      const app = await adapter.createAdapterApp();
-   }); */
-
-   it("reuses apps correctly", async () => {
-      const id = crypto.randomUUID();
-
-      const first = await adapter.createAdapterApp(
-         {
-            initialConfig: { server: { cors: { origin: "random" } } },
-         },
-         undefined,
-         { id },
-      );
-      const second = await adapter.createAdapterApp();
-      const third = await adapter.createAdapterApp(undefined, undefined, { id });
-
-      await first.build();
-      await second.build();
-      await third.build();
-
-      expect(first.toJSON().server.cors.origin).toEqual("random");
-      expect(first).toBe(third);
-      expect(first).not.toBe(second);
-      expect(second).not.toBe(third);
-      expect(second.toJSON().server.cors.origin).toEqual("*");
-
-      // recreate the first one
-      const first2 = await adapter.createAdapterApp(undefined, undefined, { id, force: true });
-      await first2.build();
-      expect(first2).not.toBe(first);
-      expect(first2).not.toBe(third);
-      expect(first2).not.toBe(second);
-      expect(first2.toJSON().server.cors.origin).toEqual("*");
-   });
-
-   adapterTestSuite(bunTestRunner, {
-      makeApp: adapter.createFrameworkApp,
-      label: "framework app",
-   });
-
-   adapterTestSuite(bunTestRunner, {
-      makeApp: adapter.createRuntimeApp,
-      label: "runtime app",
-   });
-});

app/__test__/api/DataApi.spec.ts

@@ -1,12 +1,11 @@
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
 import { Guard } from "../../src/auth";
+import { parse } from "../../src/core/utils";
 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 { schemaToEm } from "../helper";
+import { disableConsoleLog, enableConsoleLog, schemaToEm } from "../helper";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-import { parse } from "core/object/schema";
 
 beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
@@ -65,15 +64,6 @@ 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 () => {
@@ -153,7 +143,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.items).toEqual(1);
+      expect(oneByRes.body.meta.count).toEqual(1);
    });
 
    it("exists/count", async () => {

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 "core/utils";
+import { getFileFromContext, isFile, isReadableStream } from "../../src/core/utils";
-import { MediaApi } from "media/api/MediaApi";
+import { MediaApi } from "../../src/media/api/MediaApi";
 import { assetsPath, assetsTmpPath } from "../helper";
 
 const mockedBackend = new Hono()
@@ -39,28 +39,10 @@ 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}`;
@@ -121,12 +103,8 @@ describe("MediaApi", () => {
    });
 
    it("should upload file in various ways", async () => {
-      const api = new MediaApi(
+      // @ts-ignore tests
-         {
+      const api = new MediaApi({}, mockedBackend.request);
-            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,6 +1,6 @@
 import { describe, expect, mock, test } from "bun:test";
 import type { ModuleBuildContext } from "../../src";
-import { App, createApp } from "core/test/utils";
+import { type App, createApp } from "../../src/App";
 import * as proto from "../../src/data/prototype";
 
 describe("App", () => {
@@ -20,7 +20,6 @@ describe("App", () => {
                   "guard",
                   "flags",
                   "logger",
-                  "helper",
                ]);
             },
          },
@@ -52,87 +51,4 @@ 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();
-   });
 });

app/__test__/app/AppServer.spec.ts

@@ -1,35 +0,0 @@
-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: {
-               origin: "*",
-               allow_methods: ["GET", "POST", "PATCH", "PUT", "DELETE"],
-               allow_headers: ["Content-Type", "Content-Length", "Authorization", "Accept"],
-            },
-         });
-      }
-
-      {
-         const server = new AppServer({
-            cors: {
-               origin: "https",
-               allow_methods: ["GET", "POST"],
-            },
-         });
-         expect(server).toBeDefined();
-         expect(server.config).toEqual({
-            cors: {
-               origin: "https",
-               allow_methods: ["GET", "POST"],
-               allow_headers: ["Content-Type", "Content-Length", "Authorization", "Accept"],
-            },
-         });
-      }
-   });
-});

app/__test__/app/repro.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { createApp } from "core/test/utils";
+import { createApp, registries } from "../../src";
 import * as proto from "../../src/data/prototype";
-import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { StorageLocalAdapter } from "../../src/media/storage/adapters/StorageLocalAdapter";
 
 describe("repros", async () => {
    /**
@@ -13,8 +13,8 @@ describe("repros", async () => {
     * There was an issue that AppData had old configs because of system entity "media"
     */
    test("registers media entity correctly to relate to it", async () => {
+      registries.media.register("local", StorageLocalAdapter);
       const app = createApp();
-      app.module.media.adapters.set("local", StorageLocalAdapter);
       await app.build();
 
       {

app/__test__/auth/Authenticator.spec.ts

@@ -2,7 +2,8 @@ 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 { parse } from "core/object/schema";
+import * as hash from "../../src/auth/utils/hash";
+import { Default, parse } from "../../src/core/utils";
 
 /*class MemoryUserPool implements UserPool {
    constructor(private users: User[] = []) {}
@@ -22,7 +23,7 @@ import { parse } from "core/object/schema";
 describe("Authenticator", async () => {
    test("cookie options", async () => {
       console.log("parsed", parse(cookieConfig, undefined));
-      console.log(cookieConfig.template({}));
+      console.log(Default(cookieConfig, {}));
    });
    /*const userpool = new MemoryUserPool([
       { id: 1, email: "d", username: "test", password: await hash.sha256("test") },

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

@@ -3,10 +3,8 @@ import { OAuthStrategy } from "../../../src/auth/authenticate/strategies";
 
 const ALL_TESTS = !!process.env.ALL_TESTS;
 
-// @todo: add mock response
 describe("OAuthStrategy", async () => {
-   return;
+   const strategy = new OAuthStrategy({
-   /*const strategy = new OAuthStrategy({
       type: "oidc",
       client: {
          client_id: process.env.OAUTH_CLIENT_ID!,
@@ -23,7 +21,6 @@ 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);
@@ -45,5 +42,5 @@ describe("OAuthStrategy", async () => {
       console.log("request", request);
 
       await new Promise((resolve) => setTimeout(resolve, 100000));
-   });*/
+   });
 });

app/__test__/core/EventManager.spec.ts

@@ -70,9 +70,6 @@ describe("EventManager", async () => {
       new SpecialEvent({ foo: "bar" });
       new InformationalEvent();
 
-      // execute asyncs
-      await emgr.executeAsyncs();
-
       expect(call).toHaveBeenCalledTimes(2);
       expect(delayed).toHaveBeenCalled();
    });
@@ -83,11 +80,15 @@ describe("EventManager", async () => {
          call();
          return Promise.all(p);
       };
-      const emgr = new EventManager({ InformationalEvent });
+      const emgr = new EventManager(
+         { InformationalEvent },
+         {
+            asyncExecutor,
+         },
+      );
 
       emgr.onEvent(InformationalEvent, async () => {});
       await emgr.emit(new InformationalEvent());
-      await emgr.executeAsyncs(asyncExecutor);
       expect(call).toHaveBeenCalled();
    });
 
@@ -124,9 +125,6 @@ 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,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { Registry } from "core";
+import type { TObject, TString } from "@sinclair/typebox";
-import { s } from "core/object/schema";
+import { Registry } from "../../src/core/registry/Registry";
+import { type TSchema, Type } from "../../src/core/utils";
 
 type Constructor<T> = new (...args: any[]) => T;
 
@@ -11,7 +12,7 @@ class What {
       return null;
    }
    getType() {
-      return s.object({ type: s.string() });
+      return Type.Object({ type: Type.String() });
    }
 }
 class What2 extends What {}
@@ -19,7 +20,7 @@ class NotAllowed {}
 
 type Test1 = {
    cls: new (...args: any[]) => What;
-   schema: s.ObjectSchema<{ type: s.StringSchema }>;
+   schema: TObject<{ type: TString }>;
    enabled: boolean;
 };
 
@@ -28,7 +29,7 @@ describe("Registry", () => {
       const registry = new Registry<Test1>().set({
          first: {
             cls: What,
-            schema: s.object({ type: s.string(), what: s.string() }),
+            schema: Type.Object({ type: Type.String(), what: Type.String() }),
             enabled: true,
          },
       } satisfies Record<string, Test1>);
@@ -37,7 +38,7 @@ describe("Registry", () => {
       expect(item).toBeDefined();
       expect(item?.cls).toBe(What);
 
-      const second = s.object({ type: s.string(), what: s.string() });
+      const second = Type.Object({ type: Type.String(), what: Type.String() });
       registry.add("second", {
          cls: What2,
          schema: second,
@@ -46,7 +47,7 @@ describe("Registry", () => {
       // @ts-ignore
       expect(registry.get("second").schema).toEqual(second);
 
-      const third = s.object({ type: s.string({ default: "1" }), what22: s.string() });
+      const third = Type.Object({ type: Type.String({ default: "1" }), what22: Type.String() });
       registry.add("third", {
          // @ts-expect-error
          cls: NotAllowed,
@@ -56,7 +57,7 @@ describe("Registry", () => {
       // @ts-ignore
       expect(registry.get("third").schema).toEqual(third);
 
-      const fourth = s.object({ type: s.number(), what22: s.string() });
+      const fourth = Type.Object({ type: Type.Number(), what22: Type.String() });
       registry.add("fourth", {
          cls: What,
          // @ts-expect-error
@@ -81,8 +82,6 @@ describe("Registry", () => {
       registry.register("what2", What2);
       expect(registry.get("what2")).toBeDefined();
       expect(registry.get("what2").cls).toBe(What2);
-      expect(JSON.stringify(registry.get("what2").schema)).toEqual(
+      expect(registry.get("what2").schema).toEqual(What2.prototype.getType());
-         JSON.stringify(What2.prototype.getType()),
-      );
    });
 });

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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,84 @@
+//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 { s } from "core/object/schema";
+import { Type } from "../../../src/core/utils";
 
 describe("SchemaObject", async () => {
    test("basic", async () => {
       const m = new SchemaObject(
-         s.strictObject({ a: s.string({ default: "b" }) }),
+         Type.Object({ a: Type.String({ default: "b" }) }),
          { a: "test" },
          {
             forceParse: true,
@@ -23,19 +23,19 @@ describe("SchemaObject", async () => {
 
    test("patch", async () => {
       const m = new SchemaObject(
-         s.strictObject({
+         Type.Object({
-            s: s.strictObject(
+            s: Type.Object(
                {
-                  a: s.string({ default: "b" }),
+                  a: Type.String({ default: "b" }),
-                  b: s.strictObject(
+                  b: Type.Object(
                      {
-                        c: s.string({ default: "d" }),
+                        c: Type.String({ default: "d" }),
-                        e: s.string({ default: "f" }),
+                        e: Type.String({ default: "f" }),
                      },
                      { default: {} },
                   ),
                },
-               { default: {} },
+               { default: {}, additionalProperties: false },
             ),
          }),
       );
@@ -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")).rejects.toThrow();
+      expect(() => m.patch("s.s.s", "c")).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(
-         s.strictObject({
+         Type.Object({
-            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
+            methods: Type.Array(Type.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(
-         s.object({
+         Type.Object({
-            s: s.object(
+            s: Type.Object(
                {
-                  a: s.string({ default: "b" }),
+                  a: Type.String({ default: "b" }),
-                  b: s.object(
+                  b: Type.Object(
                      {
-                        c: s.string({ default: "d" }),
+                        c: Type.String({ default: "d" }),
                      },
                      { default: {} },
                   ),
@@ -107,8 +107,8 @@ describe("SchemaObject", async () => {
 
    test("set", async () => {
       const m = new SchemaObject(
-         s.strictObject({
+         Type.Object({
-            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
+            methods: Type.Array(Type.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(
-         s.strictObject({
+         Type.Object({
-            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
+            methods: Type.Array(Type.String(), { default: ["GET", "PATCH"] }),
          }),
          undefined,
          {
@@ -145,8 +145,8 @@ describe("SchemaObject", async () => {
    test("listener: onBeforeUpdate", async () => {
       let called = false;
       const m = new SchemaObject(
-         s.strictObject({
+         Type.Object({
-            methods: s.array(s.string(), { default: ["GET", "PATCH"] }),
+            methods: Type.Array(Type.String(), { default: ["GET", "PATCH"] }),
          }),
          undefined,
          {
@@ -167,7 +167,7 @@ describe("SchemaObject", async () => {
    });
 
    test("throwIfRestricted", async () => {
-      const m = new SchemaObject(s.strictObject({}), undefined, {
+      const m = new SchemaObject(Type.Object({}), undefined, {
          restrictPaths: ["a.b"],
       });
 
@@ -179,13 +179,13 @@ describe("SchemaObject", async () => {
 
    test("restriction bypass", async () => {
       const m = new SchemaObject(
-         s.strictObject({
+         Type.Object({
-            s: s.strictObject(
+            s: Type.Object(
                {
-                  a: s.string({ default: "b" }),
+                  a: Type.String({ default: "b" }),
-                  b: s.strictObject(
+                  b: Type.Object(
                      {
-                        c: s.string({ default: "d" }),
+                        c: Type.String({ default: "d" }),
                      },
                      { default: {} },
                   ),
@@ -205,21 +205,7 @@ describe("SchemaObject", async () => {
       expect(m.get()).toEqual({ s: { a: "b", b: { c: "e" } } });
    });
 
-   const dataEntitiesSchema = s.strictObject({
+   const dataEntitiesSchema = Type.Object(
-      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(
             {},
@@ -244,7 +230,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 "core/object/query/object-query";
+import { type ObjectQuery, convert, validate } from "../../../src/core/object/query/object-query";
 
 describe("object-query", () => {
    const q: ObjectQuery = { name: "Michael" };

app/__test__/core/utils.spec.ts

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { Perf, ucFirst } from "../../src/core/utils";
+import { Perf, datetimeStringUTC, isBlob, 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) => {
@@ -76,6 +75,57 @@ 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 () => {
@@ -196,76 +246,6 @@ 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.only("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", () => {
          expect(utils.datetimeStringUTC("2025-02-21T16:48:25.841Z")).toBe("2025-02-21 16:48:25");

app/__test__/data/DataController.spec.ts

@@ -1,19 +1,19 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 
 import { Guard } from "../../src/auth";
-import { parse } from "core/object/schema";
+import { parse } from "../../src/core/utils";
 import {
    Entity,
    type EntityData,
    EntityManager,
    ManyToOneRelation,
+   type MutatorResponse,
+   type RepositoryResponse,
    TextField,
 } from "../../src/data";
 import { DataController } from "../../src/data/api/DataController";
 import { dataConfigSchema } from "../../src/data/data-schema";
 import { disableConsoleLog, enableConsoleLog, getDummyConnection } from "../helper";
-import type { RepositoryResultJSON } from "data/entities/query/RepositoryResult";
-import type { MutatorResultJSON } from "data/entities/mutation/MutatorResult";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
 beforeAll(() => disableConsoleLog(["log", "warn"]));
@@ -21,6 +21,52 @@ 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 }),
@@ -74,7 +120,8 @@ describe("[data] DataController", async () => {
                method: "POST",
                body: JSON.stringify(_user),
             });
-            const result = (await res.json()) as MutatorResultJSON;
+            //console.log("res", { _user }, res);
+            const result = (await res.json()) as MutatorResponse;
             const { id, ...data } = result.data as any;
 
             expect(res.status).toBe(201);
@@ -88,7 +135,7 @@ describe("[data] DataController", async () => {
                method: "POST",
                body: JSON.stringify(_post),
             });
-            const result = (await res.json()) as MutatorResultJSON;
+            const result = (await res.json()) as MutatorResponse;
             const { id, ...data } = result.data as any;
 
             expect(res.status).toBe(201);
@@ -99,13 +146,13 @@ describe("[data] DataController", async () => {
 
       test("/:entity (read many)", async () => {
          const res = await app.request("/entity/users");
-         const data = (await res.json()) as RepositoryResultJSON;
+         const data = (await res.json()) as RepositoryResponse;
 
-         //expect(data.meta.total).toBe(3);
+         expect(data.meta.total).toBe(3);
-         //expect(data.meta.count).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 () => {
@@ -118,32 +165,33 @@ describe("[data] DataController", async () => {
                where: { bio: { $isnull: 1 } },
             }),
          });
-         const data = (await res.json()) as RepositoryResultJSON;
+         const data = (await res.json()) as RepositoryResponse;
 
-         //expect(data.meta.total).toBe(3);
+         expect(data.meta.total).toBe(3);
-         //expect(data.meta.count).toBe(1);
+         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 RepositoryResultJSON;
+         const data = (await res.json()) as RepositoryResponse;
 
-         //expect(data.meta.total).toBe(3);
+         expect(data.meta.total).toBe(3);
-         //expect(data.meta.count).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 RepositoryResultJSON<EntityData>;
+         const data = (await res.json()) as RepositoryResponse<EntityData>;
+         console.log("data", data);
 
-         //expect(data.meta.total).toBe(3);
+         expect(data.meta.total).toBe(3);
-         //expect(data.meta.count).toBe(1);
+         expect(data.meta.count).toBe(1);
          expect(data.meta.items).toBe(1);
          expect(data.data).toEqual({ id: 3, ...fixtures.users[2] });
       });
@@ -153,7 +201,7 @@ describe("[data] DataController", async () => {
             method: "PATCH",
             body: JSON.stringify({ name: "new name" }),
          });
-         const { data } = (await res.json()) as MutatorResultJSON;
+         const { data } = (await res.json()) as MutatorResponse;
 
          expect(res.ok).toBe(true);
          expect(data as any).toEqual({ id: 3, ...fixtures.users[2], name: "new name" });
@@ -161,26 +209,27 @@ 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 RepositoryResultJSON;
+         const data = (await res.json()) as RepositoryResponse;
+         console.log("data", data);
 
-         //expect(data.meta.total).toBe(2);
+         expect(data.meta.total).toBe(2);
-         //expect(data.meta.count).toBe(1);
+         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 RepositoryResultJSON<EntityData>;
+         const { data } = (await res.json()) as RepositoryResponse<EntityData>;
          expect(data).toEqual({ id: 2, ...fixtures.posts[1] });
 
          // verify
          const res2 = await app.request("/entity/posts");
-         const data2 = (await res2.json()) as RepositoryResultJSON;
+         const data2 = (await res2.json()) as RepositoryResponse;
-         //expect(data2.meta.total).toBe(1);
+         expect(data2.meta.total).toBe(1);
       });
    });
 });

app/__test__/data/data-query-impl.spec.ts

@@ -1,18 +1,25 @@
-import { describe, test, expect } from "bun:test";
+import { describe, expect, test } from "bun:test";
-import { getDummyConnection } from "../helper";
+import { Value, _jsonp } from "../../src/core/utils";
-import { type WhereQuery, WhereBuilder } from "data";
+import { type RepoQuery, WhereBuilder, type WhereQuery, querySchema } from "../../src/data";
+import type { RepoQueryIn } from "../../src/data/server/data-query-impl";
+import { getDummyConnection } from "./helper";
 
-function qb() {
+const decode = (input: RepoQueryIn, expected: RepoQuery) => {
-   const c = getDummyConnection();
+   const result = Value.Decode(querySchema, input);
-   const kysely = c.dummyConnection.kysely;
+   expect(result).toEqual(expected);
-   return kysely.selectFrom("t").selectAll();
+};
-}
+
-function compile(q: WhereQuery) {
+describe("data-query-impl", () => {
-   const { sql, parameters } = WhereBuilder.addClause(qb(), q).compile();
+   function qb() {
-   return { sql, parameters };
+      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]],
@@ -87,4 +94,64 @@ describe("WhereBuilder", () => {
          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/data.test.ts

@@ -34,12 +34,19 @@ 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.data).toBeUndefined();
+      expect(query.result).toEqual([]);
    });
 
    test("findMany", async () => {
@@ -49,7 +56,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.data).toEqual([]);
+      expect(query.result).toEqual([]);
    });
 
    test("findMany with number", async () => {
@@ -59,7 +66,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.data).toEqual([]);
+      expect(query.result).toEqual([]);
    });
 
    test("try adding an existing field name", async () => {
@@ -103,18 +110,4 @@ 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/mutation.simple.test.ts

@@ -45,7 +45,7 @@ describe("Mutator simple", async () => {
          },
       });
 
-      expect(query.data).toEqual([{ id: 1, label: "test", count: 1 }]);
+      expect(query.result).toEqual([{ id: 1, label: "test", count: 1 }]);
    });
 
    test("update inserted row", async () => {
@@ -87,7 +87,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.data).toBeUndefined();
+      expect(query2.result.length).toBe(0);
    });
 
    test("validation: insert incomplete row", async () => {
@@ -177,13 +177,13 @@ describe("Mutator simple", async () => {
    });
 
    test("insertMany", async () => {
-      const oldCount = (await em.repo(items).count()).data.count;
+      const oldCount = (await em.repo(items).count()).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()).data.count;
+      const newCount = (await em.repo(items).count()).count;
       expect(newCount).toBe(oldCount + inserts.length);
 
       const { data: data2 } = await em.repo(items).findMany({ offset: oldCount });

app/__test__/data/polymorphic.test.ts

@@ -1,5 +1,5 @@
 import { afterAll, expect as bunExpect, describe, test } from "bun:test";
-import { stripMark } from "core/object/schema";
+import { stripMark } from "../../src/core/utils";
 import { Entity, EntityManager, PolymorphicRelation, TextField } from "../../src/data";
 import { getDummyConnection } from "./helper";
 

app/__test__/data/prototype.test.ts

@@ -101,8 +101,7 @@ describe("prototype", () => {
 
       type Posts = Schema<typeof posts2>;
 
-      // @todo: check
+      expect(posts1.toJSON()).toEqual(posts2.toJSON());
-      //expect(posts1.toJSON()).toEqual(posts2.toJSON());
    });
 
    test("test example", async () => {

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

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { Entity, NumberField, TextField } from "data";
+import { Entity, NumberField, TextField } from "../../../src/data";
-import * as p from "data/prototype";
 
 describe("[data] Entity", async () => {
    const entity = new Entity("test", [
@@ -48,7 +47,14 @@ describe("[data] Entity", async () => {
       expect(entity.getField("new_field")).toBe(field);
    });
 
-   test.only("types", async () => {
+   // @todo: move this to ClientApp
-      console.log(entity.toTypes());
+   /*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

@@ -47,8 +47,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("users")).toEqual([em.relations.all[0]]);
-      expect(em.relationsOf("posts")).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/Mutator.spec.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, describe, expect, test } from "bun:test";
 import type { EventManager } from "../../../src/core/events";
 import {
    Entity,
@@ -12,14 +12,11 @@ import {
    TextField,
 } from "../../../src/data";
 import * as proto from "../../../src/data/prototype";
-import { getDummyConnection, disableConsoleLog, enableConsoleLog } from "../../helper";
+import { getDummyConnection } from "../helper";
 
 const { dummyConnection, afterAllCleanup } = getDummyConnection();
 afterAll(afterAllCleanup);
 
-beforeAll(() => disableConsoleLog(["log", "warn"]));
-afterAll(async () => (await afterAllCleanup()) && enableConsoleLog());
-
 describe("[data] Mutator (base)", async () => {
    const entity = new Entity("items", [
       new TextField("label", { required: true }),
@@ -291,17 +288,14 @@ 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,6 +1,6 @@
 import { afterAll, describe, expect, test } from "bun:test";
 import type { Kysely, Transaction } from "kysely";
-import { Perf } from "core/utils";
+import { Perf } from "../../../src/core/utils";
 import {
    Entity,
    EntityManager,
@@ -8,10 +8,7 @@ import {
    ManyToOneRelation,
    RepositoryEvents,
    TextField,
-   entity as $entity,
+} from "../../../src/data";
-   text as $text,
-   em as $em,
-} from "data";
 import { getDummyConnection } from "../helper";
 
 type E = Kysely<any> | Transaction<any>;
@@ -26,6 +23,120 @@ 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);
@@ -46,88 +157,25 @@ describe("[Repository]", async () => {
       // count all
       const res = await em.repository(items).count();
       expect(res.sql).toBe('select count(*) as "count" from "items"');
-      expect(res.data.count).toBe(3);
+      expect(res.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
+      const res2 = await em.repository(items).count({ label: { $in: ["a", "b"] } });
-         .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.data.count).toBe(2);
+      expect(res2.count).toBe(2);
 
       // check exists
       const res3 = await em.repository(items).exists({ label: "a" });
-      expect(res3.data.exists).toBe(true);
+      expect(res3.exists).toBe(true);
 
       const res4 = await em.repository(items).exists({ label: "d" });
-      expect(res4.data.exists).toBe(false);
+      expect(res4.exists).toBe(false);
 
       // for now, allow empty filter
       const res5 = await em.repository(items).exists({});
-      expect(res5.data.exists).toBe(true);
+      expect(res5.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]);
    });
 });
 
@@ -150,36 +198,24 @@ describe("[data] Repository (Events)", async () => {
    });
 
    test("events were fired", async () => {
-      const repo = em.repository(items);
+      await em.repository(items).findId(1);
-      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 repo.findOne({ id: 1 });
+      await em.repository(items).findOne({ id: 1 });
-      await repo.emgr.executeAsyncs();
       expect(events.has(RepositoryEvents.RepositoryFindOneBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindOneAfter.slug)).toBeTrue();
       events.clear();
 
-      await repo.findMany({ where: { id: 1 } });
+      await em.repository(items).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 repo.findManyByReference(1, "categories");
+      await em.repository(items).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/WithBuilder.spec.ts

@@ -89,9 +89,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 ?) 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 ? offset ?) as obj) as "author" from "posts"',
       );
-      expect(res2.parameters).toEqual([1]);
+      expect(res2.parameters).toEqual([1, 0]);
    });
 
    test("test with empty join", async () => {
@@ -194,9 +194,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 ?) 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 ? offset ?) as obj) as "single" from "categories"',
       );
-      expect(res.parameters).toEqual(["categories.single", 1]);
+      expect(res.parameters).toEqual(["categories.single", 1, 0]);
 
       const qb2 = WithBuilder.addClause(
          em,
@@ -273,9 +273,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 ?) 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"',
+            '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"',
          );
-         expect(qb.compile().parameters).toEqual(["users.avatar", 1, 1]);
+         expect(qb.compile().parameters).toEqual(["users.avatar", 1, 0, 1, 0]);
       });
 
       test("compiles with many", async () => {
@@ -315,9 +315,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 ?) 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 ? 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"',
          );
-         expect(qb.compile().parameters).toEqual([1, 12, 0]);
+         expect(qb.compile().parameters).toEqual([1, 0, 12, 0]);
       });
 
       test("returns correct result", async () => {

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

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

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

@@ -1,15 +1,9 @@
 import { describe, expect, test } from "bun:test";
-import { DateField, dateFieldConfigSchema } from "../../../../src/data";
+import { DateField } from "../../../../src/data";
-import { fieldTestSuite } from "data/fields/field-test-suite";
+import { runBaseFieldTests } from "./inc";
-import { bunTestRunner } from "adapter/bun/test";
 
 describe("[data] DateField", async () => {
-   fieldTestSuite(
+   runBaseFieldTests(DateField, { defaultValue: new Date(), schemaType: "date" });
-      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,15 +1,13 @@
 import { describe, expect, test } from "bun:test";
 import { EnumField } from "../../../../src/data";
-import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
+import { runBaseFieldTests, transformPersist } from "./inc";
 
 function options(strings: string[]) {
    return { type: "strings", values: strings };
 }
 
 describe("[data] EnumField", async () => {
-   fieldTestSuite(
+   runBaseFieldTests(
-      { expect, test },
-      // @ts-ignore
       EnumField,
       { defaultValue: "a", schemaType: "text" },
       { options: options(["a", "b", "c"]) },
@@ -17,13 +15,11 @@ 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();
@@ -33,7 +29,6 @@ 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,8 +1,7 @@
 import { describe, expect, test } from "bun:test";
+import { Default, stripMark } from "../../../../src/core/utils";
 import { baseFieldConfigSchema, Field } from "../../../../src/data/fields/Field";
-import { fieldTestSuite } from "data/fields/field-test-suite";
+import { runBaseFieldTests } from "./inc";
-import { bunTestRunner } from "adapter/bun/test";
-import { stripMark } from "core/object/schema";
 
 describe("[data] Field", async () => {
    class FieldSpec extends Field {
@@ -20,10 +19,10 @@ describe("[data] Field", async () => {
       });
    });
 
-   fieldTestSuite(bunTestRunner, FieldSpec, { defaultValue: "test", schemaType: "text" });
+   runBaseFieldTests(FieldSpec, { defaultValue: "test", schemaType: "text" });
 
    test("default config", async () => {
-      const config = baseFieldConfigSchema.template({});
+      const config = Default(baseFieldConfigSchema, {});
       expect(stripMark(new FieldSpec("test").config)).toEqual(config as any);
    });
 

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

@@ -1,13 +1,19 @@
 import { describe, expect, test } from "bun:test";
-import { Entity, EntityIndex, Field } from "../../../../src/data";
+import { Type } from "../../../../src/core/utils";
-import { s } from "core/object/schema";
+import {
+   Entity,
+   EntityIndex,
+   type EntityManager,
+   Field,
+   type SchemaResponse,
+} from "../../../../src/data";
 
 class TestField extends Field {
    protected getSchema(): any {
-      return s.any();
+      return Type.Any();
    }
 
-   override schema() {
+   schema(em: EntityManager<any>): SchemaResponse {
       return undefined as any;
    }
 }

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

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

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

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

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

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

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

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

app/__test__/data/specs/fields/inc.ts

@@ -1,7 +1,7 @@
-import type { BaseFieldConfig, Field, TActionContext } from "data";
+import { expect, test } from "bun:test";
 import type { ColumnDataType } from "kysely";
 import { omit } from "lodash-es";
-import type { TestRunner } from "core/test";
+import type { BaseFieldConfig, Field, TActionContext } from "../../../../src/data";
 
 type ConstructableField = new (name: string, config?: Partial<BaseFieldConfig>) => Field;
 
@@ -15,13 +15,11 @@ export function transformPersist(field: Field, value: any, context?: TActionCont
    return field.transformPersist(value, undefined as any, context as any);
 }
 
-export function fieldTestSuite(
+export function runBaseFieldTests(
-   testRunner: TestRunner,
    fieldClass: ConstructableField,
    config: FieldTestConfig,
    _requiredConfig: any = {},
 ) {
-   const { test, expect } = testRunner;
    const noConfigField = new fieldClass("no_config", _requiredConfig);
    const fillable = new fieldClass("fillable", { ..._requiredConfig, fillable: true });
    const required = new fieldClass("required", { ..._requiredConfig, required: true });
@@ -50,7 +48,7 @@ export function fieldTestSuite(
       expect(noConfigField.hasDefault()).toBe(false);
       expect(noConfigField.getDefault()).toBeUndefined();
       expect(dflt.hasDefault()).toBe(true);
-      expect(dflt.getDefault()).toEqual(config.defaultValue);
+      expect(dflt.getDefault()).toBe(config.defaultValue);
    });
 
    test("isFillable", async () => {
@@ -78,9 +76,9 @@ export function fieldTestSuite(
       const isPrimitive = (v) => ["string", "number"].includes(typeof v);
       for (const value of config.sampleValues!) {
          // "form"
-         expect(isPrimitive(noConfigField.getValue(value, "form"))).toBe(true);
+         expect(isPrimitive(noConfigField.getValue(value, "form"))).toBeTrue();
          // "table"
-         expect(isPrimitive(noConfigField.getValue(value, "table"))).toBe(true);
+         expect(isPrimitive(noConfigField.getValue(value, "table"))).toBeTrue();
          // "read"
          // "submit"
       }
@@ -98,7 +96,12 @@ export function fieldTestSuite(
    test("toJSON", async () => {
       const _config = {
          ..._requiredConfig,
+         //order: 1,
+         fillable: true,
          required: false,
+         hidden: false,
+         //virtual: false,
+         //default_value: undefined
       };
 
       function fieldJson(field: Field) {
@@ -110,19 +113,19 @@ export function fieldTestSuite(
       }
 
       expect(fieldJson(noConfigField)).toEqual({
+         //name: "no_config",
          type: noConfigField.type,
          config: _config,
       });
 
       expect(fieldJson(fillable)).toEqual({
+         //name: "fillable",
          type: noConfigField.type,
-         config: {
+         config: _config,
-            ..._config,
-            fillable: true,
-         },
       });
 
       expect(fieldJson(required)).toEqual({
+         //name: "required",
          type: required.type,
          config: {
             ..._config,
@@ -131,6 +134,7 @@ export function fieldTestSuite(
       });
 
       expect(fieldJson(hidden)).toEqual({
+         //name: "hidden",
          type: required.type,
          config: {
             ..._config,
@@ -139,6 +143,7 @@ export function fieldTestSuite(
       });
 
       expect(fieldJson(dflt)).toEqual({
+         //name: "dflt",
          type: dflt.type,
          config: {
             ..._config,
@@ -147,6 +152,7 @@ export function fieldTestSuite(
       });
 
       expect(fieldJson(requiredAndDefault)).toEqual({
+         //name: "full",
          type: requiredAndDefault.type,
          config: {
             ..._config,

app/__test__/flows/FetchTask.spec.ts

@@ -41,7 +41,7 @@ beforeAll(() =>
 );
 afterAll(unmockFetch);
 
-describe.skip("FetchTask", async () => {
+describe("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,23 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { Flow, LogTask, SubFlowTask, RenderTask, Task } from "../../src/flows";
+import { Flow, LogTask, RenderTask, SubFlowTask } from "../../src/flows";
-import { s } from "core/object/schema";
 
-export class StringifyTask<Output extends string> extends Task<
+describe("SubFlowTask", async () => {
-   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",
@@ -38,6 +22,8 @@ describe.skip("SubFlowTask", async () => {
 
       const execution = flow.createExecution();
       await execution.start();
+      /*console.log(execution.logs);
+      console.log(execution.getResponse());*/
 
       expect(execution.getResponse()).toEqual("Subflow output: subflow");
    });
@@ -54,8 +40,8 @@ describe.skip("SubFlowTask", async () => {
          loop: true,
          input: [1, 2, 3],
       });
-      const task3 = new StringifyTask("stringify", {
+      const task3 = new RenderTask("render2", {
-         input: "{{ sub.output }}",
+         render: `Subflow output: {{ sub.output | join: ", " }}`,
       });
 
       const flow = new Flow("test", [task, task2, task3], []);
@@ -65,6 +51,41 @@ describe.skip("SubFlowTask", async () => {
       const execution = flow.createExecution();
       await execution.start();
 
-      expect(execution.getResponse()).toEqual('"run 1,run 2,run 3"');
+      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");
    });
 });

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/object/schema";
 
-describe.skip("Task", async () => {
+describe("Task", async () => {
    test("resolveParams: template with parse", async () => {
       const result = await Task.resolveParams(
-         s.object({ test: dynamic(s.number()) }),
+         Type.Object({ test: dynamic(Type.Number()) }),
          {
             test: "{{ some.path }}",
          },
@@ -22,7 +22,7 @@ describe.skip("Task", async () => {
 
    test("resolveParams: with string", async () => {
       const result = await Task.resolveParams(
-         s.object({ test: s.string() }),
+         Type.Object({ test: Type.String() }),
          {
             test: "{{ some.path }}",
          },
@@ -38,7 +38,7 @@ describe.skip("Task", async () => {
 
    test("resolveParams: with object", async () => {
       const result = await Task.resolveParams(
-         s.object({ test: dynamic(s.object({ key: s.string(), value: s.string() })) }),
+         Type.Object({ test: dynamic(Type.Object({ key: Type.String(), value: Type.String() })) }),
          {
             test: { key: "path", value: "{{ some.path }}" },
          },
@@ -51,4 +51,62 @@ describe.skip("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 { s, parse } from "core/object/schema";
+import { type Static, type StaticDecode, Type, parse } from "../../src/core/utils";
 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 = s.Static<typeof OutputParamTask.schema>;
+type OutputIn = Static<typeof OutputParamTask.schema>;
-type OutputOut = s.StaticCoerced<typeof OutputParamTask.schema>;
+type OutputOut = StaticDecode<typeof OutputParamTask.schema>;
 
 class OutputParamTask extends Task<typeof OutputParamTask.schema> {
    type = "output-param";
 
-   static override schema = s.strictObject({
+   static override schema = Type.Object({
       number: dynamic(
-         s.number({
+         Type.Number({
             title: "Output number",
          }),
          Number.parseInt,
@@ -43,7 +43,7 @@ class PassthroughFlowInput extends Task {
    }
 }
 
-describe.skip("Flow task inputs", async () => {
+describe("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.skip("Flow trigger", async () => {
+describe("Flow trigger", async () => {
    test("manual trigger", async () => {
       let called = false;
 

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

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

app/__test__/helper.ts

@@ -38,15 +38,14 @@ export function getLocalLibsqlConnection() {
    return { url: "http://127.0.0.1:8080" };
 }
 
-type ConsoleSeverity = "debug" | "log" | "warn" | "error";
+type ConsoleSeverity = "log" | "warn" | "error";
 const _oldConsoles = {
-   debug: console.debug,
    log: console.log,
    warn: console.warn,
    error: console.error,
 };
 
-export function disableConsoleLog(severities: ConsoleSeverity[] = ["debug", "log", "warn"]) {
+export function disableConsoleLog(severities: ConsoleSeverity[] = ["log", "warn"]) {
    severities.forEach((severity) => {
       console[severity] = () => null;
    });
@@ -79,7 +78,6 @@ 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/config.integration.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { createApp } from "core/test/utils";
+import { createApp } from "../../src";
 import { Api } from "../../src/Api";
 
 describe("integration config", () => {
@@ -13,8 +13,9 @@ 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" }, asdf: { type: "text" } },
+         fields: { id: { type: "primary", name: "id" }, asdf: { type: "text" } },
          type: "regular",
       });
 

app/__test__/media/MediaController.spec.ts

@@ -1,12 +1,16 @@
 /// <reference types="@types/bun" />
 
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { createApp } from "core/test/utils";
+import { createApp, registries } from "../../src";
 import { mergeObject, randomString } from "../../src/core/utils";
 import type { TAppMediaConfig } from "../../src/media/media-schema";
-import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { StorageLocalAdapter } from "../../src/media/storage/adapters/StorageLocalAdapter";
 import { assetsPath, assetsTmpPath, disableConsoleLog, enableConsoleLog } from "../helper";
 
+beforeAll(() => {
+   registries.media.register("local", StorageLocalAdapter);
+});
+
 const path = `${assetsPath}/image.png`;
 
 async function makeApp(mediaOverride: Partial<TAppMediaConfig> = {}) {
@@ -27,8 +31,6 @@ async function makeApp(mediaOverride: Partial<TAppMediaConfig> = {}) {
       },
    });
 
-   app.module.media.adapters.set("local", StorageLocalAdapter);
-
    await app.build();
    return app;
 }
@@ -41,7 +43,7 @@ beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
 
 describe("MediaController", () => {
-   test("accepts direct", async () => {
+   test.only("accepts direct", async () => {
       const app = await makeApp();
 
       const file = Bun.file(path);

app/__test__/media/Storage.spec.ts

@@ -1,9 +1,8 @@
 import { describe, expect, test } from "bun:test";
-import { type FileBody, Storage } from "../../src/media/storage/Storage";
+import { type FileBody, Storage, type StorageAdapter } from "../../src/media/storage/Storage";
 import * as StorageEvents from "../../src/media/storage/events";
-import { StorageAdapter } from "media";
 
-class TestAdapter extends StorageAdapter {
+class TestAdapter implements StorageAdapter {
    files: Record<string, FileBody> = {};
 
    getName() {
@@ -62,7 +61,7 @@ describe("Storage", async () => {
    test("uploads a file", async () => {
       const {
          meta: { type, size },
-      } = await storage.uploadFile("hello" as any, "world.txt");
+      } = await storage.uploadFile("hello", "world.txt");
       expect({ type, size }).toEqual({ type: "text/plain", size: 0 });
    });
 
@@ -72,7 +71,6 @@ 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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,109 @@
+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,9 +5,7 @@ import { getRandomizedFilename } from "../../src/media/utils";
 
 describe("media/mime-types", () => {
    test("tiny resolves", () => {
-      const tests = [
+      const tests = [[".mp4", "video/mp4", ".jpg", "image/jpeg", ".zip", "application/zip"]];
-         [".mp4", "video/mp4", ".jpg", "image/jpeg", ".zip", "application/zip"],
-      ] as const;
 
       for (const [ext, mime] of tests) {
          expect(tiny.guess(ext)).toBe(mime);
@@ -71,7 +69,7 @@ describe("media/mime-types", () => {
          ["application/zip", "zip"],
          ["text/tab-separated-values", "tsv"],
          ["application/zip", "zip"],
-      ] as const;
+      ];
 
       for (const [mime, ext] of tests) {
          expect(tiny.extension(mime), `extension(): ${mime} should be ${ext}`).toBe(ext);
@@ -88,7 +86,7 @@ describe("media/mime-types", () => {
          ["image.jpeg", "jpeg"],
          ["-473Wx593H-466453554-black-MODEL.jpg", "jpg"],
          ["-473Wx593H-466453554-black-MODEL.avif", "avif"],
-      ] as const;
+      ];
 
       for (const [filename, ext] of tests) {
          expect(
@@ -96,10 +94,5 @@ 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");
    });
 });

app/__test__/modules/AppAuth.spec.ts

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import { createApp } from "core/test/utils";
+import { createApp } from "../../src";
 import { AuthController } from "../../src/auth/api/AuthController";
 import { em, entity, make, text } from "../../src/data";
 import { AppAuth, type ModuleBuildContext } from "../../src/modules";
@@ -8,12 +8,6 @@ import { disableConsoleLog, enableConsoleLog } from "../helper";
 import { makeCtx, moduleTestSuite } from "./module-test-suite";
 
 describe("AppAuth", () => {
-   test.only("...", () => {
-      const auth = new AppAuth({});
-      console.log(auth.toJSON());
-      console.log(auth.config);
-   });
-
    moduleTestSuite(AppAuth);
 
    let ctx: ModuleBuildContext;
@@ -75,7 +69,7 @@ describe("AppAuth", () => {
             },
             body: JSON.stringify({
                email: "some@body.com",
-               password: "12345678",
+               password: "123456",
             }),
          });
          enableConsoleLog();
@@ -87,65 +81,6 @@ 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: {
@@ -159,7 +94,6 @@ describe("AppAuth", () => {
       });
 
       await app.build();
-      app.registerAdminController();
       const spy = spyOn(app.module.auth.authenticator, "requestCookieRefresh");
 
       // register custom route
@@ -169,10 +103,6 @@ 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);
    });
 

app/__test__/modules/AppData.spec.ts

@@ -1,51 +1,13 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
-import { parse } from "core/object/schema";
+import { parse } from "../../src/core/utils";
 import { fieldsSchema } from "../../src/data/data-schema";
-import { AppData, type ModuleBuildContext } from "../../src/modules";
+import { AppData } from "../../src/modules";
-import { makeCtx, moduleTestSuite } from "./module-test-suite";
+import { 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,15 +1,15 @@
 import { describe, expect, test } from "bun:test";
-import { createApp } from "core/test/utils";
+import { createApp, registries } from "../../src";
 import { em, entity, text } from "../../src/data";
-import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
+import { StorageLocalAdapter } from "../../src/media/storage/adapters/StorageLocalAdapter";
-import { AppMedia } from "../../src/media/AppMedia";
+import { AppMedia } from "../../src/modules";
 import { moduleTestSuite } from "./module-test-suite";
 
 describe("AppMedia", () => {
    moduleTestSuite(AppMedia);
 
    test("should allow additional fields", async () => {
-      //registries.media.register("local", StorageLocalAdapter);
+      registries.media.register("local", StorageLocalAdapter);
 
       const app = createApp({
          initialConfig: {
@@ -30,7 +30,6 @@ describe("AppMedia", () => {
             }).toJSON(),
          },
       });
-      app.module.media.adapters.set("local", StorageLocalAdapter);
 
       await app.build();
 

app/__test__/modules/Module.spec.ts

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

app/__test__/modules/ModuleManager.spec.ts

@@ -1,11 +1,10 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
+import { Type, disableConsoleLog, enableConsoleLog, stripMark } from "../../src/core/utils";
-import { Connection, entity, text } from "data";
+import { entity, text } from "../../src/data";
-import { Module } from "modules/Module";
+import { Module } from "../../src/modules/Module";
-import { type ConfigTable, getDefaultConfig, ModuleManager } from "modules/ModuleManager";
+import { ModuleManager, getDefaultConfig } from "../../src/modules/ModuleManager";
-import { CURRENT_VERSION, TABLE_NAME } from "modules/migrations";
+import { CURRENT_VERSION, TABLE_NAME } from "../../src/modules/migrations";
 import { getDummyConnection } from "../helper";
-import { s, stripMark } from "core/object/schema";
 
 describe("ModuleManager", async () => {
    test("s1: no config, no build", async () => {
@@ -90,11 +89,7 @@ describe("ModuleManager", async () => {
 
       await mm2.build();
 
-      /* console.log({
+      expect(stripMark(json)).toEqual(stripMark(mm2.configs()));
-         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();
@@ -259,10 +254,10 @@ describe("ModuleManager", async () => {
    // @todo: add tests for migrations (check "backup" and new version)
 
    describe("revert", async () => {
-      const failingModuleSchema = s.partialObject({
+      const failingModuleSchema = Type.Object({
-         value: s.number(),
+         value: Type.Optional(Type.Number()),
       });
-      class FailingModule extends Module<s.Static<typeof failingModuleSchema>> {
+      class FailingModule extends Module<typeof failingModuleSchema> {
          getSchema() {
             return failingModuleSchema;
          }
@@ -385,128 +380,4 @@ 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/module-test-suite.ts

@@ -4,14 +4,14 @@ 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 { getDummyConnection } from "../helper";
-import { ModuleHelper } from "modules/ModuleHelper";
 
 export function makeCtx(overrides?: Partial<ModuleBuildContext>): ModuleBuildContext {
    const { dummyConnection } = getDummyConnection();
-   const ctx = {
+   return {
       connection: dummyConnection,
       server: new Hono(),
       em: new EntityManager([], dummyConnection),
@@ -21,10 +21,6 @@ export function makeCtx(overrides?: Partial<ModuleBuildContext>): ModuleBuildCon
       logger: new DebugLogger(false),
       ...overrides,
    };
-   return {
-      ...ctx,
-      helper: new ModuleHelper(ctx as any),
-   } as any;
 }
 
 export function moduleTestSuite(module: { new (): Module }) {
@@ -44,8 +40,7 @@ export function moduleTestSuite(module: { new (): Module }) {
       it("uses the default config", async () => {
          const m = new module();
          await m.setContext(ctx).build();
-         expect(m.toJSON()).toEqual(m.getSchema().template({}, { withOptional: true }));
+         expect(stripMark(m.toJSON())).toEqual(Default(m.getSchema(), {}));
-         //expect(stripMark(m.toJSON())).toEqual(Default(m.getSchema(), {}));
       });
    });
 }

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

@@ -1,12 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,23 +0,0 @@
-import pkg from "./package.json" with { type: "json" };
-import c from "picocolors";
-import { formatNumber } from "core/utils";
-
-const result = await Bun.build({
-   entrypoints: ["./src/cli/index.ts"],
-   target: "node",
-   outdir: "./dist/cli",
-   env: "PUBLIC_*",
-   minify: true,
-   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,6 +1,5 @@
 import { $ } from "bun";
 import * as tsup from "tsup";
-import pkg from "./package.json" with { type: "json" };
 
 const args = process.argv.slice(2);
 const watch = args.includes("--watch");
@@ -9,13 +8,8 @@ const types = args.includes("--types");
 const sourcemap = args.includes("--sourcemap");
 const clean = args.includes("--clean");
 
-const define = {
-   __isDev: "0",
-   __version: JSON.stringify(pkg.version),
-};
-
 if (clean) {
-   console.info("Cleaning dist (w/o static)");
+   console.log("Cleaning dist (w/o static)");
    await $`find dist -mindepth 1 ! -path "dist/static/*" ! -path "dist/static" -exec rm -rf {} +`;
 }
 
@@ -27,11 +21,11 @@ function buildTypes() {
    Bun.spawn(["bun", "build:types"], {
       stdout: "inherit",
       onExit: () => {
-         console.info("Types built");
+         console.log("Types built");
          Bun.spawn(["bun", "tsc-alias"], {
             stdout: "inherit",
             onExit: () => {
-               console.info("Types aliased");
+               console.log("Types aliased");
                types_running = false;
             },
          });
@@ -53,21 +47,14 @@ if (types && !watch) {
 }
 
 function banner(title: string) {
-   console.info("");
+   console.log("");
-   console.info("=".repeat(40));
+   console.log("=".repeat(40));
-   console.info(title.toUpperCase());
+   console.log(title.toUpperCase());
-   console.info("-".repeat(40));
+   console.log("-".repeat(40));
 }
 
 // collection of always-external packages
-const external = [
+const external = ["bun:test", "@libsql/client"] as const;
-   "bun:test",
-   "node:test",
-   "node:assert/strict",
-   "@libsql/client",
-   "bknd",
-   /^bknd\/.*/,
-] as const;
 
 /**
  * Building backend and general API
@@ -78,15 +65,7 @@ async function buildApi() {
       minify,
       sourcemap,
       watch,
-      define,
+      entry: ["src/index.ts", "src/data/index.ts", "src/core/index.ts", "src/core/utils/index.ts"],
-      entry: [
-         "src/index.ts",
-         "src/core/index.ts",
-         "src/core/utils/index.ts",
-         "src/data/index.ts",
-         "src/media/index.ts",
-         "src/plugins/index.ts",
-      ],
       outDir: "dist",
       external: [...external],
       metafile: true,
@@ -116,7 +95,6 @@ async function buildUi() {
       minify,
       sourcemap,
       watch,
-      define,
       external: [
          ...external,
          "react",
@@ -176,7 +154,6 @@ async function buildUiElements() {
       minify,
       sourcemap,
       watch,
-      define,
       entry: ["src/ui/elements/index.ts"],
       outDir: "dist/ui/elements",
       external: [
@@ -228,15 +205,14 @@ function baseConfig(adapter: string, overrides: Partial<tsup.Options> = {}): tsu
       },
       ...overrides,
       define: {
-         ...define,
+         __isDev: "0",
          ...overrides.define,
       },
       external: [
          /^cloudflare*/,
-         /^@?hono.*?/,
+         /^@?(hono|libsql).*?/,
          /^(bknd|react|next|node).*?/,
          /.*\.(html)$/,
-         ...external,
          ...(Array.isArray(overrides.external) ? overrides.external : []),
       ],
    };
@@ -253,14 +229,14 @@ async function buildAdapters() {
 
    // specific adatpers
    await tsup.build(baseConfig("react-router"));
-   await tsup.build(
+   await tsup.build(baseConfig("bun"));
-      baseConfig("bun", {
-         external: [/^bun\:.*/],
-      }),
-   );
    await tsup.build(baseConfig("astro"));
    await tsup.build(baseConfig("aws"));
-   await tsup.build(baseConfig("cloudflare"));
+   await tsup.build(
+      baseConfig("cloudflare", {
+         external: [/^kysely/],
+      }),
+   );
 
    await tsup.build({
       ...baseConfig("vite"),
@@ -276,29 +252,6 @@ async function buildAdapters() {
       ...baseConfig("node"),
       platform: "node",
    });
-
-   await tsup.build({
-      ...baseConfig("sqlite/edge"),
-      entry: ["src/adapter/sqlite/edge.ts"],
-      outDir: "dist/adapter/sqlite",
-      metafile: false,
-   });
-
-   await tsup.build({
-      ...baseConfig("sqlite/node"),
-      entry: ["src/adapter/sqlite/node.ts"],
-      outDir: "dist/adapter/sqlite",
-      platform: "node",
-      metafile: false,
-   });
-
-   await tsup.build({
-      ...baseConfig("sqlite/bun"),
-      entry: ["src/adapter/sqlite/bun.ts"],
-      outDir: "dist/adapter/sqlite",
-      metafile: false,
-      external: [/^bun\:.*/],
-   });
 }
 
 await buildApi();

app/e2e/adapters.ts

@@ -1,218 +0,0 @@
-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.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.log(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.log("adapter", c.cyan(name));
-   await config.clean();
-
-   const { proc, data } = await config.start();
-   console.log("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.log("DONE!");
-
-   while (!proc.killed) {
-      proc.kill("SIGINT");
-      await Bun.sleep(250);
-      console.log("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);
-   }
-}

app/e2e/base.e2e-spec.ts

@@ -1,25 +0,0 @@
-// @ts-check
-import { test, expect } from "@playwright/test";
-import { testIds } from "../src/ui/lib/config";
-
-import { getAdapterConfig } from "./inc/adapters";
-const config = getAdapterConfig();
-
-test("start page has expected title", async ({ page }) => {
-   await page.goto(config.base_path);
-   await expect(page).toHaveTitle(/BKND/);
-});
-
-test("start page has expected heading", async ({ page }) => {
-   await page.goto(config.base_path);
-
-   // Example of checking if a heading with "No entity selected" exists and is visible
-   const heading = page.getByRole("heading", { name: /No entity selected/i });
-   await expect(heading).toBeVisible();
-});
-
-test("modal opens on button click", async ({ page }) => {
-   await page.goto(config.base_path);
-   await page.getByTestId(testIds.data.btnCreateEntity).click();
-   await expect(page.getByRole("dialog")).toBeVisible();
-});

app/e2e/inc/adapters.ts

@@ -1,44 +0,0 @@
-const adapter = process.env.TEST_ADAPTER;
-
-const default_config = {
-   media_adapter: "local",
-   base_path: "",
-} as const;
-
-const configs = {
-   cloudflare: {
-      media_adapter: "r2",
-   },
-   "react-router": {
-      base_path: "/admin",
-   },
-   nextjs: {
-      base_path: "/admin",
-   },
-   astro: {
-      base_path: "/admin",
-   },
-   node: {
-      base_path: "",
-   },
-   bun: {
-      base_path: "",
-   },
-};
-
-export function getAdapterConfig(): typeof default_config {
-   if (adapter) {
-      if (!configs[adapter]) {
-         console.warn(
-            `Adapter "${adapter}" not found. Available adapters: ${Object.keys(configs).join(", ")}`,
-         );
-      } else {
-         return {
-            ...default_config,
-            ...configs[adapter],
-         };
-      }
-   }
-
-   return default_config;
-}

app/e2e/media.e2e-spec.ts

@@ -1,55 +0,0 @@
-// @ts-check
-import { test, expect } from "@playwright/test";
-import { testIds } from "../src/ui/lib/config";
-import type { SchemaResponse } from "../src/modules/server/SystemController";
-import { getAdapterConfig } from "./inc/adapters";
-
-// Annotate entire file as serial.
-test.describe.configure({ mode: "serial" });
-
-const config = getAdapterConfig();
-
-test("can enable media", async ({ page }) => {
-   await page.goto(`${config.base_path}/media/settings`);
-
-   // enable
-   const enableToggle = page.getByTestId(testIds.media.switchEnabled);
-   if ((await enableToggle.getAttribute("aria-checked")) !== "true") {
-      await expect(enableToggle).toBeVisible();
-      await enableToggle.click();
-      await expect(enableToggle).toHaveAttribute("aria-checked", "true");
-
-      // select local
-      const adapterChoice = page.locator(`css=button#adapter-${config.media_adapter}`);
-      await expect(adapterChoice).toBeVisible();
-      await adapterChoice.click();
-
-      // save
-      const saveBtn = page.getByRole("button", { name: /Update/i });
-      await expect(saveBtn).toBeVisible();
-
-      // intercept network request, wait for it to finish and get the response
-      const [request] = await Promise.all([
-         page.waitForRequest((request) => request.url().includes("api/system/schema")),
-         saveBtn.click(),
-      ]);
-      const response = await request.response();
-      expect(response?.status(), "fresh config 200").toBe(200);
-      const body = (await response?.json()) as SchemaResponse;
-      expect(body.config.media.enabled, "media is enabled").toBe(true);
-      expect(body.config.media.adapter?.type, "correct adapter").toBe(config.media_adapter);
-   }
-});
-
-test("can upload a file", async ({ page }) => {
-   await page.goto(`${config.base_path}/media`);
-   // check any text to contain "Upload files"
-   await expect(page.getByText(/Upload files/i)).toBeVisible();
-
-   // upload a file from disk
-   // Start waiting for file chooser before clicking. Note no await.
-   const fileChooserPromise = page.waitForEvent("filechooser");
-   await page.getByText("Upload file").click();
-   const fileChooser = await fileChooserPromise;
-   await fileChooser.setFiles("./e2e/assets/image.jpg");
-});

app/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "sideEffects": false,
   "bin": "./dist/cli/index.js",
-  "version": "0.16.0-rc.0",
+  "version": "0.10.0-rc.5",
   "description": "Lightweight Firebase/Supabase alternative built to run anywhere — incl. Next.js, React Router, Astro, Cloudflare, Bun, Node, AWS Lambda & more.",
   "homepage": "https://bknd.io",
   "repository": {
@@ -13,15 +13,13 @@
   "bugs": {
     "url": "https://github.com/bknd-io/bknd/issues"
   },
-  "engines": {
-    "node": ">=22"
-  },
   "scripts": {
-    "dev": "BKND_CLI_LOG_LEVEL=debug vite",
+    "dev": "vite",
+    "test": "ALL_TESTS=1 bun test --bail",
+    "test:coverage": "ALL_TESTS=1 bun test --bail --coverage",
     "build": "NODE_ENV=production bun run build.ts --minify --types",
     "build:all": "rm -rf dist && bun run build:static && NODE_ENV=production bun run build.ts --minify --types --clean && bun run build:cli",
-    "build:ci": "mkdir -p dist/static/.vite && echo '{}' > dist/static/.vite/manifest.json && NODE_ENV=production bun run build.ts",
+    "build:cli": "bun build src/cli/index.ts --target node --outdir dist/cli --env PUBLIC_* --minify",
-    "build:cli": "bun run build.cli.ts",
     "build:static": "vite build",
     "watch": "bun run build.ts --types --watch",
     "types": "bun tsc -p tsconfig.build.json --noEmit",
@@ -29,84 +27,64 @@
     "build:types": "tsc -p tsconfig.build.json --emitDeclarationOnly && tsc-alias",
     "updater": "bun x npm-check-updates -ui",
     "cli": "LOCAL=1 bun src/cli/index.ts",
-    "prepublishOnly": "bun run types && bun run test && bun run test:node && bun run test:e2e && bun run build:all && cp ../README.md ./",
+    "prepublishOnly": "bun run types && bun run test && bun run build:all && cp ../README.md ./",
-    "postpublish": "rm -f README.md",
+    "postpublish": "rm -f README.md"
-    "test": "ALL_TESTS=1 bun test --bail",
-    "test:all": "bun run test && bun run test:node",
-    "test:bun": "ALL_TESTS=1 bun test --bail",
-    "test:node": "vitest run",
-    "test:adapters": "bun test src/adapter/**/*.adapter.spec.ts --bail",
-    "test:coverage": "ALL_TESTS=1 bun test --bail --coverage",
-    "test:vitest:coverage": "vitest run --coverage",
-    "test:e2e": "playwright test",
-    "test:e2e:adapters": "bun run e2e/adapters.ts",
-    "test:e2e:ui": "playwright test --ui",
-    "test:e2e:debug": "playwright test --debug",
-    "test:e2e:report": "playwright show-report"
   },
   "license": "FSL-1.1-MIT",
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
     "@codemirror/lang-html": "^6.4.9",
     "@codemirror/lang-json": "^6.0.1",
+    "@codemirror/lang-liquid": "^6.2.2",
     "@hello-pangea/dnd": "^18.0.1",
-    "@hono/swagger-ui": "^0.5.1",
+    "@libsql/client": "^0.14.0",
     "@mantine/core": "^7.17.1",
     "@mantine/hooks": "^7.17.1",
+    "@sinclair/typebox": "^0.34.30",
     "@tanstack/react-form": "^1.0.5",
     "@uiw/react-codemirror": "^4.23.10",
     "@xyflow/react": "^12.4.4",
     "aws4fetch": "^1.0.20",
-    "bcryptjs": "^3.0.2",
     "dayjs": "^1.11.13",
     "fast-xml-parser": "^5.0.8",
-    "hono": "^4.7.11",
+    "hono": "^4.7.4",
     "json-schema-form-react": "^0.0.2",
-    "json-schema-library": "10.0.0-rc7",
+    "json-schema-library": "^10.0.0-rc7",
     "json-schema-to-ts": "^3.1.1",
     "kysely": "^0.27.6",
+    "liquidjs": "^10.21.0",
     "lodash-es": "^4.17.21",
     "oauth4webapi": "^2.11.1",
     "object-path-immutable": "^4.1.2",
+    "picocolors": "^1.1.1",
     "radix-ui": "^1.1.3",
     "swr": "^2.3.3"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.758.0",
     "@bluwy/giget-core": "^0.1.2",
-    "@cloudflare/vitest-pool-workers": "^0.8.38",
-    "@cloudflare/workers-types": "^4.20250606.0",
     "@dagrejs/dagre": "^1.1.4",
-    "@hono/vite-dev-server": "^0.19.1",
+    "@hono/typebox-validator": "^0.3.2",
+    "@hono/vite-dev-server": "^0.19.0",
     "@hookform/resolvers": "^4.1.3",
-    "@libsql/client": "^0.15.9",
+    "@libsql/kysely-libsql": "^0.4.1",
     "@mantine/modals": "^7.17.1",
     "@mantine/notifications": "^7.17.1",
-    "@playwright/test": "^1.51.1",
     "@rjsf/core": "5.22.2",
-    "@standard-schema/spec": "^1.0.0",
     "@tabler/icons-react": "3.18.0",
     "@tailwindcss/postcss": "^4.0.12",
     "@tailwindcss/vite": "^4.0.12",
-    "@testing-library/jest-dom": "^6.6.3",
-    "@testing-library/react": "^16.2.0",
     "@types/node": "^22.13.10",
     "@types/react": "^19.0.10",
     "@types/react-dom": "^19.0.4",
     "@vitejs/plugin-react": "^4.3.4",
-    "@vitest/coverage-v8": "^3.0.9",
     "autoprefixer": "^10.4.21",
     "clsx": "^2.1.1",
     "dotenv": "^16.4.7",
     "jotai": "^2.12.2",
-    "jsdom": "^26.0.0",
-    "jsonv-ts": "^0.2.2",
     "kysely-d1": "^0.3.0",
-    "kysely-generic-sqlite": "^1.2.1",
-    "libsql-stateless-easy": "^1.8.0",
     "open": "^10.1.0",
     "openapi-types": "^12.1.3",
-    "picocolors": "^1.1.1",
     "postcss": "^8.5.3",
     "postcss-preset-mantine": "^1.17.0",
     "postcss-simple-vars": "^7.0.1",
@@ -122,16 +100,12 @@
     "tailwindcss-animate": "^1.0.7",
     "tsc-alias": "^1.8.11",
     "tsup": "^8.4.0",
-    "tsx": "^4.19.3",
+    "vite": "^6.2.1",
-    "uuid": "^11.1.0",
-    "vite": "^6.3.5",
-    "vite-plugin-circular-dependency": "^0.5.0",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.9",
     "wouter": "^3.6.0"
   },
   "optionalDependencies": {
-    "@hono/node-server": "^1.14.3"
+    "@hono/node-server": "^1.13.8"
   },
   "peerDependencies": {
     "react": ">=19",
@@ -144,71 +118,47 @@
     ".": {
       "types": "./dist/types/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.js"
+      "require": "./dist/index.cjs"
     },
     "./ui": {
       "types": "./dist/types/ui/index.d.ts",
       "import": "./dist/ui/index.js",
-      "require": "./dist/ui/index.js"
+      "require": "./dist/ui/index.cjs"
     },
     "./elements": {
       "types": "./dist/types/ui/elements/index.d.ts",
       "import": "./dist/ui/elements/index.js",
-      "require": "./dist/ui/elements/index.js"
+      "require": "./dist/ui/elements/index.cjs"
     },
     "./client": {
       "types": "./dist/types/ui/client/index.d.ts",
       "import": "./dist/ui/client/index.js",
-      "require": "./dist/ui/client/index.js"
+      "require": "./dist/ui/client/index.cjs"
     },
     "./data": {
       "types": "./dist/types/data/index.d.ts",
       "import": "./dist/data/index.js",
-      "require": "./dist/data/index.js"
+      "require": "./dist/data/index.cjs"
     },
     "./core": {
       "types": "./dist/types/core/index.d.ts",
       "import": "./dist/core/index.js",
-      "require": "./dist/core/index.js"
+      "require": "./dist/core/index.cjs"
     },
     "./utils": {
       "types": "./dist/types/core/utils/index.d.ts",
       "import": "./dist/core/utils/index.js",
-      "require": "./dist/core/utils/index.js"
+      "require": "./dist/core/utils/index.cjs"
     },
     "./cli": {
       "types": "./dist/types/cli/index.d.ts",
       "import": "./dist/cli/index.js",
-      "require": "./dist/cli/index.js"
+      "require": "./dist/cli/index.cjs"
-    },
-    "./media": {
-      "types": "./dist/types/media/index.d.ts",
-      "import": "./dist/media/index.js",
-      "require": "./dist/media/index.js"
-    },
-    "./plugins": {
-      "types": "./dist/types/plugins/index.d.ts",
-      "import": "./dist/plugins/index.js",
-      "require": "./dist/plugins/index.js"
-    },
-    "./adapter/sqlite": {
-      "types": "./dist/types/adapter/sqlite/edge.d.ts",
-      "import": {
-        "workerd": "./dist/adapter/sqlite/edge.js",
-        "edge-light": "./dist/adapter/sqlite/edge.js",
-        "netlify": "./dist/adapter/sqlite/edge.js",
-        "vercel": "./dist/adapter/sqlite/edge.js",
-        "browser": "./dist/adapter/sqlite/edge.js",
-        "bun": "./dist/adapter/sqlite/bun.js",
-        "node": "./dist/adapter/sqlite/node.js",
-        "default": "./dist/adapter/sqlite/node.js"
-      },
-      "require": "./dist/adapter/sqlite/node.js"
     },
     "./adapter/cloudflare": {
       "types": "./dist/types/adapter/cloudflare/index.d.ts",
       "import": "./dist/adapter/cloudflare/index.js",
-      "require": "./dist/adapter/cloudflare/index.js"
+      "require": "./dist/adapter/cloudflare/index.cjs"
     },
     "./adapter": {
       "types": "./dist/types/adapter/index.d.ts",
@@ -217,60 +167,42 @@
     "./adapter/vite": {
       "types": "./dist/types/adapter/vite/index.d.ts",
       "import": "./dist/adapter/vite/index.js",
-      "require": "./dist/adapter/vite/index.js"
+      "require": "./dist/adapter/vite/index.cjs"
     },
     "./adapter/nextjs": {
       "types": "./dist/types/adapter/nextjs/index.d.ts",
       "import": "./dist/adapter/nextjs/index.js",
-      "require": "./dist/adapter/nextjs/index.js"
+      "require": "./dist/adapter/nextjs/index.cjs"
     },
     "./adapter/react-router": {
       "types": "./dist/types/adapter/react-router/index.d.ts",
       "import": "./dist/adapter/react-router/index.js",
-      "require": "./dist/adapter/react-router/index.js"
+      "require": "./dist/adapter/react-router/index.cjs"
     },
     "./adapter/bun": {
       "types": "./dist/types/adapter/bun/index.d.ts",
       "import": "./dist/adapter/bun/index.js",
-      "require": "./dist/adapter/bun/index.js"
+      "require": "./dist/adapter/bun/index.cjs"
     },
     "./adapter/node": {
       "types": "./dist/types/adapter/node/index.d.ts",
       "import": "./dist/adapter/node/index.js",
-      "require": "./dist/adapter/node/index.js"
+      "require": "./dist/adapter/node/index.cjs"
     },
     "./adapter/astro": {
       "types": "./dist/types/adapter/astro/index.d.ts",
       "import": "./dist/adapter/astro/index.js",
-      "require": "./dist/adapter/astro/index.js"
+      "require": "./dist/adapter/astro/index.cjs"
     },
     "./adapter/aws": {
       "types": "./dist/types/adapter/aws/index.d.ts",
       "import": "./dist/adapter/aws/index.js",
-      "require": "./dist/adapter/aws/index.js"
+      "require": "./dist/adapter/aws/index.cjs"
     },
     "./dist/main.css": "./dist/ui/main.css",
     "./dist/styles.css": "./dist/ui/styles.css",
     "./dist/manifest.json": "./dist/static/.vite/manifest.json"
   },
-  "typesVersions": {
-    "*": {
-      "data": ["./dist/types/data/index.d.ts"],
-      "core": ["./dist/types/core/index.d.ts"],
-      "utils": ["./dist/types/core/utils/index.d.ts"],
-      "cli": ["./dist/types/cli/index.d.ts"],
-      "media": ["./dist/types/media/index.d.ts"],
-      "plugins": ["./dist/types/plugins/index.d.ts"],
-      "adapter": ["./dist/types/adapter/index.d.ts"],
-      "adapter/cloudflare": ["./dist/types/adapter/cloudflare/index.d.ts"],
-      "adapter/vite": ["./dist/types/adapter/vite/index.d.ts"],
-      "adapter/nextjs": ["./dist/types/adapter/nextjs/index.d.ts"],
-      "adapter/react-router": ["./dist/types/adapter/react-router/index.d.ts"],
-      "adapter/bun": ["./dist/types/adapter/bun/index.d.ts"],
-      "adapter/node": ["./dist/types/adapter/node/index.d.ts"],
-      "adapter/sqlite": ["./dist/types/adapter/sqlite/edge.d.ts"]
-    }
-  },
   "publishConfig": {
     "access": "public"
   },

app/playwright.config.ts

@@ -1,43 +0,0 @@
-import { defineConfig, devices } from "@playwright/test";
-
-const baseUrl = process.env.TEST_URL || "http://localhost:28623";
-const startCommand = process.env.TEST_START_COMMAND || "bun run dev";
-const autoStart = ["1", "true", undefined].includes(process.env.TEST_AUTO_START);
-const timeout = process.env.TEST_TIMEOUT ? Number.parseInt(process.env.TEST_TIMEOUT) : 5000;
-
-export default defineConfig({
-   testMatch: "**/*.e2e-spec.ts",
-   testDir: "./e2e",
-   fullyParallel: true,
-   forbidOnly: !!process.env.CI,
-   retries: process.env.CI ? 2 : 0,
-   workers: process.env.CI ? 1 : undefined,
-   reporter: "html",
-   timeout,
-   use: {
-      baseURL: baseUrl,
-      trace: "on-first-retry",
-      video: "on-first-retry",
-   },
-   projects: [
-      {
-         name: "chromium",
-         use: { ...devices["Desktop Chrome"] },
-      },
-      /* {
-         name: "firefox",
-         use: { ...devices["Desktop Firefox"] },
-      },
-      {
-         name: "webkit",
-         use: { ...devices["Desktop Safari"] },
-      }, */
-   ],
-   webServer: autoStart
-      ? {
-           command: startCommand,
-           url: baseUrl,
-           reuseExistingServer: !process.env.CI,
-        }
-      : undefined,
-});

app/src/Api.ts

@@ -1,19 +1,13 @@
 import type { SafeUser } from "auth";
-import { AuthApi, type AuthApiOptions } from "auth/api/AuthApi";
+import { AuthApi } from "auth/api/AuthApi";
-import { DataApi, type DataApiOptions } from "data/api/DataApi";
+import { DataApi } from "data/api/DataApi";
 import { decode } from "hono/jwt";
-import { MediaApi, type MediaApiOptions } from "media/api/MediaApi";
+import { MediaApi } from "media/api/MediaApi";
 import { SystemApi } from "modules/SystemApi";
 import { omitKeys } from "core/utils";
-import type { BaseModuleApiOptions } from "modules";
 
 export type TApiUser = SafeUser;
 
-export type ApiFetcher = (
-   input: RequestInfo | URL,
-   init?: RequestInit,
-) => Response | Promise<Response>;
-
 declare global {
    interface Window {
       __BKND__: {
@@ -22,24 +16,14 @@ declare global {
    }
 }
 
-type SubApiOptions<T extends BaseModuleApiOptions> = Omit<T, keyof BaseModuleApiOptions>;
-
 export type ApiOptions = {
    host?: string;
    headers?: Headers;
    key?: string;
-   storage?: {
+   localStorage?: boolean;
-      getItem: (key: string) => string | undefined | null | Promise<string | undefined | null>;
+   fetcher?: typeof fetch;
-      setItem: (key: string, value: string) => void | Promise<void>;
-      removeItem: (key: string) => void | Promise<void>;
-   };
-   onAuthStateChange?: (state: AuthState) => void;
-   fetcher?: ApiFetcher;
    verbose?: boolean;
    verified?: boolean;
-   data?: SubApiOptions<DataApiOptions>;
-   auth?: SubApiOptions<AuthApiOptions>;
-   media?: SubApiOptions<MediaApiOptions>;
 } & (
    | {
         token?: string;
@@ -72,18 +56,18 @@ export class Api {
       this.verified = options.verified === true;
 
       // prefer request if given
-      if ("request" in options && options.request) {
+      if ("request" in options) {
          this.options.host = options.host ?? new URL(options.request.url).origin;
          this.options.headers = options.headers ?? options.request.headers;
          this.extractToken();
 
          // then check for a token
-      } else if ("token" in options && options.token) {
+      } else if ("token" in options) {
          this.token_transport = "header";
-         this.updateToken(options.token, { trigger: false });
+         this.updateToken(options.token);
 
          // then check for an user object
-      } else if ("user" in options && options.user) {
+      } else if ("user" in options) {
          this.token_transport = "none";
          this.user = options.user;
          this.verified = options.verified !== false;
@@ -94,10 +78,6 @@ export class Api {
       this.buildApis();
    }
 
-   get fetcher() {
-      return this.options.fetcher ?? fetch;
-   }
-
    get baseUrl() {
       return this.options.host ?? "http://localhost";
    }
@@ -126,30 +106,18 @@ export class Api {
             this.updateToken(headerToken);
             return;
          }
-      } else if (this.storage) {
+      } else if (this.options.localStorage) {
-         this.storage.getItem(this.tokenKey).then((token) => {
+         const token = localStorage.getItem(this.tokenKey);
+         if (token) {
             this.token_transport = "header";
-            this.updateToken(token ? String(token) : undefined);
+            this.updateToken(token);
-         });
+         }
       }
+
+      //console.warn("Couldn't extract token");
    }
 
-   private get storage() {
+   updateToken(token?: string, rebuild?: boolean) {
-      if (!this.options.storage) return null;
-      return {
-         getItem: async (key: string) => {
-            return await this.options.storage!.getItem(key);
-         },
-         setItem: async (key: string, value: string) => {
-            return await this.options.storage!.setItem(key, value);
-         },
-         removeItem: async (key: string) => {
-            return await this.options.storage!.removeItem(key);
-         },
-      };
-   }
-
-   updateToken(token?: string, opts?: { rebuild?: boolean; trigger?: boolean }) {
       this.token = token;
       this.verified = false;
 
@@ -159,25 +127,17 @@ export class Api {
          this.user = undefined;
       }
 
-      if (this.storage) {
+      if (this.options.localStorage) {
          const key = this.tokenKey;
 
          if (token) {
-            this.storage.setItem(key, token).then(() => {
+            localStorage.setItem(key, token);
-               this.options.onAuthStateChange?.(this.getAuthState());
-            });
          } else {
-            this.storage.removeItem(key).then(() => {
+            localStorage.removeItem(key);
-               this.options.onAuthStateChange?.(this.getAuthState());
-            });
-         }
-      } else {
-         if (opts?.trigger !== false) {
-            this.options.onAuthStateChange?.(this.getAuthState());
          }
       }
 
-      if (opts?.rebuild) this.buildApis();
+      if (rebuild) this.buildApis();
    }
 
    private markAuthVerified(verfied: boolean) {
@@ -247,32 +207,15 @@ export class Api {
       const fetcher = this.options.fetcher;
 
       this.system = new SystemApi(baseParams, fetcher);
-      this.data = new DataApi(
+      this.data = new DataApi(baseParams, fetcher);
-         {
-            ...baseParams,
-            ...this.options.data,
-         },
-         fetcher,
-      );
       this.auth = new AuthApi(
          {
             ...baseParams,
-            credentials: this.options.storage ? "omit" : "include",
+            onTokenUpdate: (token) => this.updateToken(token, true),
-            ...this.options.auth,
-            onTokenUpdate: (token) => {
-               this.updateToken(token, { rebuild: true });
-               this.options.auth?.onTokenUpdate?.(token);
-            },
-         },
-         fetcher,
-      );
-      this.media = new MediaApi(
-         {
-            ...baseParams,
-            ...this.options.media,
          },
          fetcher,
       );
+      this.media = new MediaApi(baseParams, fetcher);
    }
 }
 

app/src/App.ts

@@ -1,44 +1,26 @@
 import type { CreateUserPayload } from "auth/AppAuth";
-import { $console } from "core/utils";
+import { $console } from "core";
 import { Event } from "core/events";
-import type { em as prototypeEm } from "data/prototype";
+import { Connection, type LibSqlCredentials, LibsqlConnection } from "data";
-import { Connection } from "data/connection/Connection";
 import type { Hono } from "hono";
 import {
-   ModuleManager,
    type InitialModuleConfigs,
    type ModuleBuildContext,
-   type ModuleConfigs,
+   ModuleManager,
    type ModuleManagerOptions,
    type Modules,
 } from "modules/ModuleManager";
 import * as SystemPermissions from "modules/permissions";
 import { AdminController, type AdminControllerOptions } from "modules/server/AdminController";
 import { SystemController } from "modules/server/SystemController";
-import type { MaybePromise } from "core/types";
-import type { ServerEnv } from "modules/Controller";
-import type { IEmailDriver, ICacheDriver } from "core/drivers";
 
-// biome-ignore format: must be here
+// biome-ignore format: must be there
 import { Api, type ApiOptions } from "Api";
 
-export type AppPluginConfig = {
+export type AppPlugin = (app: App) => Promise<void> | void;
-   name: string;
-   schema?: () => MaybePromise<ReturnType<typeof prototypeEm> | void>;
-   beforeBuild?: () => MaybePromise<void>;
-   onBuilt?: () => MaybePromise<void>;
-   onServerInit?: (server: Hono<ServerEnv>) => MaybePromise<void>;
-   onFirstBoot?: () => MaybePromise<void>;
-   onBoot?: () => MaybePromise<void>;
-   onModulesCreated?: (modules: Modules) => void;
-};
-export type AppPlugin = (app: App) => AppPluginConfig;
 
 abstract class AppEvent<A = {}> extends Event<{ app: App } & A> {}
-export class AppConfigUpdatedEvent extends AppEvent<{
+export class AppConfigUpdatedEvent extends AppEvent {
-   module: string;
-   config: ModuleConfigs[keyof ModuleConfigs];
-}> {
    static override slug = "app-config-updated";
 }
 export class AppBuiltEvent extends AppEvent {
@@ -47,32 +29,22 @@ export class AppBuiltEvent extends AppEvent {
 export class AppFirstBoot extends AppEvent {
    static override slug = "app-first-boot";
 }
-export class AppRequest extends AppEvent<{ request: Request }> {
+export const AppEvents = { AppConfigUpdatedEvent, AppBuiltEvent, AppFirstBoot } as const;
-   static override slug = "app-request";
-}
-export class AppBeforeResponse extends AppEvent<{ request: Request; response: Response }> {
-   static override slug = "app-before-response";
-}
-export const AppEvents = {
-   AppConfigUpdatedEvent,
-   AppBuiltEvent,
-   AppFirstBoot,
-   AppRequest,
-   AppBeforeResponse,
-} as const;
 
 export type AppOptions = {
    plugins?: AppPlugin[];
    seed?: (ctx: ModuleBuildContext & { app: App }) => Promise<void>;
    manager?: Omit<ModuleManagerOptions, "initial" | "onUpdated" | "seed">;
-   asyncEventsMode?: "sync" | "async" | "none";
-   drivers?: {
-      email?: IEmailDriver;
-      cache?: ICacheDriver;
-   };
 };
 export type CreateAppConfig = {
-   connection?: Connection | { url: string };
+   connection?:
+      | Connection
+      | {
+           // @deprecated
+           type: "libsql";
+           config: LibSqlCredentials;
+        }
+      | LibSqlCredentials;
    initialConfig?: InitialModuleConfigs;
    options?: AppOptions;
 };
@@ -80,41 +52,53 @@ export type CreateAppConfig = {
 export type AppConfig = InitialModuleConfigs;
 export type LocalApiOptions = Request | ApiOptions;
 
-export class App<C extends Connection = Connection, Options extends AppOptions = AppOptions> {
+export class App {
-   static readonly Events = AppEvents;
-
    modules: ModuleManager;
+   static readonly Events = AppEvents;
    adminController?: AdminController;
-   _id: string = crypto.randomUUID();
-   plugins: Map<string, AppPluginConfig> = new Map();
-   drivers: Options["drivers"] = {};
-
    private trigger_first_boot = false;
+   private plugins: AppPlugin[];
+   private _id: string = crypto.randomUUID();
    private _building: boolean = false;
 
    constructor(
-      public connection: C,
+      private connection: Connection,
       _initialConfig?: InitialModuleConfigs,
-      private options?: Options,
+      private options?: AppOptions,
    ) {
-      this.drivers = options?.drivers ?? {};
+      this.plugins = options?.plugins ?? [];
-
-      for (const plugin of options?.plugins ?? []) {
-         const config = plugin(this);
-         if (this.plugins.has(config.name)) {
-            throw new Error(`Plugin ${config.name} already registered`);
-         }
-         this.plugins.set(config.name, config);
-      }
-      this.runPlugins("onBoot");
       this.modules = new ModuleManager(connection, {
          ...(options?.manager ?? {}),
          initial: _initialConfig,
-         onUpdated: this.onUpdated.bind(this),
+         onUpdated: async (key, config) => {
-         onFirstBoot: this.onFirstBoot.bind(this),
+            // if the EventManager was disabled, we assume we shouldn't
-         onServerInit: this.onServerInit.bind(this),
+            // respond to events, such as "onUpdated".
-         onModulesBuilt: this.onModulesBuilt.bind(this),
+            // this is important if multiple changes are done, and then build() is called manually
-         onModulesCreated: this.onModulesCreated.bind(this),
+            if (!this.emgr.enabled) {
+               $console.warn("App config updated, but event manager is disabled, skip.");
+               return;
+            }
+
+            $console.log("App config updated", key);
+            // @todo: potentially double syncing
+            await this.build({ sync: true });
+            await this.emgr.emit(new AppConfigUpdatedEvent({ app: this }));
+         },
+         onFirstBoot: async () => {
+            $console.log("App first boot");
+            this.trigger_first_boot = true;
+         },
+         onServerInit: async (server) => {
+            server.use(async (c, next) => {
+               c.set("app", this);
+               await next();
+
+               try {
+                  // gracefully add the app id
+                  c.res.headers.set("X-bknd-id", this._id);
+               } catch (e) {}
+            });
+         },
       });
       this.modules.ctx().emgr.registerEvents(AppEvents);
    }
@@ -123,32 +107,6 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
       return this.modules.ctx().emgr;
    }
 
-   protected async runPlugins<Key extends keyof AppPluginConfig>(
-      key: Key,
-      ...args: any[]
-   ): Promise<{ name: string; result: any }[]> {
-      const results: { name: string; result: any }[] = [];
-      for (const [name, config] of this.plugins) {
-         try {
-            if (key in config && config[key]) {
-               const fn = config[key];
-               if (fn && typeof fn === "function") {
-                  $console.debug(`[Plugin:${name}] ${key}`);
-                  // @ts-expect-error
-                  const result = await fn(...args);
-                  results.push({
-                     name,
-                     result,
-                  });
-               }
-            }
-         } catch (e) {
-            $console.warn(`[Plugin:${name}] error running "${key}"`, String(e));
-         }
-      }
-      return results as any;
-   }
-
    async build(options?: { sync?: boolean; fetch?: boolean; forceBuild?: boolean }) {
       // prevent multiple concurrent builds
       if (this._building) {
@@ -157,8 +115,6 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
          }
          if (!options?.forceBuild) return;
       }
-
-      await this.runPlugins("beforeBuild");
       this._building = true;
 
       if (options?.sync) this.modules.ctx().flags.sync_required = true;
@@ -170,10 +126,13 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
       guard.registerPermissions(Object.values(SystemPermissions));
       server.route("/api/system", new SystemController(this).getController());
 
-      // emit built event
+      // load plugins
+      if (this.plugins.length > 0) {
+         await Promise.all(this.plugins.map((plugin) => plugin(this)));
+      }
+
       $console.log("App built");
       await this.emgr.emit(new AppBuiltEvent({ app: this }));
-      await this.runPlugins("onBuilt");
 
       // first boot is set from ModuleManager when there wasn't a config table
       if (this.trigger_first_boot) {
@@ -201,7 +160,7 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
    }
 
    get fetch(): Hono["fetch"] {
-      return this.server.fetch as any;
+      return this.server.fetch;
    }
 
    get module() {
@@ -230,10 +189,7 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
    registerAdminController(config?: AdminControllerOptions) {
       // register admin
       this.adminController = new AdminController(this, config);
-      this.modules.server.route(
+      this.modules.server.route(config?.basepath ?? "/", this.adminController.getController());
-         this.adminController.basepath,
-         this.adminController.getController(),
-      );
       return this;
    }
 
@@ -257,87 +213,34 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
 
       return new Api({ host: "http://localhost", ...(options ?? {}), fetcher });
    }
-
-   async onUpdated<Module extends keyof Modules>(module: Module, config: ModuleConfigs[Module]) {
-      // if the EventManager was disabled, we assume we shouldn't
-      // respond to events, such as "onUpdated".
-      // this is important if multiple changes are done, and then build() is called manually
-      if (!this.emgr.enabled) {
-         $console.warn("App config updated, but event manager is disabled, skip.");
-         return;
-      }
-
-      $console.log("App config updated", module);
-      // @todo: potentially double syncing
-      await this.build({ sync: true });
-      await this.emgr.emit(new AppConfigUpdatedEvent({ app: this, module, config }));
-   }
-
-   protected async onFirstBoot() {
-      $console.log("App first boot");
-      this.trigger_first_boot = true;
-      await this.runPlugins("onFirstBoot");
-   }
-
-   protected async onServerInit(server: Hono<ServerEnv>) {
-      server.use(async (c, next) => {
-         c.set("app", this);
-         await this.emgr.emit(new AppRequest({ app: this, request: c.req.raw }));
-         await next();
-
-         try {
-            // gracefully add the app id
-            c.res.headers.set("X-bknd-id", this._id);
-         } catch (e) {}
-
-         await this.emgr.emit(
-            new AppBeforeResponse({ app: this, request: c.req.raw, response: c.res }),
-         );
-
-         // execute collected async events (async by default)
-         switch (this.options?.asyncEventsMode ?? "async") {
-            case "sync":
-               await this.emgr.executeAsyncs();
-               break;
-            case "async":
-               this.emgr.executeAsyncs();
-               break;
-         }
-      });
-
-      // call server init if set
-      if (this.options?.manager?.onServerInit) {
-         this.options.manager.onServerInit(server);
-      }
-
-      await this.runPlugins("onServerInit", server);
-   }
-
-   protected async onModulesBuilt(ctx: ModuleBuildContext) {
-      const results = (await this.runPlugins("schema")) as {
-         name: string;
-         result: ReturnType<typeof prototypeEm>;
-      }[];
-      if (results.length > 0) {
-         for (const { name, result } of results) {
-            if (result) {
-               $console.log(`[Plugin:${name}] schema`);
-               ctx.helper.ensureSchema(result);
-            }
-         }
-      }
-   }
-
-   protected async onModulesCreated(modules: Modules, ctx: ModuleBuildContext) {
-      await this.runPlugins("onModulesCreated", modules, ctx);
-      this.options?.manager?.onModulesCreated?.(modules, ctx);
-   }
 }
 
 export function createApp(config: CreateAppConfig = {}) {
-   if (!config.connection || !Connection.isConnection(config.connection)) {
+   let connection: Connection | undefined = undefined;
+
+   try {
+      if (Connection.isConnection(config.connection)) {
+         connection = config.connection;
+      } else if (typeof config.connection === "object") {
+         if ("type" in config.connection) {
+            $console.warn(
+               "Using deprecated connection type 'libsql', use the 'config' object directly.",
+            );
+            connection = new LibsqlConnection(config.connection.config);
+         } else {
+            connection = new LibsqlConnection(config.connection);
+         }
+      } else {
+         connection = new LibsqlConnection({ url: ":memory:" });
+         $console.warn("No connection provided, using in-memory database");
+      }
+   } catch (e) {
+      $console.error("Could not create connection", e);
+   }
+
+   if (!connection) {
       throw new Error("Invalid connection");
    }
 
-   return new App(config.connection, config.initialConfig, config.options);
+   return new App(connection, config.initialConfig, config.options);
 }

app/src/adapter/adapter-test-suite.ts

@@ -1,90 +0,0 @@
-import type { TestRunner } from "core/test";
-import type { BkndConfig, DefaultArgs, FrameworkOptions, RuntimeOptions } from "./index";
-import type { App } from "App";
-
-export function adapterTestSuite<
-   Config extends BkndConfig = BkndConfig,
-   Args extends DefaultArgs = DefaultArgs,
->(
-   testRunner: TestRunner,
-   {
-      makeApp,
-      makeHandler,
-      label = "app",
-      overrides = {},
-   }: {
-      makeApp: (
-         config: Config,
-         args?: Args,
-         opts?: RuntimeOptions | FrameworkOptions,
-      ) => Promise<App>;
-      makeHandler?: (
-         config?: Config,
-         args?: Args,
-         opts?: RuntimeOptions | FrameworkOptions,
-      ) => (request: Request) => Promise<Response>;
-      label?: string;
-      overrides?: {
-         dbUrl?: string;
-      };
-   },
-) {
-   const { test, expect, mock } = testRunner;
-   const id = crypto.randomUUID();
-
-   test(`creates ${label}`, async () => {
-      const beforeBuild = mock(async () => null) as any;
-      const onBuilt = mock(async () => null) as any;
-
-      const config = {
-         app: (env) => ({
-            connection: { url: env.url },
-            initialConfig: {
-               server: { cors: { origin: env.origin } },
-            },
-         }),
-         beforeBuild,
-         onBuilt,
-      } as const satisfies BkndConfig;
-
-      const app = await makeApp(
-         config as any,
-         {
-            url: overrides.dbUrl ?? ":memory:",
-            origin: "localhost",
-         } as any,
-         { id },
-      );
-      expect(app).toBeDefined();
-      expect(app.toJSON().server.cors.origin).toEqual("localhost");
-      expect(beforeBuild).toHaveBeenCalledTimes(1);
-      expect(onBuilt).toHaveBeenCalledTimes(1);
-   });
-
-   if (makeHandler) {
-      const getConfig = async (fetcher: (r: Request) => Promise<Response>) => {
-         const res = await fetcher(new Request("http://localhost:3000/api/system/config"));
-         const data = (await res.json()) as any;
-         return { res, data };
-      };
-
-      test("responds with the same app id", async () => {
-         const fetcher = makeHandler(undefined, undefined, { id });
-
-         const { res, data } = await getConfig(fetcher);
-         expect(res.ok).toBe(true);
-         expect(res.status).toBe(200);
-         expect(data.server.cors.origin).toEqual("localhost");
-      });
-
-      test("creates fresh & responds to api config", async () => {
-         // set the same id, but force recreate
-         const fetcher = makeHandler(undefined, undefined, { id, force: true });
-
-         const { res, data } = await getConfig(fetcher);
-         expect(res.ok).toBe(true);
-         expect(res.status).toBe(200);
-         expect(data.server.cors.origin).toEqual("*");
-      });
-   }
-}

app/src/adapter/astro/astro.adapter.spec.ts

@@ -1,15 +0,0 @@
-import { afterAll, beforeAll, describe } from "bun:test";
-import * as astro from "./astro.adapter";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-import { adapterTestSuite } from "adapter/adapter-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-describe("astro adapter", () => {
-   adapterTestSuite(bunTestRunner, {
-      makeApp: astro.getApp,
-      makeHandler: (c, a, o) => (request: Request) => astro.serve(c, a, o)({ request }),
-   });
-});

app/src/adapter/astro/astro.adapter.ts

@@ -1,25 +1,34 @@
-import { type FrameworkBkndConfig, createFrameworkApp, type FrameworkOptions } from "bknd/adapter";
+import type { App } from "bknd";
+import { type FrameworkBkndConfig, createFrameworkApp } from "bknd/adapter";
+import { Api, type ApiOptions } from "bknd/client";
+
+export type AstroBkndConfig<Args = TAstro> = FrameworkBkndConfig<Args>;
 
-type AstroEnv = NodeJS.ProcessEnv;
 type TAstro = {
    request: Request;
 };
-export type AstroBkndConfig<Env = AstroEnv> = FrameworkBkndConfig<Env>;
 
-export async function getApp<Env = AstroEnv>(
+export type Options = {
-   config: AstroBkndConfig<Env> = {},
+   mode?: "static" | "dynamic";
-   args: Env = {} as Env,
+} & Omit<ApiOptions, "host"> & {
-   opts: FrameworkOptions = {},
+      host?: string;
-) {
+   };
-   return await createFrameworkApp(config, args ?? import.meta.env, opts);
+
+export async function getApi(Astro: TAstro, options: Options = { mode: "static" }) {
+   const api = new Api({
+      host: new URL(Astro.request.url).origin,
+      headers: options.mode === "dynamic" ? Astro.request.headers : undefined,
+   });
+   await api.verifyAuth();
+   return api;
 }
 
-export function serve<Env = AstroEnv>(
+let app: App;
-   config: AstroBkndConfig<Env> = {},
+export function serve<Context extends TAstro = TAstro>(config: AstroBkndConfig<Context> = {}) {
-   args: Env = {} as Env,
+   return async (args: Context) => {
-   opts?: FrameworkOptions,
+      if (!app) {
-) {
+         app = await createFrameworkApp(config, args);
-   return async (fnArgs: TAstro) => {
+      }
-      return (await getApp(config, args, opts)).fetch(fnArgs.request);
+      return app.fetch(args.request);
    };
 }

app/src/adapter/aws/aws-lambda.adapter.ts

@@ -1,76 +1,68 @@
 import type { App } from "bknd";
 import { handle } from "hono/aws-lambda";
-import { serveStatic } from "@hono/node-server/serve-static";
+import { type RuntimeBkndConfig, createRuntimeApp } from "bknd/adapter";
-import { type RuntimeBkndConfig, createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
 
-type AwsLambdaEnv = object;
+export type AwsLambdaBkndConfig = RuntimeBkndConfig & {
-export type AwsLambdaBkndConfig<Env extends AwsLambdaEnv = AwsLambdaEnv> =
+   assets?:
-   RuntimeBkndConfig<Env> & {
+      | {
-      assets?:
+           mode: "local";
-         | {
+           root: string;
-              mode: "local";
+        }
-              root: string;
+      | {
-           }
+           mode: "url";
-         | {
+           url: string;
-              mode: "url";
+        };
-              url: string;
+};
-           };
-   };
 
-export async function createApp<Env extends AwsLambdaEnv = AwsLambdaEnv>(
+let app: App;
-   { adminOptions = false, assets, ...config }: AwsLambdaBkndConfig<Env> = {},
+export async function createApp({
-   args: Env = {} as Env,
+   adminOptions = false,
-   opts?: RuntimeOptions,
+   assets,
-): Promise<App> {
+   ...config
-   let additional: Partial<RuntimeBkndConfig> = {
+}: AwsLambdaBkndConfig = {}) {
-      adminOptions,
+   if (!app) {
-   };
+      let additional: Partial<RuntimeBkndConfig> = {
+         adminOptions,
+      };
 
-   if (assets?.mode) {
+      if (assets?.mode) {
-      switch (assets.mode) {
+         switch (assets.mode) {
-         case "local":
+            case "local":
-            // @todo: serve static outside app context
+               // @todo: serve static outside app context
-            additional = {
+               additional = {
-               adminOptions: adminOptions === false ? undefined : adminOptions,
+                  adminOptions: adminOptions === false ? undefined : adminOptions,
-               serveStatic: serveStatic({
+                  serveStatic: (await import("@hono/node-server/serve-static")).serveStatic({
-                  root: assets.root,
+                     root: assets.root,
-                  onFound: (path, c) => {
+                     onFound: (path, c) => {
-                     c.res.headers.set("Cache-Control", "public, max-age=31536000");
+                        c.res.headers.set("Cache-Control", "public, max-age=31536000");
-                  },
+                     },
-               }),
+                  }),
-            };
+               };
-            break;
+               break;
-         case "url":
+            case "url":
-            additional.adminOptions = {
+               additional.adminOptions = {
-               ...(typeof adminOptions === "object" ? adminOptions : {}),
+                  ...(typeof adminOptions === "object" ? adminOptions : {}),
-               assetsPath: assets.url,
+                  assets_path: assets.url,
-            };
+               };
-            break;
+               break;
-         default:
+            default:
-            throw new Error("Invalid assets mode");
+               throw new Error("Invalid assets mode");
+         }
       }
-   }
 
-   return await createRuntimeApp(
+      app = await createRuntimeApp({
-      {
          ...config,
          ...additional,
-      },
+      });
-      args ?? process.env,
+   }
-      opts,
+
-   );
+   return app;
 }
 
-export function serve<Env extends AwsLambdaEnv = AwsLambdaEnv>(
+export function serveLambda(config: AwsLambdaBkndConfig = {}) {
-   config: AwsLambdaBkndConfig<Env> = {},
+   console.log("serving lambda");
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
    return async (event) => {
-      const app = await createApp(config, args, opts);
+      const app = await createApp(config);
       return await handle(app.server)(event);
    };
 }
-
-// compatibility with old code
-export const serveLambda = serve;

app/src/adapter/aws/aws.adapter.spec.ts

@@ -1,19 +0,0 @@
-import { afterAll, beforeAll, describe } from "bun:test";
-import * as awsLambda from "./aws-lambda.adapter";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-import { adapterTestSuite } from "adapter/adapter-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-describe("aws adapter", () => {
-   adapterTestSuite(bunTestRunner, {
-      makeApp: awsLambda.createApp,
-      // @todo: add a request to lambda event translator?
-      makeHandler: (c, a, o) => async (request: Request) => {
-         const app = await awsLambda.createApp(c, a, o);
-         return app.fetch(request);
-      },
-   });
-});

app/src/adapter/bun/bun.adapter.spec.ts

@@ -1,15 +0,0 @@
-import { afterAll, beforeAll, describe } from "bun:test";
-import * as bun from "./bun.adapter";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-import { adapterTestSuite } from "adapter/adapter-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-describe("bun adapter", () => {
-   adapterTestSuite(bunTestRunner, {
-      makeApp: bun.createApp,
-      makeHandler: bun.createHandler,
-   });
-});

app/src/adapter/bun/bun.adapter.ts

@@ -1,69 +1,47 @@
 /// <reference types="bun-types" />
 
 import path from "node:path";
-import { type RuntimeBkndConfig, createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
+import type { App } from "bknd";
-import { registerLocalMediaAdapter } from ".";
+import { type RuntimeBkndConfig, createRuntimeApp } from "bknd/adapter";
+import { registerLocalMediaAdapter } from "bknd/adapter/node";
 import { config } from "bknd/core";
 import type { ServeOptions } from "bun";
 import { serveStatic } from "hono/bun";
-import type { App } from "App";
 
-type BunEnv = Bun.Env;
+let app: App;
-export type BunBkndConfig<Env = BunEnv> = RuntimeBkndConfig<Env> & Omit<ServeOptions, "fetch">;
 
-export async function createApp<Env = BunEnv>(
+export type BunBkndConfig = RuntimeBkndConfig & Omit<ServeOptions, "fetch">;
-   { distPath, ...config }: BunBkndConfig<Env> = {},
+
-   args: Env = {} as Env,
+export async function createApp({ distPath, ...config }: RuntimeBkndConfig = {}) {
-   opts?: RuntimeOptions,
-) {
    const root = path.resolve(distPath ?? "./node_modules/bknd/dist", "static");
 
-   const app = await createRuntimeApp(
+   if (!app) {
-      {
+      registerLocalMediaAdapter();
+      app = await createRuntimeApp({
          ...config,
          serveStatic: serveStatic({ root }),
-      },
+      });
-      args ?? (process.env as Env),
+   }
-      opts,
+
-   );
-   registerLocalMediaAdapter(app);
    return app;
 }
 
-export function createHandler<Env = BunEnv>(
+export function serve({
-   config: BunBkndConfig<Env> = {},
+   distPath,
-   args: Env = {} as Env,
+   connection,
-   opts?: RuntimeOptions,
+   initialConfig,
-) {
+   options,
-   let app: App | undefined;
+   port = config.server.default_port,
-   return async (req: Request) => {
+   onBuilt,
-      if (!app) {
+   buildConfig,
-         app = await createApp(config, args ?? (process.env as Env), opts);
+   adminOptions,
-      }
+   ...serveOptions
-      return app.fetch(req);
+}: BunBkndConfig = {}) {
-   };
-}
-
-export function serve<Env = BunEnv>(
-   {
-      distPath,
-      connection,
-      initialConfig,
-      options,
-      port = config.server.default_port,
-      onBuilt,
-      buildConfig,
-      adminOptions,
-      ...serveOptions
-   }: BunBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
    Bun.serve({
       ...serveOptions,
       port,
-      fetch: createHandler(
+      fetch: async (request: Request) => {
-         {
+         const app = await createApp({
             connection,
             initialConfig,
             options,
@@ -71,11 +49,10 @@ export function serve<Env = BunEnv>(
             buildConfig,
             adminOptions,
             distPath,
-         },
+         });
-         args,
+         return app.fetch(request);
-         opts,
+      },
-      ),
    });
 
-   console.info(`Server is running on http://localhost:${port}`);
+   console.log(`Server is running on http://localhost:${port}`);
 }

app/src/adapter/bun/connection/BunSqliteConnection.spec.ts

@@ -1,15 +0,0 @@
-import { connectionTestSuite } from "data/connection/connection-test-suite";
-import { bunSqlite } from "./BunSqliteConnection";
-import { bunTestRunner } from "adapter/bun/test";
-import { describe } from "bun:test";
-import { Database } from "bun:sqlite";
-
-describe("BunSqliteConnection", () => {
-   connectionTestSuite(bunTestRunner, {
-      makeConnection: () => ({
-         connection: bunSqlite({ database: new Database(":memory:") }),
-         dispose: async () => {},
-      }),
-      rawDialectDetails: [],
-   });
-});

app/src/adapter/bun/connection/BunSqliteConnection.ts

@@ -1,40 +0,0 @@
-import { Database } from "bun:sqlite";
-import { genericSqlite, type GenericSqliteConnection } from "bknd/data";
-
-export type BunSqliteConnection = GenericSqliteConnection<Database>;
-export type BunSqliteConnectionConfig = {
-   database: Database;
-};
-
-export function bunSqlite(config?: BunSqliteConnectionConfig | { url: string }) {
-   let db: Database;
-   if (config) {
-      if ("database" in config) {
-         db = config.database;
-      } else {
-         db = new Database(config.url);
-      }
-   } else {
-      db = new Database(":memory:");
-   }
-
-   return genericSqlite("bun-sqlite", db, (utils) => {
-      //const fn = cache ? "query" : "prepare";
-      const getStmt = (sql: string) => db.prepare(sql);
-
-      return {
-         db,
-         query: utils.buildQueryFn({
-            all: (sql, parameters) => getStmt(sql).all(...(parameters || [])),
-            run: (sql, parameters) => {
-               const { changes, lastInsertRowid } = getStmt(sql).run(...(parameters || []));
-               return {
-                  insertId: utils.parseBigInt(lastInsertRowid),
-                  numAffectedRows: utils.parseBigInt(changes),
-               };
-            },
-         }),
-         close: () => db.close(),
-      };
-   });
-}

app/src/adapter/bun/index.ts

@@ -1,3 +1 @@
 export * from "./bun.adapter";
-export * from "../node/storage";
-export * from "./connection/BunSqliteConnection";

app/src/adapter/bun/test.ts

@@ -1,11 +0,0 @@
-import { expect, test, mock, describe, beforeEach, afterEach, afterAll } from "bun:test";
-
-export const bunTestRunner = {
-   describe,
-   expect,
-   test,
-   mock,
-   beforeEach,
-   afterEach,
-   afterAll,
-};

app/src/adapter/cloudflare/D1Connection.ts

@@ -0,0 +1,59 @@
+/// <reference types="@cloudflare/workers-types" />
+
+import { KyselyPluginRunner, SqliteConnection, SqliteIntrospector } from "bknd/data";
+import type { QB } from "data/connection/Connection";
+import { type DatabaseIntrospector, Kysely, ParseJSONResultsPlugin } from "kysely";
+import { D1Dialect } from "kysely-d1";
+
+export type D1ConnectionConfig = {
+   binding: D1Database;
+};
+
+class CustomD1Dialect extends D1Dialect {
+   override createIntrospector(db: Kysely<any>): DatabaseIntrospector {
+      return new SqliteIntrospector(db, {
+         excludeTables: ["_cf_KV"],
+      });
+   }
+}
+
+export class D1Connection extends SqliteConnection {
+   protected override readonly supported = {
+      batching: true,
+   };
+
+   constructor(private config: D1ConnectionConfig) {
+      const plugins = [new ParseJSONResultsPlugin()];
+
+      const kysely = new Kysely({
+         dialect: new CustomD1Dialect({ database: config.binding }),
+         plugins,
+      });
+      super(kysely, {}, plugins);
+   }
+
+   protected override async batch<Queries extends QB[]>(
+      queries: [...Queries],
+   ): Promise<{
+      [K in keyof Queries]: Awaited<ReturnType<Queries[K]["execute"]>>;
+   }> {
+      const db = this.config.binding;
+
+      const res = await db.batch(
+         queries.map((q) => {
+            const { sql, parameters } = q.compile();
+            return db.prepare(sql).bind(...parameters);
+         }),
+      );
+
+      // let it run through plugins
+      const kyselyPlugins = new KyselyPluginRunner(this.plugins);
+      const data: any = [];
+      for (const r of res) {
+         const rows = await kyselyPlugins.transformResultRows(r.results);
+         data.push(rows);
+      }
+
+      return data;
+   }
+}

app/src/adapter/cloudflare/StorageR2Adapter.ts

@@ -1,22 +1,23 @@
-import type { App } from "bknd";
+import { registries } from "bknd";
 import { isDebug } from "bknd/core";
-import { guessMimeType as guess, StorageAdapter, type FileBody } from "bknd/media";
+import { StringEnum, Type } from "bknd/utils";
-import { getBindings } from "../bindings";
+import type { FileBody, StorageAdapter } from "media/storage/Storage";
-import { s } from "core/object/schema";
+import { guess } from "media/storage/mime-types-tiny";
+import { getBindings } from "./bindings";
 
 export function makeSchema(bindings: string[] = []) {
-   return s.object(
+   return Type.Object(
       {
-         binding: bindings.length > 0 ? s.string({ enum: bindings }) : s.string().optional(),
+         binding: bindings.length > 0 ? StringEnum(bindings) : Type.Optional(Type.String()),
       },
       { title: "R2", description: "Cloudflare R2 storage" },
    );
 }
 
-export function registerMedia(app: App, env: Record<string, any>) {
+export function registerMedia(env: Record<string, any>) {
    const r2_bindings = getBindings(env, "R2Bucket");
 
-   app.module.media.adapters.set(
+   registries.media.register(
       "r2",
       class extends StorageR2Adapter {
          constructor(private config: any) {
@@ -46,10 +47,8 @@ export function registerMedia(app: App, env: Record<string, any>) {
  * Adapter for R2 storage
  * @todo: add tests (bun tests won't work, need node native tests)
  */
-export class StorageR2Adapter extends StorageAdapter {
+export class StorageR2Adapter implements StorageAdapter {
-   constructor(private readonly bucket: R2Bucket) {
+   constructor(private readonly bucket: R2Bucket) {}
-      super();
-   }
 
    getName(): string {
       return "r2";
@@ -61,49 +60,46 @@ export class StorageR2Adapter extends StorageAdapter {
 
    async putObject(key: string, body: FileBody) {
       try {
-         const res = await this.bucket.put(this.getKey(key), body);
+         const res = await this.bucket.put(key, body);
          return res?.etag;
       } catch (e) {
          return undefined;
       }
    }
-   async listObjects(prefix = ""): Promise<{ key: string; last_modified: Date; size: number }[]> {
+   async listObjects(
-      const list = await this.bucket.list({ limit: 50, prefix: this.getKey(prefix) });
+      prefix?: string,
+   ): Promise<{ key: string; last_modified: Date; size: number }[]> {
+      const list = await this.bucket.list({ limit: 50 });
       return list.objects.map((item) => ({
-         key: item.key.replace(this.getKey(""), ""),
+         key: item.key,
          size: item.size,
          last_modified: item.uploaded,
       }));
    }
 
    private async headObject(key: string): Promise<R2Object | null> {
-      return await this.bucket.head(this.getKey(key));
+      return await this.bucket.head(key);
    }
 
    async objectExists(key: string): Promise<boolean> {
       return (await this.headObject(key)) !== null;
    }
 
-   async getObject(_key: string, headers: Headers): Promise<Response> {
+   async getObject(key: string, headers: Headers): Promise<Response> {
       let object: R2ObjectBody | null;
-      const key = this.getKey(_key);
-
       const responseHeaders = new Headers({
          "Accept-Ranges": "bytes",
          "Content-Type": guess(key),
       });
 
-      const range = headers.has("range");
-
       //console.log("getObject:headers", headersToObject(headers));
-      if (range) {
+      if (headers.has("range")) {
          const options = isDebug()
             ? {} // miniflare doesn't support range requests
             : {
                  range: headers,
                  onlyIf: headers,
               };
-
          object = (await this.bucket.get(key, options)) as R2ObjectBody;
 
          if (!object) {
@@ -125,20 +121,21 @@ export class StorageR2Adapter extends StorageAdapter {
          }
       }
 
+      //console.log("response headers:before", headersToObject(responseHeaders));
       this.writeHttpMetadata(responseHeaders, object);
       responseHeaders.set("etag", object.httpEtag);
       responseHeaders.set("Content-Length", String(object.size));
       responseHeaders.set("Last-Modified", object.uploaded.toUTCString());
+      //console.log("response headers:after", headersToObject(responseHeaders));
 
       return new Response(object.body, {
-         status: range ? 206 : 200,
+         status: object.range ? 206 : 200,
          headers: responseHeaders,
       });
    }
 
    private writeHttpMetadata(headers: Headers, object: R2Object | R2ObjectBody): void {
       let metadata = object.httpMetadata;
-
       if (!metadata || Object.keys(metadata).length === 0) {
          // guessing is especially required for dev environment (miniflare)
          metadata = {
@@ -165,17 +162,13 @@ export class StorageR2Adapter extends StorageAdapter {
    }
 
    async deleteObject(key: string): Promise<void> {
-      await this.bucket.delete(this.getKey(key));
+      await this.bucket.delete(key);
    }
 
    getObjectUrl(key: string): string {
       throw new Error("Method getObjectUrl not implemented.");
    }
 
-   protected getKey(key: string) {
-      return key;
-   }
-
    toJSON(secrets?: boolean) {
       return {
          type: this.getName(),

app/src/adapter/cloudflare/cloudflare-workers.adapter.spec.ts

@@ -1,62 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { makeApp } from "./modes/fresh";
-import { makeConfig, type CfMakeConfigArgs } from "./config";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-import { adapterTestSuite } from "adapter/adapter-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-import type { CloudflareBkndConfig } from "./cloudflare-workers.adapter";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-describe("cf adapter", () => {
-   const DB_URL = ":memory:";
-   const $ctx = (env?: any, request?: Request, ctx?: ExecutionContext) => ({
-      request: request ?? (null as any),
-      env: env ?? { url: DB_URL },
-      ctx: ctx ?? (null as any),
-   });
-
-   it("makes config", async () => {
-      const staticConfig = makeConfig(
-         {
-            connection: { url: DB_URL },
-            initialConfig: { data: { basepath: DB_URL } },
-         },
-         $ctx({ DB_URL }),
-      );
-      expect(staticConfig.initialConfig).toEqual({ data: { basepath: DB_URL } });
-      expect(staticConfig.connection).toBeDefined();
-
-      const dynamicConfig = makeConfig(
-         {
-            app: (env) => ({
-               initialConfig: { data: { basepath: env.DB_URL } },
-               connection: { url: env.DB_URL },
-            }),
-         },
-         $ctx({ DB_URL }),
-      );
-      expect(dynamicConfig.initialConfig).toEqual({ data: { basepath: DB_URL } });
-      expect(dynamicConfig.connection).toBeDefined();
-   });
-
-   adapterTestSuite<CloudflareBkndConfig, CfMakeConfigArgs<any>>(bunTestRunner, {
-      makeApp: async (c, a, o) => {
-         return await makeApp(c, { env: a } as any, o);
-      },
-      makeHandler: (c, a, o) => {
-         return async (request: any) => {
-            const app = await makeApp(
-               // needs a fallback, otherwise tries to launch D1
-               c ?? {
-                  connection: { url: DB_URL },
-               },
-               a!,
-               o,
-            );
-            return app.fetch(request);
-         };
-      },
-   });
-});

app/src/adapter/cloudflare/cloudflare-workers.adapter.ts

@@ -1,62 +1,81 @@
 /// <reference types="@cloudflare/workers-types" />
 
-import type { RuntimeBkndConfig } from "bknd/adapter";
+import { type FrameworkBkndConfig, makeConfig } from "bknd/adapter";
 import { Hono } from "hono";
 import { serveStatic } from "hono/cloudflare-workers";
-import { getFresh } from "./modes/fresh";
+import { D1Connection } from "./D1Connection";
+import { registerMedia } from "./StorageR2Adapter";
+import { getBinding } from "./bindings";
 import { getCached } from "./modes/cached";
 import { getDurable } from "./modes/durable";
-import type { App } from "bknd";
+import { getFresh, getWarm } from "./modes/fresh";
-import { $console } from "core/utils";
-import { registerMedia } from "./storage/StorageR2Adapter";
 
-declare global {
+export type CloudflareBkndConfig<Env = any> = FrameworkBkndConfig<Context<Env>> & {
-   namespace Cloudflare {
-      interface Env {}
-   }
-}
-
-export type CloudflareEnv = Cloudflare.Env;
-export type CloudflareBkndConfig<Env = CloudflareEnv> = RuntimeBkndConfig<Env> & {
    mode?: "warm" | "fresh" | "cache" | "durable";
-   bindings?: (args: Env) => {
+   bindings?: (args: Context<Env>) => {
       kv?: KVNamespace;
       dobj?: DurableObjectNamespace;
       db?: D1Database;
    };
-   d1?: {
-      session?: boolean;
-      transport?: "header" | "cookie";
-      first?: D1SessionConstraint;
-   };
    static?: "kv" | "assets";
    key?: string;
    keepAliveSeconds?: number;
    forceHttps?: boolean;
    manifest?: string;
-   registerMedia?: boolean;
+   setAdminHtml?: boolean;
+   html?: string;
 };
 
-export type Context<Env = CloudflareEnv> = {
+export type Context<Env = any> = {
    request: Request;
    env: Env;
    ctx: ExecutionContext;
 };
 
-export function serve<Env extends CloudflareEnv = CloudflareEnv>(
+let media_registered: boolean = false;
-   config: CloudflareBkndConfig<Env> = {},
+export function makeCfConfig(config: CloudflareBkndConfig, context: Context) {
-) {
+   if (!media_registered) {
+      registerMedia(context.env as any);
+      media_registered = true;
+   }
+
+   const appConfig = makeConfig(config, context);
+   const bindings = config.bindings?.(context);
+   if (!appConfig.connection) {
+      let db: D1Database | undefined;
+      if (bindings?.db) {
+         console.log("Using database from bindings");
+         db = bindings.db;
+      } else if (Object.keys(context.env ?? {}).length > 0) {
+         const binding = getBinding(context.env, "D1Database");
+         if (binding) {
+            console.log(`Using database from env "${binding.key}"`);
+            db = binding.value;
+         }
+      }
+
+      if (db) {
+         appConfig.connection = new D1Connection({ binding: db });
+      } else {
+         throw new Error("No database connection given");
+      }
+   }
+
+   return appConfig;
+}
+
+export function serve<Env = any>(config: CloudflareBkndConfig<Env> = {}) {
    return {
       async fetch(request: Request, env: Env, ctx: ExecutionContext) {
          const url = new URL(request.url);
 
          if (config.manifest && config.static === "assets") {
-            $console.warn("manifest is not useful with static 'assets'");
+            console.warn("manifest is not useful with static 'assets'");
          } else if (!config.manifest && config.static === "kv") {
             throw new Error("manifest is required with static 'kv'");
          }
 
-         if (config.manifest && config.static === "kv") {
+         if (config.manifest && config.static !== "assets") {
             const pathname = url.pathname.slice(1);
             const assetManifest = JSON.parse(config.manifest);
             if (pathname && pathname in assetManifest) {
@@ -80,36 +99,21 @@ export function serve<Env extends CloudflareEnv = CloudflareEnv>(
             }
          }
 
-         const context = { request, env, ctx } as Context<Env>;
+         const context = { request, env, ctx } as Context;
          const mode = config.mode ?? "warm";
 
-         let app: App;
          switch (mode) {
             case "fresh":
-               app = await getFresh(config, context, { force: true });
+               return await getFresh(config, context);
-               break;
             case "warm":
-               app = await getFresh(config, context);
+               return await getWarm(config, context);
-               break;
             case "cache":
-               app = await getCached(config, context);
+               return await getCached(config, context);
-               break;
             case "durable":
                return await getDurable(config, context);
             default:
                throw new Error(`Unknown mode ${mode}`);
          }
-
-         registerMediaInternal(app, config, context);
-         return app.fetch(request, env, ctx);
       },
    };
 }
-
-let media_registered: boolean = false;
-function registerMediaInternal(app: App, config: CloudflareBkndConfig<any>, ctx?: Context) {
-   if (!media_registered && config.registerMedia !== false) {
-      registerMedia(app, ctx?.env as any);
-      media_registered = true;
-   }
-}

app/src/adapter/cloudflare/config.ts

@@ -1,180 +0,0 @@
-/// <reference types="@cloudflare/workers-types" />
-
-import { getBinding } from "./bindings";
-import { d1Sqlite } from "./connection/D1Connection";
-import { Connection } from "bknd/data";
-import type { CloudflareBkndConfig, CloudflareEnv } from ".";
-import { App } from "bknd";
-import { makeConfig as makeAdapterConfig } from "bknd/adapter";
-import type { Context, ExecutionContext } from "hono";
-import { $console } from "core/utils";
-import { setCookie } from "hono/cookie";
-import { sqlite } from "bknd/adapter/sqlite";
-
-export const constants = {
-   exec_async_event_id: "cf_register_waituntil",
-   cache_endpoint: "/__bknd/cache",
-   do_endpoint: "/__bknd/do",
-   d1_session: {
-      cookie: "cf_d1_session",
-      header: "x-cf-d1-session",
-   },
-};
-
-export type CfMakeConfigArgs<Env extends CloudflareEnv = CloudflareEnv> = {
-   env: Env;
-   ctx?: ExecutionContext;
-   request?: Request;
-};
-
-function getCookieValue(cookies: string | null, name: string) {
-   if (!cookies) return null;
-
-   for (const cookie of cookies.split("; ")) {
-      const [key, value] = cookie.split("=");
-      if (key === name && value) {
-         return decodeURIComponent(value);
-      }
-   }
-   return null;
-}
-
-export function d1SessionHelper(config: CloudflareBkndConfig<any>) {
-   const headerKey = constants.d1_session.header;
-   const cookieKey = constants.d1_session.cookie;
-   const transport = config.d1?.transport;
-
-   return {
-      get: (request?: Request): D1SessionBookmark | undefined => {
-         if (!request || !config.d1?.session) return undefined;
-
-         if (!transport || transport === "cookie") {
-            const cookies = request.headers.get("Cookie");
-            if (cookies) {
-               const cookie = getCookieValue(cookies, cookieKey);
-               if (cookie) {
-                  return cookie;
-               }
-            }
-         }
-
-         if (!transport || transport === "header") {
-            if (request.headers.has(headerKey)) {
-               return request.headers.get(headerKey) as any;
-            }
-         }
-
-         return undefined;
-      },
-      set: (c: Context, d1?: D1DatabaseSession) => {
-         if (!d1 || !config.d1?.session) return;
-
-         const session = d1.getBookmark();
-         if (session) {
-            if (!transport || transport === "header") {
-               c.header(headerKey, session);
-            }
-            if (!transport || transport === "cookie") {
-               setCookie(c, cookieKey, session, {
-                  httpOnly: true,
-                  secure: true,
-                  sameSite: "Lax",
-                  maxAge: 60 * 5, // 5 minutes
-               });
-            }
-         }
-      },
-   };
-}
-
-export function makeConfig<Env extends CloudflareEnv = CloudflareEnv>(
-   config: CloudflareBkndConfig<Env>,
-   args?: CfMakeConfigArgs<Env>,
-) {
-   const appConfig = makeAdapterConfig(config, args?.env);
-
-   // if connection instance is given, don't do anything
-   // other than checking if D1 session is defined
-   if (Connection.isConnection(appConfig.connection)) {
-      if (config.d1?.session) {
-         // we cannot guarantee that db was opened with session
-         throw new Error(
-            "D1 session don't work when D1 is directly given as connection. Define it in bindings instead.",
-         );
-      }
-      // if connection is given, try to open with unified sqlite adapter
-   } else if (appConfig.connection) {
-      appConfig.connection = sqlite(appConfig.connection);
-
-      // if connection is not given, but env is set
-      // try to make D1 from bindings
-   } else if (args?.env) {
-      const bindings = config.bindings?.(args?.env);
-      const sessionHelper = d1SessionHelper(config);
-      const sessionId = sessionHelper.get(args.request);
-      let session: D1DatabaseSession | undefined;
-      let db: D1Database | undefined;
-
-      // if db is given in bindings, use it
-      if (bindings?.db) {
-         $console.debug("Using database from bindings");
-         db = bindings.db;
-
-         // scan for D1Database in args
-      } else {
-         const binding = getBinding(args.env, "D1Database");
-         if (binding) {
-            $console.debug(`Using database from env "${binding.key}"`);
-            db = binding.value;
-         }
-      }
-
-      // if db is found, check if session is requested
-      if (db) {
-         if (config.d1?.session) {
-            session = db.withSession(sessionId ?? config.d1?.first);
-            if (!session) {
-               throw new Error("Couldn't create session");
-            }
-
-            appConfig.connection = d1Sqlite({ binding: session });
-            appConfig.options = {
-               ...appConfig.options,
-               manager: {
-                  ...appConfig.options?.manager,
-                  onServerInit: (server) => {
-                     server.use(async (c, next) => {
-                        sessionHelper.set(c, session);
-                        await next();
-                     });
-                  },
-               },
-            };
-         } else {
-            appConfig.connection = d1Sqlite({ binding: db });
-         }
-      }
-   }
-
-   if (!Connection.isConnection(appConfig.connection)) {
-      throw new Error("Couldn't find database connection");
-   }
-
-   return appConfig;
-}
-
-export function registerAsyncsExecutionContext(
-   app: App,
-   ctx: { waitUntil: ExecutionContext["waitUntil"] },
-) {
-   app.emgr.onEvent(
-      App.Events.AppBeforeResponse,
-      async (event) => {
-         ctx.waitUntil(event.params.app.emgr.executeAsyncs());
-      },
-      {
-         mode: "sync",
-         id: constants.exec_async_event_id,
-      },
-   );
-}

app/src/adapter/cloudflare/connection/D1Connection.ts

@@ -1,75 +0,0 @@
-/// <reference types="@cloudflare/workers-types" />
-
-import { genericSqlite, type GenericSqliteConnection } from "bknd/data";
-import type { QueryResult } from "kysely";
-
-export type D1SqliteConnection = GenericSqliteConnection<D1Database>;
-
-export type D1ConnectionConfig<DB extends D1Database | D1DatabaseSession = D1Database> = {
-   binding: DB;
-};
-
-export function d1Sqlite<DB extends D1Database | D1DatabaseSession = D1Database>(
-   config: D1ConnectionConfig<DB>,
-) {
-   const db = config.binding;
-
-   return genericSqlite(
-      "d1-sqlite",
-      db,
-      (utils) => {
-         const getStmt = (sql: string, parameters?: any[] | readonly any[]) =>
-            db.prepare(sql).bind(...(parameters || []));
-
-         const mapResult = (res: D1Result<any>): QueryResult<any> => {
-            if (res.error) {
-               throw new Error(res.error);
-            }
-
-            const numAffectedRows =
-               res.meta.changes > 0 ? utils.parseBigInt(res.meta.changes) : undefined;
-            const insertId = res.meta.last_row_id
-               ? utils.parseBigInt(res.meta.last_row_id)
-               : undefined;
-
-            return {
-               insertId,
-               numAffectedRows,
-               rows: res.results,
-               // @ts-ignore
-               meta: res.meta,
-            };
-         };
-
-         return {
-            db,
-            batch: async (stmts) => {
-               const res = await db.batch(
-                  stmts.map(({ sql, parameters }) => {
-                     return getStmt(sql, parameters);
-                  }),
-               );
-               return res.map(mapResult);
-            },
-            query: utils.buildQueryFn({
-               all: async (sql, parameters) => {
-                  const prep = getStmt(sql, parameters);
-                  return mapResult(await prep.all()).rows;
-               },
-               run: async (sql, parameters) => {
-                  const prep = getStmt(sql, parameters);
-                  return mapResult(await prep.run());
-               },
-            }),
-            close: () => {},
-         };
-      },
-      {
-         supports: {
-            batching: true,
-            softscans: false,
-         },
-         excludeTables: ["_cf_KV", "_cf_METADATA"],
-      },
-   );
-}

app/src/adapter/cloudflare/connection/D1Connection.vitest.ts

@@ -1,33 +0,0 @@
-import { describe, test, expect } from "vitest";
-
-import { viTestRunner } from "adapter/node/vitest";
-import { connectionTestSuite } from "data/connection/connection-test-suite";
-import { Miniflare } from "miniflare";
-import { d1Sqlite } from "./D1Connection";
-
-describe("d1Sqlite", async () => {
-   connectionTestSuite(viTestRunner, {
-      makeConnection: async () => {
-         const mf = new Miniflare({
-            modules: true,
-            script: "export default { async fetch() { return new Response(null); } }",
-            d1Databases: ["DB"],
-         });
-
-         const binding = (await mf.getD1Database("DB")) as D1Database;
-         return {
-            connection: d1Sqlite({ binding }),
-            dispose: () => mf.dispose(),
-         };
-      },
-      rawDialectDetails: [
-         "meta.served_by",
-         "meta.duration",
-         "meta.changes",
-         "meta.changed_db",
-         "meta.size_after",
-         "meta.rows_read",
-         "meta.rows_written",
-      ],
-   });
-});

app/src/adapter/cloudflare/connection/DoConnection.ts

@@ -1,80 +0,0 @@
-/// <reference types="@cloudflare/workers-types" />
-
-import { genericSqlite, type GenericSqliteConnection } from "bknd/data";
-import type { QueryResult } from "kysely";
-
-export type D1SqliteConnection = GenericSqliteConnection<D1Database>;
-export type DurableObjecSql = DurableObjectState["storage"]["sql"];
-
-export type D1ConnectionConfig<DB extends DurableObjecSql> =
-   | DurableObjectState
-   | {
-        sql: DB;
-     };
-
-export function doSqlite<DB extends DurableObjecSql>(config: D1ConnectionConfig<DB>) {
-   const db = "sql" in config ? config.sql : config.storage.sql;
-
-   return genericSqlite(
-      "do-sqlite",
-      db,
-      (utils) => {
-         // must be async to work with the miniflare mock
-         const getStmt = async (sql: string, parameters?: any[] | readonly any[]) =>
-            await db.exec(sql, ...(parameters || []));
-
-         const mapResult = (
-            cursor: SqlStorageCursor<Record<string, SqlStorageValue>>,
-         ): QueryResult<any> => {
-            const numAffectedRows =
-               cursor.rowsWritten > 0 ? utils.parseBigInt(cursor.rowsWritten) : undefined;
-            const insertId = undefined;
-
-            const obj = {
-               insertId,
-               numAffectedRows,
-               rows: cursor.toArray() || [],
-               // @ts-ignore
-               meta: {
-                  rowsWritten: cursor.rowsWritten,
-                  rowsRead: cursor.rowsRead,
-                  databaseSize: db.databaseSize,
-               },
-            };
-            //console.info("mapResult", obj);
-            return obj;
-         };
-
-         return {
-            db,
-            batch: async (stmts) => {
-               // @todo: maybe wrap in a transaction?
-               // because d1 implicitly does a transaction on batch
-               return Promise.all(
-                  stmts.map(async (stmt) => {
-                     return mapResult(await getStmt(stmt.sql, stmt.parameters));
-                  }),
-               );
-            },
-            query: utils.buildQueryFn({
-               all: async (sql, parameters) => {
-                  const prep = getStmt(sql, parameters);
-                  return mapResult(await prep).rows;
-               },
-               run: async (sql, parameters) => {
-                  const prep = getStmt(sql, parameters);
-                  return mapResult(await prep);
-               },
-            }),
-            close: () => {},
-         };
-      },
-      {
-         supports: {
-            batching: true,
-            softscans: false,
-         },
-         excludeTables: ["_cf_KV", "_cf_METADATA"],
-      },
-   );
-}

app/src/adapter/cloudflare/connection/DoConnection.vitest.ts

@@ -1,92 +0,0 @@
-/// <reference types="@cloudflare/workers-types" />
-
-import { describe, test, expect } from "vitest";
-
-import { viTestRunner } from "adapter/node/vitest";
-import { connectionTestSuite } from "data/connection/connection-test-suite";
-import { Miniflare } from "miniflare";
-import { doSqlite } from "./DoConnection";
-
-const script = `
-import { DurableObject } from "cloudflare:workers";
-
-export class TestObject extends DurableObject {
-    constructor(ctx, env) {
-      super(ctx, env);
-      this.storage = ctx.storage;
-   }
-      
-   async exec(sql, ...parameters) {
-      //return { sql, parameters }
-      const cursor = this.storage.sql.exec(sql, ...parameters);
-      return {
-         rows: cursor.toArray() || [],
-         rowsWritten: cursor.rowsWritten,
-         rowsRead: cursor.rowsRead,
-         databaseSize: this.storage.sql.databaseSize,
-      }
-   }
-      
-   async databaseSize() {
-      return this.storage.sql.databaseSize;
-   }
-}
-   
-export default {
-   async fetch(request, env) {
-      const stub = env.TEST_OBJECT.get(env.TEST_OBJECT.idFromName("test"));
-      return stub.fetch(request);
-   }
-}
-`;
-
-describe("doSqlite", async () => {
-   connectionTestSuite(viTestRunner, {
-      makeConnection: async () => {
-         const mf = new Miniflare({
-            modules: true,
-            durableObjects: { TEST_OBJECT: { className: "TestObject", useSQLite: true } },
-            script,
-         });
-
-         const ns = await mf.getDurableObjectNamespace("TEST_OBJECT");
-         const id = ns.idFromName("test");
-         const stub = ns.get(id) as unknown as DurableObjectStub<
-            Rpc.DurableObjectBranded & {
-               exec: (sql: string, ...parameters: any[]) => Promise<any>;
-            }
-         >;
-
-         const stubs: any[] = [];
-         const mock = {
-            databaseSize: 0,
-            exec: async function (sql: string, ...parameters: any[]) {
-               // @ts-ignore
-               const result = (await stub.exec(sql, ...parameters)) as any;
-               this.databaseSize = result.databaseSize;
-               stubs.push(result);
-               return {
-                  toArray: () => result.rows,
-                  rowsWritten: result.rowsWritten,
-                  rowsRead: result.rowsRead,
-               };
-            },
-         };
-
-         return {
-            connection: doSqlite({ sql: mock as any }),
-            dispose: async () => {
-               await Promise.all(
-                  stubs.map((stub) => {
-                     try {
-                        return stub[Symbol.dispose]();
-                     } catch (e) {}
-                  }),
-               );
-               await mf.dispose();
-            },
-         };
-      },
-      rawDialectDetails: ["meta.rowsWritten", "meta.rowsRead", "meta.databaseSize"],
-   });
-});