admin ui: store data canvas positions

.github/workflows/test.yml

@@ -15,20 +15,12 @@ jobs:
       - name: Setup Bun
         uses: oven-sh/setup-bun@v1
         with:
-          bun-version: "1.2.5"
+          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
-
-      - name: Run Bun tests
-        working-directory: ./app
-        run: bun run test:bun
-
-      - name: Run Node tests
-        working-directory: ./app
-        run: npm run test:node
+        run: bun run test

app/.gitignore

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

app/__test__/adapter/adapter.test.ts

@@ -1,62 +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";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-describe("adapter", () => {
-   it("makes config", () => {
-      expect(adapter.makeConfig({})).toEqual({});
-      expect(adapter.makeConfig({}, { env: { TEST: "test" } })).toEqual({});
-
-      // merges everything returned from `app` with the config
-      expect(adapter.makeConfig({ app: (a) => a as any }, { env: { TEST: "test" } })).toEqual({
-         env: { TEST: "test" },
-      } as any);
-   });
-
-   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

@@ -5,8 +5,7 @@ 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 } from "core/utils/test";
+import { disableConsoleLog, enableConsoleLog, schemaToEm } from "../helper";
 
 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 () => {

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 { MediaApi } from "media/api/MediaApi";
+import { getFileFromContext, isFile, isReadableStream } from "../../src/core/utils";
+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(
-         {
-            upload_fetcher: mockedBackend.request,
-         },
-         mockedBackend.request,
-      );
+      // @ts-ignore tests
+      const api = new MediaApi({}, 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 "../../src/App";
+import { type App, createApp } from "../../src/App";
 import * as proto from "../../src/data/prototype";
 
 describe("App", () => {
@@ -51,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/repro.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 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 () => {
    /**

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 { type TObject, type TString, Type } from "@sinclair/typebox";
-import { Registry } from "core";
+import type { TObject, TString } from "@sinclair/typebox";
+import { Registry } from "../../src/core/registry/Registry";
+import { type TSchema, Type } from "../../src/core/utils";
 
 type Constructor<T> = new (...args: any[]) => T;
 

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,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { SchemaObject } from "../../../src/core";
-import { Type } from "@sinclair/typebox";
+import { Type } from "../../../src/core/utils";
 
 describe("SchemaObject", async () => {
    test("basic", async () => {

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/specs/Entity.spec.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { Entity, NumberField, TextField } from "data";
-import * as p from "data/prototype";
+import { Entity, NumberField, TextField } from "../../../src/data";
 
 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 () => {
-      console.log(entity.toTypes());
-   });
+   // @todo: move this to ClientApp
+   /*test("serialize and deserialize", async () => {
+      const json = entity.toJSON();
+      //sconsole.log("json", json.fields);
+      const newEntity = Entity.deserialize(json);
+      //console.log("newEntity", newEntity.toJSON().fields);
+      expect(newEntity).toBeInstanceOf(Entity);
+      expect(json).toEqual(newEntity.toJSON());
+      expect(json.fields).toEqual(newEntity.toJSON().fields);
+   });*/
 });

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

@@ -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("posts")).toEqual([em.relations.all[0]!]);
+      expect(em.relationsOf("users")).toEqual([em.relations.all[0]]);
+      expect(em.relationsOf("posts")).toEqual([em.relations.all[0]]);
       expect(em.hasRelations("users")).toBe(true);
       expect(em.hasRelations("posts")).toBe(true);
       expect(em.relatedEntitiesOf("users")).toEqual([posts]);

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

@@ -288,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,
-   text as $text,
-   em as $em,
-} from "data";
+} from "../../../src/data";
 import { getDummyConnection } from "../helper";
 
 type E = Kysely<any> | Transaction<any>;
@@ -180,47 +177,6 @@ describe("[Repository]", async () => {
       const res5 = await em.repository(items).exists({});
       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
-      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")
-            .findMany({})
-            .then((r) => [r.meta.count, r.meta.total]),
-      ).resolves.toEqual([0, 0]);
-
-      expect(
-         em
-            .repo("items", { includeCounts: false })
-            .findMany({})
-            .then((r) => [r.meta.count, r.meta.total]),
-      ).resolves.toEqual([undefined, undefined]);
-   });
 });
 
 describe("[data] Repository (Events)", async () => {
@@ -242,36 +198,24 @@ describe("[data] Repository (Events)", async () => {
    });
 
    test("events were fired", async () => {
-      const repo = em.repository(items);
-      await repo.findId(1);
-      await repo.emgr.executeAsyncs();
+      await em.repository(items).findId(1);
       expect(events.has(RepositoryEvents.RepositoryFindOneBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindOneAfter.slug)).toBeTrue();
       events.clear();
 
-      await repo.findOne({ id: 1 });
-      await repo.emgr.executeAsyncs();
+      await em.repository(items).findOne({ id: 1 });
       expect(events.has(RepositoryEvents.RepositoryFindOneBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindOneAfter.slug)).toBeTrue();
       events.clear();
 
-      await repo.findMany({ where: { id: 1 } });
-      await repo.emgr.executeAsyncs();
+      await em.repository(items).findMany({ where: { id: 1 } });
       expect(events.has(RepositoryEvents.RepositoryFindManyBefore.slug)).toBeTrue();
       expect(events.has(RepositoryEvents.RepositoryFindManyAfter.slug)).toBeTrue();
       events.clear();
 
-      await repo.findManyByReference(1, "categories");
-      await repo.emgr.executeAsyncs();
+      await em.repository(items).findManyByReference(1, "categories");
       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/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,9 +1,9 @@
 import { describe, expect, test } from "bun:test";
 import { DateField } from "../../../../src/data";
-import { fieldTestSuite } from "data/fields/field-test-suite";
+import { runBaseFieldTests } from "./inc";
 
 describe("[data] DateField", async () => {
-   fieldTestSuite({ expect, test }, DateField, { defaultValue: new Date(), schemaType: "date" });
+   runBaseFieldTests(DateField, { defaultValue: new Date(), schemaType: "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(
-      { expect, test },
-      // @ts-ignore
+   runBaseFieldTests(
       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,7 +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";
 
 describe("[data] Field", async () => {
    class FieldSpec extends Field {
@@ -19,7 +19,7 @@ describe("[data] Field", async () => {
       });
    });
 
-   fieldTestSuite({ expect, test }, FieldSpec, { defaultValue: "test", schemaType: "text" });
+   runBaseFieldTests(FieldSpec, { defaultValue: "test", schemaType: "text" });
 
    test("default config", async () => {
       const config = Default(baseFieldConfigSchema, {});

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

@@ -1,13 +1,19 @@
 import { describe, expect, test } from "bun:test";
-import { Type } from "@sinclair/typebox";
-import { Entity, EntityIndex, Field } from "../../../../src/data";
+import { Type } from "../../../../src/core/utils";
+import {
+   Entity,
+   EntityIndex,
+   type EntityManager,
+   Field,
+   type SchemaResponse,
+} from "../../../../src/data";
 
 class TestField extends Field {
    protected getSchema(): 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
-   fieldTestSuite({ expect, test }, JsonSchemaField, { defaultValue: {}, schemaType: "text" });
+   runBaseFieldTests(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/TextField.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { TextField } from "../../../../src/data";
-import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
+import { runBaseFieldTests, transformPersist } from "./inc";
 
 describe("[data] TextField", async () => {
    test("transformPersist (config)", async () => {
@@ -11,5 +11,5 @@ describe("[data] TextField", async () => {
       expect(transformPersist(field, "abc")).resolves.toBe("abc");
    });
 
-   fieldTestSuite({ expect, test }, 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(
-   testRunner: TestRunner,
+export function runBaseFieldTests(
    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 });
@@ -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,9 +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) {
@@ -112,16 +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,
       });
 
       expect(fieldJson(required)).toEqual({
+         //name: "required",
          type: required.type,
          config: {
             ..._config,
@@ -130,6 +134,7 @@ export function fieldTestSuite(
       });
 
       expect(fieldJson(hidden)).toEqual({
+         //name: "hidden",
          type: required.type,
          config: {
             ..._config,
@@ -138,6 +143,7 @@ export function fieldTestSuite(
       });
 
       expect(fieldJson(dflt)).toEqual({
+         //name: "dflt",
          type: dflt.type,
          config: {
             ..._config,
@@ -146,6 +152,7 @@ export function fieldTestSuite(
       });
 
       expect(fieldJson(requiredAndDefault)).toEqual({
+         //name: "full",
          type: requiredAndDefault.type,
          config: {
             ..._config,

app/__test__/flows/SubWorkflowTask.spec.ts

@@ -1,23 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { Flow, LogTask, SubFlowTask, RenderTask, Task } from "../../src/flows";
-import { Type } from "@sinclair/typebox";
-
-export class StringifyTask<Output extends string> extends Task<
-   typeof StringifyTask.schema,
-   Output
-> {
-   type = "stringify";
-
-   static override schema = Type.Optional(
-      Type.Object({
-         input: Type.Optional(Type.String()),
-      }),
-   );
-
-   async execute() {
-      return JSON.stringify(this.params.input) as Output;
-   }
-}
+import { Flow, LogTask, RenderTask, SubFlowTask } from "../../src/flows";
 
 describe("SubFlowTask", async () => {
    test("Simple Subflow", async () => {
@@ -40,6 +22,8 @@ describe("SubFlowTask", async () => {
 
       const execution = flow.createExecution();
       await execution.start();
+      /*console.log(execution.logs);
+      console.log(execution.getResponse());*/
 
       expect(execution.getResponse()).toEqual("Subflow output: subflow");
    });
@@ -56,8 +40,8 @@ describe("SubFlowTask", async () => {
          loop: true,
          input: [1, 2, 3],
       });
-      const task3 = new StringifyTask("stringify", {
-         input: "{{ sub.output }}",
+      const task3 = new RenderTask("render2", {
+         render: `Subflow output: {{ sub.output | join: ", " }}`,
       });
 
       const flow = new Flow("test", [task, task2, task3], []);
@@ -67,6 +51,41 @@ describe("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,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { Type } from "@sinclair/typebox";
+import { Type } from "../../src/core/utils";
 import { Task } from "../../src/flows";
 import { dynamic } from "../../src/flows/tasks/Task";
 
@@ -51,4 +51,62 @@ describe("Task", async () => {
 
       expect(result.test).toEqual({ key: "path", value: "1/1" });
    });
+
+   test("resolveParams: with json", async () => {
+      const result = await Task.resolveParams(
+         Type.Object({
+            test: dynamic(Type.Object({ key: Type.String(), value: Type.String() })),
+         }),
+         {
+            test: "{{ some | json }}",
+         },
+         {
+            some: {
+               key: "path",
+               value: "1/1",
+            },
+         },
+      );
+
+      expect(result.test).toEqual({ key: "path", value: "1/1" });
+   });
+
+   test("resolveParams: with array", async () => {
+      const result = await Task.resolveParams(
+         Type.Object({
+            test: dynamic(Type.Array(Type.String())),
+         }),
+         {
+            test: '{{ "1,2,3" | split: "," | json }}',
+         },
+      );
+
+      expect(result.test).toEqual(["1", "2", "3"]);
+   });
+
+   test("resolveParams: boolean", async () => {
+      const result = await Task.resolveParams(
+         Type.Object({
+            test: dynamic(Type.Boolean()),
+         }),
+         {
+            test: "{{ true }}",
+         },
+      );
+
+      expect(result.test).toEqual(true);
+   });
+
+   test("resolveParams: float", async () => {
+      const result = await Task.resolveParams(
+         Type.Object({
+            test: dynamic(Type.Number(), Number.parseFloat),
+         }),
+         {
+            test: "{{ 3.14 }}",
+         },
+      );
+
+      expect(result.test).toEqual(3.14);
+   });
 });

app/__test__/flows/inputs.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { Hono } from "hono";
 import { Event, EventManager } from "../../src/core/events";
-import { parse } from "../../src/core/utils";
-import { type Static, type StaticDecode, Type } from "@sinclair/typebox";
+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";
 

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 } from "@sinclair/typebox";
+import { type Static, Type, _jsonp, withDisabledConsole } from "../../src/core/utils";
 import { Condition, ExecutionEvent, FetchTask, Flow, LogTask, Task } from "../../src/flows";
 
 /*beforeAll(disableConsoleLog);

app/__test__/helper.ts

@@ -78,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__/media/MediaController.spec.ts

@@ -4,7 +4,7 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 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(() => {

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 = [
-         [".mp4", "video/mp4", ".jpg", "image/jpeg", ".zip", "application/zip"],
-      ] as const;
+      const tests = [[".mp4", "video/mp4", ".jpg", "image/jpeg", ".zip", "application/zip"]];
 
       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

@@ -69,7 +69,7 @@ describe("AppAuth", () => {
             },
             body: JSON.stringify({
                email: "some@body.com",
-               password: "12345678",
+               password: "123456",
             }),
          });
          enableConsoleLog();
@@ -81,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: {

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 "../../src/core/utils";
 import { fieldsSchema } from "../../src/data/data-schema";
-import { AppData, type ModuleBuildContext } from "../../src/modules";
-import { makeCtx, moduleTestSuite } from "./module-test-suite";
-import * as proto from "data/prototype";
+import { AppData } from "../../src/modules";
+import { moduleTestSuite } from "./module-test-suite";
 
 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,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 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/modules";
 import { moduleTestSuite } from "./module-test-suite";
 

app/__test__/modules/Module.spec.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { stripMark } from "../../src/core/utils";
-import { type TSchema, Type } from "@sinclair/typebox";
+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";
@@ -10,10 +9,10 @@ function createModule<Schema extends TSchema>(schema: Schema) {
       getSchema() {
          return schema;
       }
-      override toJSON() {
+      toJSON() {
          return this.config;
       }
-      override useForceParse() {
+      useForceParse() {
          return true;
       }
    }

app/__test__/modules/ModuleManager.spec.ts

@@ -1,13 +1,10 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { disableConsoleLog, enableConsoleLog, stripMark } from "core/utils";
-import { Type } from "@sinclair/typebox";
-import { Connection, entity, text } from "data";
-import { Module } from "modules/Module";
-import { type ConfigTable, getDefaultConfig, ModuleManager } from "modules/ModuleManager";
-import { CURRENT_VERSION, TABLE_NAME } from "modules/migrations";
+import { Type, disableConsoleLog, enableConsoleLog, stripMark } from "../../src/core/utils";
+import { entity, text } from "../../src/data";
+import { Module } from "../../src/modules/Module";
+import { ModuleManager, getDefaultConfig } from "../../src/modules/ModuleManager";
+import { CURRENT_VERSION, TABLE_NAME } from "../../src/modules/migrations";
 import { getDummyConnection } from "../helper";
-import { diff } from "core/object/diff";
-import type { Static } from "@sinclair/typebox";
 
 describe("ModuleManager", async () => {
    test("s1: no config, no build", async () => {
@@ -383,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 = Type.Object({
-         value: Type.Array(Type.Number(), { default: [] }),
-      });
-      type SampleSchema = Static<typeof schema>;
-      class Sample extends Module<typeof schema> {
-         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__/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.ts

@@ -54,7 +54,7 @@ function banner(title: string) {
 }
 
 // collection of always-external packages
-const external = ["bun:test", "node:test", "node:assert/strict", "@libsql/client"] as const;
+const external = ["bun:test", "@libsql/client"] as const;
 
 /**
  * Building backend and general API
@@ -65,13 +65,7 @@ async function buildApi() {
       minify,
       sourcemap,
       watch,
-      entry: [
-         "src/index.ts",
-         "src/core/index.ts",
-         "src/core/utils/index.ts",
-         "src/data/index.ts",
-         "src/media/index.ts",
-      ],
+      entry: ["src/index.ts", "src/data/index.ts", "src/core/index.ts", "src/core/utils/index.ts"],
       outDir: "dist",
       external: [...external],
       metafile: true,

app/e2e/adapters.ts

@@ -1,214 +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"),
-      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);
-
-   await $`TEST_URL=${data} TEST_ADAPTER=${name} bun run test:e2e`;
-   console.log("DONE!");
-
-   while (!proc.killed) {
-      proc.kill("SIGINT");
-      await Bun.sleep(250);
-      console.log("Waiting for process to exit...");
-   }
-}
-
-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.12.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": {
@@ -14,10 +14,11 @@
     "url": "https://github.com/bknd-io/bknd/issues"
   },
   "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:static": "vite build",
     "watch": "bun run build.ts --types --watch",
@@ -26,50 +27,38 @@
     "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 ./",
-    "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": "tsx --test $(find . -type f -name '*.native-spec.ts')",
-    "test:adapters": "bun test src/adapter/**/*.adapter.spec.ts --bail",
-    "test:coverage": "ALL_TESTS=1 bun test --bail --coverage",
-    "test:vitest": "vitest run",
-    "test:vitest:watch": "vitest",
-    "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"
+    "prepublishOnly": "bun run types && bun run test && bun run build:all && cp ../README.md ./",
+    "postpublish": "rm -f README.md"
   },
   "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",
-    "@libsql/client": "^0.15.2",
+    "@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.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",
-    "lodash-es": "^4.17.21",
-    "@sinclair/typebox": "0.34.30"
+    "swr": "^2.3.3"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.758.0",
@@ -81,23 +70,18 @@
     "@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",
     "@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",
     "kysely-d1": "^0.3.0",
     "open": "^10.1.0",
     "openapi-types": "^12.1.3",
@@ -105,7 +89,6 @@
     "postcss-preset-mantine": "^1.17.0",
     "postcss-simple-vars": "^7.0.1",
     "posthog-js-lite": "^3.4.2",
-    "picocolors": "^1.1.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-hook-form": "^7.54.2",
@@ -117,10 +100,8 @@
     "tailwindcss-animate": "^1.0.7",
     "tsc-alias": "^1.8.11",
     "tsup": "^8.4.0",
-    "tsx": "^4.19.3",
     "vite": "^6.2.1",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.9",
     "wouter": "^3.6.0"
   },
   "optionalDependencies": {
@@ -137,52 +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"
-    },
-    "./media": {
-      "types": "./dist/types/media/index.d.ts",
-      "import": "./dist/media/index.js",
-      "require": "./dist/media/index.js"
+      "require": "./dist/cli/index.cjs"
     },
     "./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",
@@ -191,37 +167,37 @@
     "./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",

app/playwright.config.ts

@@ -1,42 +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);
-
-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: 20000,
-   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

@@ -8,11 +8,6 @@ import { omitKeys } from "core/utils";
 
 export type TApiUser = SafeUser;
 
-export type ApiFetcher = (
-   input: RequestInfo | URL,
-   init?: RequestInit,
-) => Response | Promise<Response>;
-
 declare global {
    interface Window {
       __BKND__: {
@@ -26,7 +21,7 @@ export type ApiOptions = {
    headers?: Headers;
    key?: string;
    localStorage?: boolean;
-   fetcher?: ApiFetcher;
+   fetcher?: typeof fetch;
    verbose?: boolean;
    verified?: boolean;
 } & (
@@ -83,10 +78,6 @@ export class Api {
       this.buildApis();
    }
 
-   get fetcher() {
-      return this.options.fetcher ?? fetch;
-   }
-
    get baseUrl() {
       return this.options.host ?? "http://localhost";
    }
@@ -122,6 +113,8 @@ export class Api {
             this.updateToken(token);
          }
       }
+
+      //console.warn("Couldn't extract token");
    }
 
    updateToken(token?: string, rebuild?: boolean) {

app/src/App.ts

@@ -4,10 +4,9 @@ import { Event } from "core/events";
 import { Connection, type LibSqlCredentials, LibsqlConnection } from "data";
 import type { Hono } from "hono";
 import {
-   ModuleManager,
    type InitialModuleConfigs,
    type ModuleBuildContext,
-   type ModuleConfigs,
+   ModuleManager,
    type ModuleManagerOptions,
    type Modules,
 } from "modules/ModuleManager";
@@ -15,9 +14,8 @@ import * as SystemPermissions from "modules/permissions";
 import { AdminController, type AdminControllerOptions } from "modules/server/AdminController";
 import { SystemController } from "modules/server/SystemController";
 
-// biome-ignore format: must be here
+// biome-ignore format: must be there
 import { Api, type ApiOptions } from "Api";
-import type { ServerEnv } from "modules/Controller";
 
 export type AppPlugin = (app: App) => Promise<void> | void;
 
@@ -31,25 +29,12 @@ export class AppBuiltEvent extends AppEvent {
 export class AppFirstBoot extends AppEvent {
    static override slug = "app-first-boot";
 }
-export class AppRequest extends AppEvent<{ request: Request }> {
-   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 const AppEvents = { AppConfigUpdatedEvent, AppBuiltEvent, AppFirstBoot } as const;
 
 export type AppOptions = {
    plugins?: AppPlugin[];
    seed?: (ctx: ModuleBuildContext & { app: App }) => Promise<void>;
    manager?: Omit<ModuleManagerOptions, "initial" | "onUpdated" | "seed">;
-   asyncEventsMode?: "sync" | "async" | "none";
 };
 export type CreateAppConfig = {
    connection?:
@@ -68,14 +53,12 @@ export type AppConfig = InitialModuleConfigs;
 export type LocalApiOptions = Request | ApiOptions;
 
 export class App {
-   static readonly Events = AppEvents;
-
    modules: ModuleManager;
+   static readonly Events = AppEvents;
    adminController?: AdminController;
-   _id: string = crypto.randomUUID();
-
    private trigger_first_boot = false;
    private plugins: AppPlugin[];
+   private _id: string = crypto.randomUUID();
    private _building: boolean = false;
 
    constructor(
@@ -87,9 +70,35 @@ export class App {
       this.modules = new ModuleManager(connection, {
          ...(options?.manager ?? {}),
          initial: _initialConfig,
-         onUpdated: this.onUpdated.bind(this),
-         onFirstBoot: this.onFirstBoot.bind(this),
-         onServerInit: this.onServerInit.bind(this),
+         onUpdated: async (key, config) => {
+            // 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", 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);
    }
@@ -180,10 +189,7 @@ export class App {
    registerAdminController(config?: AdminControllerOptions) {
       // register admin
       this.adminController = new AdminController(this, config);
-      this.modules.server.route(
-         this.adminController.basepath,
-         this.adminController.getController(),
-      );
+      this.modules.server.route(config?.basepath ?? "/", this.adminController.getController());
       return this;
    }
 
@@ -207,53 +213,6 @@ export class App {
 
       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 }));
-   }
-
-   async onFirstBoot() {
-      $console.log("App first boot");
-      this.trigger_first_boot = true;
-   }
-
-   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;
-         }
-      });
-   }
 }
 
 export function createApp(config: CreateAppConfig = {}) {

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>(
-   config: AstroBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts: FrameworkOptions = {},
-) {
-   return await createFrameworkApp(config, args ?? import.meta.env, opts);
+export type Options = {
+   mode?: "static" | "dynamic";
+} & Omit<ApiOptions, "host"> & {
+      host?: string;
+   };
+
+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>(
-   config: AstroBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: FrameworkOptions,
-) {
-   return async (fnArgs: TAstro) => {
-      return (await getApp(config, args, opts)).fetch(fnArgs.request);
+let app: App;
+export function serve<Context extends TAstro = TAstro>(config: AstroBkndConfig<Context> = {}) {
+   return async (args: Context) => {
+      if (!app) {
+         app = await createFrameworkApp(config, args);
+      }
+      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, type RuntimeOptions } from "bknd/adapter";
+import { type RuntimeBkndConfig, createRuntimeApp } from "bknd/adapter";
 
-type AwsLambdaEnv = object;
-export type AwsLambdaBkndConfig<Env extends AwsLambdaEnv = AwsLambdaEnv> =
-   RuntimeBkndConfig<Env> & {
-      assets?:
-         | {
-              mode: "local";
-              root: string;
-           }
-         | {
-              mode: "url";
-              url: string;
-           };
-   };
+export type AwsLambdaBkndConfig = RuntimeBkndConfig & {
+   assets?:
+      | {
+           mode: "local";
+           root: string;
+        }
+      | {
+           mode: "url";
+           url: string;
+        };
+};
 
-export async function createApp<Env extends AwsLambdaEnv = AwsLambdaEnv>(
-   { adminOptions = false, assets, ...config }: AwsLambdaBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-): Promise<App> {
-   let additional: Partial<RuntimeBkndConfig> = {
-      adminOptions,
-   };
+let app: App;
+export async function createApp({
+   adminOptions = false,
+   assets,
+   ...config
+}: AwsLambdaBkndConfig = {}) {
+   if (!app) {
+      let additional: Partial<RuntimeBkndConfig> = {
+         adminOptions,
+      };
 
-   if (assets?.mode) {
-      switch (assets.mode) {
-         case "local":
-            // @todo: serve static outside app context
-            additional = {
-               adminOptions: adminOptions === false ? undefined : adminOptions,
-               serveStatic: serveStatic({
-                  root: assets.root,
-                  onFound: (path, c) => {
-                     c.res.headers.set("Cache-Control", "public, max-age=31536000");
-                  },
-               }),
-            };
-            break;
-         case "url":
-            additional.adminOptions = {
-               ...(typeof adminOptions === "object" ? adminOptions : {}),
-               assetsPath: assets.url,
-            };
-            break;
-         default:
-            throw new Error("Invalid assets mode");
+      if (assets?.mode) {
+         switch (assets.mode) {
+            case "local":
+               // @todo: serve static outside app context
+               additional = {
+                  adminOptions: adminOptions === false ? undefined : adminOptions,
+                  serveStatic: (await import("@hono/node-server/serve-static")).serveStatic({
+                     root: assets.root,
+                     onFound: (path, c) => {
+                        c.res.headers.set("Cache-Control", "public, max-age=31536000");
+                     },
+                  }),
+               };
+               break;
+            case "url":
+               additional.adminOptions = {
+                  ...(typeof adminOptions === "object" ? adminOptions : {}),
+                  assets_path: assets.url,
+               };
+               break;
+            default:
+               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>(
-   config: AwsLambdaBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
+export function serveLambda(config: AwsLambdaBkndConfig = {}) {
+   console.log("serving lambda");
    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,64 +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 { 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";
 
-type BunEnv = Bun.Env;
-export type BunBkndConfig<Env = BunEnv> = RuntimeBkndConfig<Env> & Omit<ServeOptions, "fetch">;
+let app: App;
 
-export async function createApp<Env = BunEnv>(
-   { distPath, ...config }: BunBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
+export type BunBkndConfig = RuntimeBkndConfig & Omit<ServeOptions, "fetch">;
+
+export async function createApp({ distPath, ...config }: RuntimeBkndConfig = {}) {
    const root = path.resolve(distPath ?? "./node_modules/bknd/dist", "static");
-   registerLocalMediaAdapter();
 
-   return await createRuntimeApp(
-      {
+   if (!app) {
+      registerLocalMediaAdapter();
+      app = await createRuntimeApp({
          ...config,
          serveStatic: serveStatic({ root }),
-      },
-      args ?? (process.env as Env),
-      opts,
-   );
+      });
+   }
+
+   return app;
 }
 
-export function createHandler<Env = BunEnv>(
-   config: BunBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
-   return async (req: Request) => {
-      const app = await createApp(config, args ?? (process.env as Env), opts);
-      return app.fetch(req);
-   };
-}
-
-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,
-) {
+export function serve({
+   distPath,
+   connection,
+   initialConfig,
+   options,
+   port = config.server.default_port,
+   onBuilt,
+   buildConfig,
+   adminOptions,
+   ...serveOptions
+}: BunBkndConfig = {}) {
    Bun.serve({
       ...serveOptions,
       port,
-      fetch: createHandler(
-         {
+      fetch: async (request: Request) => {
+         const app = await createApp({
             connection,
             initialConfig,
             options,
@@ -66,10 +49,9 @@ export function serve<Env = BunEnv>(
             buildConfig,
             adminOptions,
             distPath,
-         },
-         args,
-         opts,
-      ),
+         });
+         return app.fetch(request);
+      },
    });
 
    console.log(`Server is running on http://localhost:${port}`);

app/src/adapter/bun/test.ts

@@ -1,7 +0,0 @@
-import { expect, test, mock } from "bun:test";
-
-export const bunTestRunner = {
-   expect,
-   test,
-   mock,
-};

app/src/adapter/cloudflare/D1Connection.ts

@@ -12,7 +12,7 @@ export type D1ConnectionConfig = {
 class CustomD1Dialect extends D1Dialect {
    override createIntrospector(db: Kysely<any>): DatabaseIntrospector {
       return new SqliteIntrospector(db, {
-         excludeTables: ["_cf_KV", "_cf_METADATA"],
+         excludeTables: ["_cf_KV"],
       });
    }
 }
@@ -32,10 +32,6 @@ export class D1Connection extends SqliteConnection {
       super(kysely, {}, plugins);
    }
 
-   get client(): D1Database {
-      return this.config.binding;
-   }
-
    protected override async batch<Queries extends QB[]>(
       queries: [...Queries],
    ): Promise<{

app/src/adapter/cloudflare/StorageR2Adapter.ts

@@ -1,10 +1,9 @@
 import { registries } from "bknd";
 import { isDebug } from "bknd/core";
-import { StringEnum } from "bknd/utils";
-import { guessMimeType as guess, StorageAdapter, type FileBody } from "bknd/media";
-import { getBindings } from "../bindings";
-import * as tb from "@sinclair/typebox";
-const { Type } = tb;
+import { StringEnum, Type } from "bknd/utils";
+import type { FileBody, StorageAdapter } from "media/storage/Storage";
+import { guess } from "media/storage/mime-types-tiny";
+import { getBindings } from "./bindings";
 
 export function makeSchema(bindings: string[] = []) {
    return Type.Object(
@@ -48,10 +47,8 @@ export function registerMedia(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 {
-   constructor(private readonly bucket: R2Bucket) {
-      super();
-   }
+export class StorageR2Adapter implements StorageAdapter {
+   constructor(private readonly bucket: R2Bucket) {}
 
    getName(): string {
       return "r2";
@@ -124,10 +121,12 @@ 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: object.range ? 206 : 200,

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

@@ -1,60 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { makeApp } from "./modes/fresh";
-import { makeConfig } 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 ?? { DB_URL },
-      ctx: ctx ?? (null as any),
-   });
-
-   it("makes config", async () => {
-      expect(
-         makeConfig(
-            {
-               connection: { url: DB_URL },
-            },
-            {},
-         ),
-      ).toEqual({ connection: { url: DB_URL } });
-
-      expect(
-         makeConfig(
-            {
-               app: (env) => ({
-                  connection: { url: env.DB_URL },
-               }),
-            },
-            {
-               DB_URL,
-            },
-         ),
-      ).toEqual({ connection: { url: DB_URL } });
-   });
-
-   adapterTestSuite<CloudflareBkndConfig, object>(bunTestRunner, {
-      makeApp,
-      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,18 +1,18 @@
 /// <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 { $console } from "core";
+import { getFresh, getWarm } from "./modes/fresh";
 
-export type CloudflareEnv = object;
-export type CloudflareBkndConfig<Env = CloudflareEnv> = RuntimeBkndConfig<Env> & {
+export type CloudflareBkndConfig<Env = any> = FrameworkBkndConfig<Context<Env>> & {
    mode?: "warm" | "fresh" | "cache" | "durable";
-   bindings?: (args: Env) => {
+   bindings?: (args: Context<Env>) => {
       kv?: KVNamespace;
       dobj?: DurableObjectNamespace;
       db?: D1Database;
@@ -22,28 +22,60 @@ export type CloudflareBkndConfig<Env = CloudflareEnv> = RuntimeBkndConfig<Env> &
    keepAliveSeconds?: number;
    forceHttps?: boolean;
    manifest?: string;
+   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>(
-   config: CloudflareBkndConfig<Env> = {},
-) {
+let media_registered: boolean = false;
+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) {
@@ -67,27 +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 });
-               break;
+               return await getFresh(config, context);
             case "warm":
-               app = await getFresh(config, context);
-               break;
+               return await getWarm(config, context);
             case "cache":
-               app = await getCached(config, context);
-               break;
+               return await getCached(config, context);
             case "durable":
                return await getDurable(config, context);
             default:
                throw new Error(`Unknown mode ${mode}`);
          }
-
-         return app.fetch(request, env, ctx);
       },
    };
 }

app/src/adapter/cloudflare/config.ts

@@ -1,65 +0,0 @@
-import { registerMedia } from "./storage/StorageR2Adapter";
-import { getBinding } from "./bindings";
-import { D1Connection } from "./D1Connection";
-import type { CloudflareBkndConfig, CloudflareEnv } from ".";
-import { App } from "bknd";
-import { makeConfig as makeAdapterConfig } from "bknd/adapter";
-import type { ExecutionContext } from "hono";
-import { $console } from "core";
-
-export const constants = {
-   exec_async_event_id: "cf_register_waituntil",
-   cache_endpoint: "/__bknd/cache",
-   do_endpoint: "/__bknd/do",
-};
-
-let media_registered: boolean = false;
-export function makeConfig<Env extends CloudflareEnv = CloudflareEnv>(
-   config: CloudflareBkndConfig<Env>,
-   args: Env = {} as Env,
-) {
-   if (!media_registered) {
-      registerMedia(args as any);
-      media_registered = true;
-   }
-
-   const appConfig = makeAdapterConfig(config, args);
-   const bindings = config.bindings?.(args);
-   if (!appConfig.connection) {
-      let db: D1Database | undefined;
-      if (bindings?.db) {
-         $console.log("Using database from bindings");
-         db = bindings.db;
-      } else if (Object.keys(args).length > 0) {
-         const binding = getBinding(args, "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 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/index.ts

@@ -1,7 +1,7 @@
 import { D1Connection, type D1ConnectionConfig } from "./D1Connection";
 
 export * from "./cloudflare-workers.adapter";
-export { makeApp, getFresh } from "./modes/fresh";
+export { makeApp, getFresh, getWarm } from "./modes/fresh";
 export { getCached } from "./modes/cached";
 export { DurableBkndApp, getDurable } from "./modes/durable";
 export { D1Connection, type D1ConnectionConfig };

app/src/adapter/cloudflare/modes/cached.ts

@@ -1,12 +1,8 @@
 import { App } from "bknd";
 import { createRuntimeApp } from "bknd/adapter";
-import type { CloudflareBkndConfig, Context, CloudflareEnv } from "../index";
-import { makeConfig, registerAsyncsExecutionContext, constants } from "../config";
+import { type CloudflareBkndConfig, type Context, makeCfConfig } from "../index";
 
-export async function getCached<Env extends CloudflareEnv = CloudflareEnv>(
-   config: CloudflareBkndConfig<Env>,
-   { env, ctx, ...args }: Context<Env>,
-) {
+export async function getCached(config: CloudflareBkndConfig, { env, ctx, ...args }: Context) {
    const { kv } = config.bindings?.(env)!;
    if (!kv) throw new Error("kv namespace is not defined in cloudflare.bindings");
    const key = config.key ?? "app";
@@ -20,11 +16,10 @@ export async function getCached<Env extends CloudflareEnv = CloudflareEnv>(
 
    const app = await createRuntimeApp(
       {
-         ...makeConfig(config, env),
+         ...makeCfConfig(config, { env, ctx, ...args }),
          initialConfig,
          onBuilt: async (app) => {
-            registerAsyncsExecutionContext(app, ctx);
-            app.module.server.client.get(constants.cache_endpoint, async (c) => {
+            app.module.server.client.get("/__bknd/cache", async (c) => {
                await kv.delete(key);
                return c.json({ message: "Cache cleared" });
             });
@@ -40,6 +35,7 @@ export async function getCached<Env extends CloudflareEnv = CloudflareEnv>(
             );
             await config.beforeBuild?.(app);
          },
+         adminOptions: { html: config.html },
       },
       { env, ctx, ...args },
    );

app/src/adapter/cloudflare/modes/durable.ts

@@ -1,20 +1,15 @@
 import { DurableObject } from "cloudflare:workers";
 import type { App, CreateAppConfig } from "bknd";
 import { createRuntimeApp, makeConfig } from "bknd/adapter";
-import type { CloudflareBkndConfig, Context, CloudflareEnv } from "../index";
-import { constants, registerAsyncsExecutionContext } from "../config";
-import { $console } from "core";
+import type { CloudflareBkndConfig, Context } from "../index";
 
-export async function getDurable<Env extends CloudflareEnv = CloudflareEnv>(
-   config: CloudflareBkndConfig<Env>,
-   ctx: Context<Env>,
-) {
+export async function getDurable(config: CloudflareBkndConfig, ctx: Context) {
    const { dobj } = config.bindings?.(ctx.env)!;
    if (!dobj) throw new Error("durable object is not defined in cloudflare.bindings");
    const key = config.key ?? "app";
 
    if ([config.onBuilt, config.beforeBuild].some((x) => x)) {
-      $console.warn("onBuilt and beforeBuild are not supported with DurableObject mode");
+      console.log("onBuilt and beforeBuild are not supported with DurableObject mode");
    }
 
    const start = performance.now();
@@ -22,11 +17,13 @@ export async function getDurable<Env extends CloudflareEnv = CloudflareEnv>(
    const id = dobj.idFromName(key);
    const stub = dobj.get(id) as unknown as DurableBkndApp;
 
-   const create_config = makeConfig(config, ctx.env);
+   const create_config = makeConfig(config, ctx);
 
    const res = await stub.fire(ctx.request, {
       config: create_config,
+      html: config.html,
       keepAliveSeconds: config.keepAliveSeconds,
+      setAdminHtml: config.setAdminHtml,
    });
 
    const headers = new Headers(res.headers);
@@ -70,8 +67,7 @@ export class DurableBkndApp extends DurableObject {
          this.app = await createRuntimeApp({
             ...config,
             onBuilt: async (app) => {
-               registerAsyncsExecutionContext(app, this.ctx);
-               app.modules.server.get(constants.do_endpoint, async (c) => {
+               app.modules.server.get("/__do", async (c) => {
                   // @ts-ignore
                   const context: any = c.req.raw.cf ? c.req.raw.cf : c.env.cf;
                   return c.json({
@@ -96,6 +92,7 @@ export class DurableBkndApp extends DurableObject {
          this.keepAlive(options.keepAliveSeconds);
       }
 
+      console.log("id", this.id);
       const res = await this.app!.fetch(request);
       const headers = new Headers(res.headers);
       headers.set("X-BuildTime", buildtime.toString());
@@ -109,17 +106,19 @@ export class DurableBkndApp extends DurableObject {
    }
 
    async onBuilt(app: App) {}
-
    async beforeBuild(app: App) {}
 
    protected keepAlive(seconds: number) {
+      console.log("keep alive for", seconds);
       if (this.interval) {
+         console.log("clearing, there is a new");
          clearInterval(this.interval);
       }
 
       let i = 0;
       this.interval = setInterval(() => {
          i += 1;
+         //console.log("keep-alive", i);
          if (i === seconds) {
             console.log("cleared");
             clearInterval(this.interval);

app/src/adapter/cloudflare/modes/fresh.ts

@@ -1,29 +1,27 @@
-import { createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
-import type { CloudflareBkndConfig, Context, CloudflareEnv } from "../index";
-import { makeConfig, registerAsyncsExecutionContext } from "../config";
+import type { App } from "bknd";
+import { createRuntimeApp } from "bknd/adapter";
+import { type CloudflareBkndConfig, type Context, makeCfConfig } from "../index";
 
-export async function makeApp<Env extends CloudflareEnv = CloudflareEnv>(
-   config: CloudflareBkndConfig<Env>,
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
-   return await createRuntimeApp<Env>(makeConfig(config, args), args, opts);
-}
-
-export async function getFresh<Env extends CloudflareEnv = CloudflareEnv>(
-   config: CloudflareBkndConfig<Env>,
-   ctx: Context<Env>,
-   opts: RuntimeOptions = {},
-) {
-   return await makeApp(
+export async function makeApp(config: CloudflareBkndConfig, ctx: Context) {
+   return await createRuntimeApp(
       {
-         ...config,
-         onBuilt: async (app) => {
-            registerAsyncsExecutionContext(app, ctx.ctx);
-            await config.onBuilt?.(app);
-         },
+         ...makeCfConfig(config, ctx),
+         adminOptions: config.html ? { html: config.html } : undefined,
       },
-      ctx.env,
-      opts,
+      ctx,
    );
 }
+
+export async function getFresh(config: CloudflareBkndConfig, ctx: Context) {
+   const app = await makeApp(config, ctx);
+   return app.fetch(ctx.request);
+}
+
+let warm_app: App;
+export async function getWarm(config: CloudflareBkndConfig, ctx: Context) {
+   if (!warm_app) {
+      warm_app = await makeApp(config, ctx);
+   }
+
+   return warm_app.fetch(ctx.request);
+}

app/src/adapter/cloudflare/storage/StorageR2Adapter.native-spec.ts

@@ -1,32 +0,0 @@
-import { createWriteStream, readFileSync } from "node:fs";
-import { test } from "node:test";
-import { Miniflare } from "miniflare";
-import { StorageR2Adapter } from "./StorageR2Adapter";
-import { adapterTestSuite } from "media";
-import { nodeTestRunner } from "adapter/node/test";
-import path from "node:path";
-
-// 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("StorageR2Adapter", async () => {
-   const mf = new Miniflare({
-      modules: true,
-      script: "export default { async fetch() { return new Response(null); } }",
-      r2Buckets: ["BUCKET"],
-   });
-
-   const bucket = (await mf.getR2Bucket("BUCKET")) as unknown as R2Bucket;
-   const adapter = new StorageR2Adapter(bucket);
-
-   const basePath = path.resolve(import.meta.dirname, "../../../../__test__/_assets");
-   const buffer = readFileSync(path.join(basePath, "image.png"));
-   const file = new File([buffer], "image.png", { type: "image/png" });
-
-   await adapterTestSuite(nodeTestRunner, adapter, file);
-   await mf.dispose();
-});

app/src/adapter/index.ts

@@ -12,113 +12,76 @@ export type BkndConfig<Args = any> = CreateAppConfig & {
 
 export type FrameworkBkndConfig<Args = any> = BkndConfig<Args>;
 
-export type CreateAdapterAppOptions = {
-   force?: boolean;
-   id?: string;
-};
-export type FrameworkOptions = CreateAdapterAppOptions;
-export type RuntimeOptions = CreateAdapterAppOptions;
-
 export type RuntimeBkndConfig<Args = any> = BkndConfig<Args> & {
    distPath?: string;
    serveStatic?: MiddlewareHandler | [string, MiddlewareHandler];
    adminOptions?: AdminControllerOptions | false;
 };
 
-export type DefaultArgs = {
-   [key: string]: any;
-};
-
-export function makeConfig<Args = DefaultArgs>(
-   config: BkndConfig<Args>,
-   args?: Args,
-): CreateAppConfig {
+export function makeConfig<Args = any>(config: BkndConfig<Args>, args?: Args): CreateAppConfig {
    let additionalConfig: CreateAppConfig = {};
-   const { app, ...rest } = config;
-   if (app) {
-      if (typeof app === "function") {
+   if ("app" in config && config.app) {
+      if (typeof config.app === "function") {
          if (!args) {
             throw new Error("args is required when config.app is a function");
          }
-         additionalConfig = app(args);
+         additionalConfig = config.app(args);
       } else {
-         additionalConfig = app;
+         additionalConfig = config.app;
       }
    }
 
-   return { ...rest, ...additionalConfig };
+   return { ...config, ...additionalConfig };
 }
 
-// a map that contains all apps by id
-const apps = new Map<string, App>();
-export async function createAdapterApp<Config extends BkndConfig = BkndConfig, Args = DefaultArgs>(
-   config: Config = {} as Config,
+export async function createFrameworkApp<Args = any>(
+   config: FrameworkBkndConfig,
    args?: Args,
-   opts?: CreateAdapterAppOptions,
 ): Promise<App> {
-   const id = opts?.id ?? "app";
-   let app = apps.get(id);
-   if (!app || opts?.force) {
-      app = App.create(makeConfig(config, args));
-      apps.set(id, app);
-   }
-   return app;
-}
+   const app = App.create(makeConfig(config, args));
 
-export async function createFrameworkApp<Args = DefaultArgs>(
-   config: FrameworkBkndConfig = {},
-   args?: Args,
-   opts?: FrameworkOptions,
-): Promise<App> {
-   const app = await createAdapterApp(config, args, opts);
-
-   if (!app.isBuilt()) {
-      if (config.onBuilt) {
-         app.emgr.onEvent(
-            App.Events.AppBuiltEvent,
-            async () => {
-               await config.onBuilt?.(app);
-            },
-            "sync",
-         );
-      }
-
-      await config.beforeBuild?.(app);
-      await app.build(config.buildConfig);
-   }
-
-   return app;
-}
-
-export async function createRuntimeApp<Args = DefaultArgs>(
-   { serveStatic, adminOptions, ...config }: RuntimeBkndConfig<Args> = {},
-   args?: Args,
-   opts?: RuntimeOptions,
-): Promise<App> {
-   const app = await createAdapterApp(config, args, opts);
-
-   if (!app.isBuilt()) {
+   if (config.onBuilt) {
       app.emgr.onEvent(
          App.Events.AppBuiltEvent,
          async () => {
-            if (serveStatic) {
-               const [path, handler] = Array.isArray(serveStatic)
-                  ? serveStatic
-                  : [$config.server.assets_path + "*", serveStatic];
-               app.modules.server.get(path, handler);
-            }
-
             await config.onBuilt?.(app);
-            if (adminOptions !== false) {
-               app.registerAdminController(adminOptions);
-            }
          },
          "sync",
       );
-
-      await config.beforeBuild?.(app);
-      await app.build(config.buildConfig);
    }
 
+   await config.beforeBuild?.(app);
+   await app.build(config.buildConfig);
+
+   return app;
+}
+
+export async function createRuntimeApp<Env = any>(
+   { serveStatic, adminOptions, ...config }: RuntimeBkndConfig,
+   env?: Env,
+): Promise<App> {
+   const app = App.create(makeConfig(config, env));
+
+   app.emgr.onEvent(
+      App.Events.AppBuiltEvent,
+      async () => {
+         if (serveStatic) {
+            const [path, handler] = Array.isArray(serveStatic)
+               ? serveStatic
+               : [$config.server.assets_path + "*", serveStatic];
+            app.modules.server.get(path, handler);
+         }
+
+         await config.onBuilt?.(app);
+         if (adminOptions !== false) {
+            app.registerAdminController(adminOptions);
+         }
+      },
+      "sync",
+   );
+
+   await config.beforeBuild?.(app);
+   await app.build(config.buildConfig);
+
    return app;
 }

app/src/adapter/nextjs/nextjs.adapter.spec.ts

@@ -1,16 +0,0 @@
-import { afterAll, beforeAll, describe } from "bun:test";
-import * as nextjs from "./nextjs.adapter";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-import { adapterTestSuite } from "adapter/adapter-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-import type { NextjsBkndConfig } from "./nextjs.adapter";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-describe("nextjs adapter", () => {
-   adapterTestSuite<NextjsBkndConfig>(bunTestRunner, {
-      makeApp: nextjs.getApp,
-      makeHandler: nextjs.serve,
-   });
-});

app/src/adapter/nextjs/nextjs.adapter.ts

@@ -1,19 +1,36 @@
-import { createFrameworkApp, type FrameworkBkndConfig, type FrameworkOptions } from "bknd/adapter";
-import { isNode } from "bknd/utils";
-import type { NextApiRequest } from "next";
+import type { App } from "bknd";
+import { type FrameworkBkndConfig, createFrameworkApp } from "bknd/adapter";
+import { isNode } from "core/utils";
 
-type NextjsEnv = NextApiRequest["env"];
-
-export type NextjsBkndConfig<Env = NextjsEnv> = FrameworkBkndConfig<Env> & {
+export type NextjsBkndConfig = FrameworkBkndConfig & {
    cleanRequest?: { searchParams?: string[] };
 };
 
-export async function getApp<Env = NextjsEnv>(
-   config: NextjsBkndConfig<Env>,
-   args: Env = {} as Env,
-   opts?: FrameworkOptions,
+type NextjsContext = {
+   env: Record<string, string | undefined>;
+};
+
+let app: App;
+let building: boolean = false;
+
+export async function getApp<Args extends NextjsContext = NextjsContext>(
+   config: NextjsBkndConfig,
+   args?: Args,
 ) {
-   return await createFrameworkApp(config, args ?? (process.env as Env), opts);
+   if (building) {
+      while (building) {
+         await new Promise((resolve) => setTimeout(resolve, 5));
+      }
+      if (app) return app;
+   }
+
+   building = true;
+   if (!app) {
+      app = await createFrameworkApp(config, args);
+      await app.build();
+   }
+   building = false;
+   return app;
 }
 
 function getCleanRequest(req: Request, cleanRequest: NextjsBkndConfig["cleanRequest"]) {
@@ -39,13 +56,11 @@ function getCleanRequest(req: Request, cleanRequest: NextjsBkndConfig["cleanRequ
    });
 }
 
-export function serve<Env = NextjsEnv>(
-   { cleanRequest, ...config }: NextjsBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: FrameworkOptions,
-) {
+export function serve({ cleanRequest, ...config }: NextjsBkndConfig = {}) {
    return async (req: Request) => {
-      const app = await getApp(config, args, opts);
+      if (!app) {
+         app = await getApp(config, { env: process.env ?? {} });
+      }
       const request = getCleanRequest(req, cleanRequest);
       return app.fetch(request);
    };

app/src/adapter/node/index.ts

@@ -1,18 +1,12 @@
 import { registries } from "bknd";
-import { type LocalAdapterConfig, StorageLocalAdapter } from "./storage/StorageLocalAdapter";
+import {
+   type LocalAdapterConfig,
+   StorageLocalAdapter,
+} from "../../media/storage/adapters/StorageLocalAdapter";
 
 export * from "./node.adapter";
 export { StorageLocalAdapter, type LocalAdapterConfig };
 
-let registered = false;
 export function registerLocalMediaAdapter() {
-   if (!registered) {
-      registries.media.register("local", StorageLocalAdapter);
-      registered = true;
-   }
-
-   return (config: Partial<LocalAdapterConfig> = {}) => {
-      const adapter = new StorageLocalAdapter(config);
-      return adapter.toJSON(true);
-   };
+   registries.media.register("local", StorageLocalAdapter);
 }

app/src/adapter/node/node.adapter.native-spec.ts

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

app/src/adapter/node/node.adapter.spec.ts

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

app/src/adapter/node/node.adapter.ts

@@ -2,12 +2,11 @@ import path from "node:path";
 import { serve as honoServe } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { registerLocalMediaAdapter } from "adapter/node/index";
-import { type RuntimeBkndConfig, createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
+import type { App } from "bknd";
+import { type RuntimeBkndConfig, createRuntimeApp } from "bknd/adapter";
 import { config as $config } from "bknd/core";
-import { $console } from "core";
 
-type NodeEnv = NodeJS.ProcessEnv;
-export type NodeBkndConfig<Env = NodeEnv> = RuntimeBkndConfig<Env> & {
+export type NodeBkndConfig = RuntimeBkndConfig & {
    port?: number;
    hostname?: string;
    listener?: Parameters<typeof honoServe>[1];
@@ -15,11 +14,14 @@ export type NodeBkndConfig<Env = NodeEnv> = RuntimeBkndConfig<Env> & {
    relativeDistPath?: string;
 };
 
-export async function createApp<Env = NodeEnv>(
-   { distPath, relativeDistPath, ...config }: NodeBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
+export function serve({
+   distPath,
+   relativeDistPath,
+   port = $config.server.default_port,
+   hostname,
+   listener,
+   ...config
+}: NodeBkndConfig = {}) {
    const root = path.relative(
       process.cwd(),
       path.resolve(distPath ?? relativeDistPath ?? "./node_modules/bknd/dist", "static"),
@@ -28,42 +30,26 @@ export async function createApp<Env = NodeEnv>(
       console.warn("relativeDistPath is deprecated, please use distPath instead");
    }
 
-   registerLocalMediaAdapter();
-   return await createRuntimeApp(
-      {
-         ...config,
-         serveStatic: serveStatic({ root }),
-      },
-      // @ts-ignore
-      args ?? { env: process.env },
-      opts,
-   );
-}
+   let app: App;
 
-export function createHandler<Env = NodeEnv>(
-   config: NodeBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
-   return async (req: Request) => {
-      const app = await createApp(config, args ?? (process.env as Env), opts);
-      return app.fetch(req);
-   };
-}
-
-export function serve<Env = NodeEnv>(
-   { port = $config.server.default_port, hostname, listener, ...config }: NodeBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: RuntimeOptions,
-) {
    honoServe(
       {
          port,
          hostname,
-         fetch: createHandler(config, args, opts),
+         fetch: async (req: Request) => {
+            if (!app) {
+               registerLocalMediaAdapter();
+               app = await createRuntimeApp({
+                  ...config,
+                  serveStatic: serveStatic({ root }),
+               });
+            }
+
+            return app.fetch(req);
+         },
       },
       (connInfo) => {
-         $console.log(`Server is running on http://localhost:${connInfo.port}`);
+         console.log(`Server is running on http://localhost:${connInfo.port}`);
          listener?.(connInfo);
       },
    );

app/src/adapter/node/storage/StorageLocalAdapter.native-spec.ts

@@ -1,18 +0,0 @@
-import { describe } from "node:test";
-import { nodeTestRunner } from "adapter/node/test";
-import { StorageLocalAdapter } from "adapter/node";
-import { adapterTestSuite } from "media/storage/adapters/adapter-test-suite";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-
-describe("StorageLocalAdapter (node)", async () => {
-   const basePath = path.resolve(import.meta.dirname, "../../../../__test__/_assets");
-   const buffer = readFileSync(path.join(basePath, "image.png"));
-   const file = new File([buffer], "image.png", { type: "image/png" });
-
-   const adapter = new StorageLocalAdapter({
-      path: path.join(basePath, "tmp"),
-   });
-
-   await adapterTestSuite(nodeTestRunner, adapter, file);
-});

app/src/adapter/node/storage/StorageLocalAdapter.spec.ts

@@ -1,15 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { StorageLocalAdapter } from "./StorageLocalAdapter";
-// @ts-ignore
-import { assetsPath, assetsTmpPath } from "../../../../__test__/helper";
-import { adapterTestSuite } from "media/storage/adapters/adapter-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-
-describe("StorageLocalAdapter (bun)", async () => {
-   const adapter = new StorageLocalAdapter({
-      path: assetsTmpPath,
-   });
-
-   const file = Bun.file(`${assetsPath}/image.png`);
-   await adapterTestSuite(bunTestRunner, adapter, file);
-});

app/src/adapter/node/test.ts

@@ -1,99 +0,0 @@
-import nodeAssert from "node:assert/strict";
-import { test } from "node:test";
-import type { Matcher, Test, TestFn, TestRunner } from "core/test";
-
-// Track mock function calls
-const mockCalls = new WeakMap<Function, number>();
-function createMockFunction<T extends (...args: any[]) => any>(fn: T): T {
-   const mockFn = (...args: Parameters<T>) => {
-      const currentCalls = mockCalls.get(mockFn) || 0;
-      mockCalls.set(mockFn, currentCalls + 1);
-      return fn(...args);
-   };
-   return mockFn as T;
-}
-
-const nodeTestMatcher = <T = unknown>(actual: T, parentFailMsg?: string) =>
-   ({
-      toEqual: (expected: T, failMsg = parentFailMsg) => {
-         nodeAssert.deepEqual(actual, expected, failMsg);
-      },
-      toBe: (expected: T, failMsg = parentFailMsg) => {
-         nodeAssert.strictEqual(actual, expected, failMsg);
-      },
-      toBeString: (failMsg = parentFailMsg) => {
-         nodeAssert.strictEqual(typeof actual, "string", failMsg);
-      },
-      toBeUndefined: (failMsg = parentFailMsg) => {
-         nodeAssert.strictEqual(actual, undefined, failMsg);
-      },
-      toBeDefined: (failMsg = parentFailMsg) => {
-         nodeAssert.notStrictEqual(actual, undefined, failMsg);
-      },
-      toBeOneOf: (expected: T | Array<T> | Iterable<T>, failMsg = parentFailMsg) => {
-         const e = Array.isArray(expected) ? expected : [expected];
-         nodeAssert.ok(e.includes(actual), failMsg);
-      },
-      toHaveBeenCalled: (failMsg = parentFailMsg) => {
-         const calls = mockCalls.get(actual as Function) || 0;
-         nodeAssert.ok(calls > 0, failMsg || "Expected function to have been called at least once");
-      },
-      toHaveBeenCalledTimes: (expected: number, failMsg = parentFailMsg) => {
-         const calls = mockCalls.get(actual as Function) || 0;
-         nodeAssert.strictEqual(
-            calls,
-            expected,
-            failMsg || `Expected function to have been called ${expected} times`,
-         );
-      },
-   }) satisfies Matcher<T>;
-
-const nodeTestResolverProxy = <T = unknown>(
-   actual: Promise<T>,
-   handler: { resolve?: any; reject?: any },
-) => {
-   return new Proxy(
-      {},
-      {
-         get: (_, prop) => {
-            if (prop === "then") {
-               return actual.then(handler.resolve, handler.reject);
-            }
-            return actual;
-         },
-      },
-   ) as Matcher<Awaited<T>>;
-};
-
-function nodeTest(label: string, fn: TestFn, options?: any) {
-   return test(label, fn as any);
-}
-nodeTest.if = (condition: boolean): Test => {
-   if (condition) {
-      return nodeTest;
-   }
-   return (() => {}) as any;
-};
-nodeTest.skip = (label: string, fn: TestFn) => {
-   return test.skip(label, fn as any);
-};
-nodeTest.skipIf = (condition: boolean): Test => {
-   if (condition) {
-      return (() => {}) as any;
-   }
-   return nodeTest;
-};
-
-export const nodeTestRunner: TestRunner = {
-   test: nodeTest,
-   mock: createMockFunction,
-   expect: <T = unknown>(actual?: T, failMsg?: string) => ({
-      ...nodeTestMatcher(actual, failMsg),
-      resolves: nodeTestResolverProxy(actual as Promise<T>, {
-         resolve: (r) => nodeTestMatcher(r, failMsg),
-      }),
-      rejects: nodeTestResolverProxy(actual as Promise<T>, {
-         reject: (r) => nodeTestMatcher(r, failMsg),
-      }),
-   }),
-};

app/src/adapter/react-router/react-router.adapter.spec.ts

@@ -1,15 +0,0 @@
-import { afterAll, beforeAll, describe } from "bun:test";
-import * as rr from "./react-router.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("react-router adapter", () => {
-   adapterTestSuite(bunTestRunner, {
-      makeApp: rr.getApp,
-      makeHandler: (c, a, o) => (request: Request) => rr.serve(c, a?.env, o)({ request }),
-   });
-});

app/src/adapter/react-router/react-router.adapter.ts

@@ -1,26 +1,39 @@
+import type { App } from "bknd";
 import { type FrameworkBkndConfig, createFrameworkApp } from "bknd/adapter";
-import type { FrameworkOptions } from "adapter";
 
-type ReactRouterEnv = NodeJS.ProcessEnv;
-type ReactRouterFunctionArgs = {
+type ReactRouterContext = {
    request: Request;
 };
-export type ReactRouterBkndConfig<Env = ReactRouterEnv> = FrameworkBkndConfig<Env>;
+export type ReactRouterBkndConfig<Args = ReactRouterContext> = FrameworkBkndConfig<Args>;
 
-export async function getApp<Env = ReactRouterEnv>(
-   config: ReactRouterBkndConfig<Env>,
-   args: Env = {} as Env,
-   opts?: FrameworkOptions,
+let app: App;
+let building: boolean = false;
+
+export async function getApp<Args extends ReactRouterContext = ReactRouterContext>(
+   config: ReactRouterBkndConfig<Args>,
+   args?: Args,
 ) {
-   return await createFrameworkApp(config, args ?? process.env, opts);
+   if (building) {
+      while (building) {
+         await new Promise((resolve) => setTimeout(resolve, 5));
+      }
+      if (app) return app;
+   }
+
+   building = true;
+   if (!app) {
+      app = await createFrameworkApp(config, args);
+      await app.build();
+   }
+   building = false;
+   return app;
 }
 
-export function serve<Env = ReactRouterEnv>(
-   config: ReactRouterBkndConfig<Env> = {},
-   args: Env = {} as Env,
-   opts?: FrameworkOptions,
+export function serve<Args extends ReactRouterContext = ReactRouterContext>(
+   config: ReactRouterBkndConfig<Args> = {},
 ) {
-   return async (fnArgs: ReactRouterFunctionArgs) => {
-      return (await getApp(config, args, opts)).fetch(fnArgs.request);
+   return async (args: Args) => {
+      app = await getApp(config, args);
+      return app.fetch(args.request);
    };
 }

app/src/adapter/vite/vite.adapter.ts

@@ -1,24 +1,18 @@
 import { serveStatic } from "@hono/node-server/serve-static";
-import {
-   type DevServerOptions,
-   default as honoViteDevServer,
-} from "@hono/vite-dev-server";
+import { type DevServerOptions, default as honoViteDevServer } from "@hono/vite-dev-server";
 import type { App } from "bknd";
-import {
-   type RuntimeBkndConfig,
-   createRuntimeApp,
-   type FrameworkOptions,
-} from "bknd/adapter";
+import { type RuntimeBkndConfig, createRuntimeApp } from "bknd/adapter";
 import { registerLocalMediaAdapter } from "bknd/adapter/node";
 import { devServerConfig } from "./dev-server-config";
 
-export type ViteEnv = NodeJS.ProcessEnv;
-export type ViteBkndConfig<Env = ViteEnv> = RuntimeBkndConfig<Env> & {};
+export type ViteBkndConfig<Env = any> = RuntimeBkndConfig<Env> & {
+   mode?: "cached" | "fresh";
+   setAdminHtml?: boolean;
+   forceDev?: boolean | { mainPath: string };
+   html?: string;
+};
 
-export function addViteScript(
-   html: string,
-   addBkndContext: boolean = true,
-) {
+export function addViteScript(html: string, addBkndContext: boolean = true) {
    return html.replace(
       "</head>",
       `<script type="module">
@@ -34,40 +28,52 @@ ${addBkndContext ? "<!-- BKND_CONTEXT -->" : ""}
    );
 }
 
-async function createApp<ViteEnv>(
-   config: ViteBkndConfig<ViteEnv> = {},
-   env: ViteEnv = {} as ViteEnv,
-   opts: FrameworkOptions = {},
-): Promise<App> {
+async function createApp(config: ViteBkndConfig = {}, env?: any) {
    registerLocalMediaAdapter();
    return await createRuntimeApp(
       {
          ...config,
-         adminOptions: config.adminOptions ?? {
-            forceDev: {
-               mainPath: "/src/main.tsx",
-            },
-         },
+         adminOptions:
+            config.setAdminHtml === false
+               ? undefined
+               : {
+                    html: config.html,
+                    forceDev: config.forceDev ?? {
+                       mainPath: "/src/main.tsx",
+                    },
+                 },
          serveStatic: ["/assets/*", serveStatic({ root: config.distPath ?? "./" })],
       },
       env,
-      opts,
    );
 }
 
-export function serve<ViteEnv>(
-   config: ViteBkndConfig<ViteEnv> = {},
-   args?: ViteEnv,
-   opts?: FrameworkOptions,
-) {
+export function serveFresh(config: Omit<ViteBkndConfig, "mode"> = {}) {
    return {
       async fetch(request: Request, env: any, ctx: ExecutionContext) {
-         const app = await createApp(config, env, opts);
+         const app = await createApp(config, env);
          return app.fetch(request, env, ctx);
       },
    };
 }
 
+let app: App;
+export function serveCached(config: Omit<ViteBkndConfig, "mode"> = {}) {
+   return {
+      async fetch(request: Request, env: any, ctx: ExecutionContext) {
+         if (!app) {
+            app = await createApp(config, env);
+         }
+
+         return app.fetch(request, env, ctx);
+      },
+   };
+}
+
+export function serve({ mode, ...config }: ViteBkndConfig = {}) {
+   return mode === "fresh" ? serveFresh(config) : serveCached(config);
+}
+
 export function devServer(options: DevServerOptions) {
    return honoViteDevServer({
       ...devServerConfig,

app/src/auth/AppAuth.ts

@@ -1,23 +1,29 @@
-import { Authenticator, AuthPermissions, Role, type Strategy } from "auth";
+import {
+   type AuthAction,
+   AuthPermissions,
+   Authenticator,
+   type ProfileExchange,
+   Role,
+   type Strategy,
+} from "auth";
 import type { PasswordStrategy } from "auth/authenticate/strategies";
-import { $console, type DB } from "core";
-import { secureRandomString, transformObject } from "core/utils";
+import { $console, type DB, Exception, type PrimaryFieldType } from "core";
+import { type Static, secureRandomString, transformObject } from "core/utils";
 import type { Entity, EntityManager } from "data";
-import { em, entity, enumm, type FieldSchema, text } from "data/prototype";
+import { type FieldSchema, em, entity, enumm, text } from "data/prototype";
+import { pick } from "lodash-es";
 import { Module } from "modules/Module";
 import { AuthController } from "./api/AuthController";
-import { type AppAuthSchema, authConfigSchema, STRATEGIES } from "./auth-schema";
-import { AppUserPool } from "auth/AppUserPool";
-import type { AppEntity } from "core/config";
+import { type AppAuthSchema, STRATEGIES, authConfigSchema } from "./auth-schema";
 
 export type UserFieldSchema = FieldSchema<typeof AppAuth.usersFields>;
 declare module "core" {
-   interface Users extends AppEntity, UserFieldSchema {}
    interface DB {
-      users: Users;
+      users: { id: PrimaryFieldType } & UserFieldSchema;
    }
 }
 
+type AuthSchema = Static<typeof authConfigSchema>;
 export type CreateUserPayload = { email: string; password: string; [key: string]: any };
 
 export class AppAuth extends Module<typeof authConfigSchema> {
@@ -25,12 +31,12 @@ export class AppAuth extends Module<typeof authConfigSchema> {
    cache: Record<string, any> = {};
    _controller!: AuthController;
 
-   override async onBeforeUpdate(from: AppAuthSchema, to: AppAuthSchema) {
+   override async onBeforeUpdate(from: AuthSchema, to: AuthSchema) {
       const defaultSecret = authConfigSchema.properties.jwt.properties.secret.default;
 
       if (!from.enabled && to.enabled) {
          if (to.jwt.secret === defaultSecret) {
-            $console.warn("No JWT secret provided, generating a random one");
+            console.warn("No JWT secret provided, generating a random one");
             to.jwt.secret = secureRandomString(64);
          }
       }
@@ -74,7 +80,7 @@ export class AppAuth extends Module<typeof authConfigSchema> {
          }
       });
 
-      this._authenticator = new Authenticator(strategies, new AppUserPool(this), {
+      this._authenticator = new Authenticator(strategies, this.resolveUser.bind(this), {
          jwt: this.config.jwt,
          cookie: this.config.cookie,
       });
@@ -84,7 +90,7 @@ export class AppAuth extends Module<typeof authConfigSchema> {
 
       this._controller = new AuthController(this);
       this.ctx.server.route(this.config.basepath, this._controller.getController());
-      this.ctx.guard.registerPermissions(AuthPermissions);
+      this.ctx.guard.registerPermissions(Object.values(AuthPermissions));
    }
 
    isStrategyEnabled(strategy: Strategy | string) {
@@ -116,6 +122,120 @@ export class AppAuth extends Module<typeof authConfigSchema> {
       return this.ctx.em as any;
    }
 
+   private async resolveUser(
+      action: AuthAction,
+      strategy: Strategy,
+      identifier: string,
+      profile: ProfileExchange,
+   ): Promise<any> {
+      if (!this.config.allow_register && action === "register") {
+         throw new Exception("Registration is not allowed", 403);
+      }
+
+      const fields = this.getUsersEntity()
+         .getFillableFields("create")
+         .map((f) => f.name);
+      const filteredProfile = Object.fromEntries(
+         Object.entries(profile).filter(([key]) => fields.includes(key)),
+      );
+
+      switch (action) {
+         case "login":
+            return this.login(strategy, identifier, filteredProfile);
+         case "register":
+            return this.register(strategy, identifier, filteredProfile);
+      }
+   }
+
+   private filterUserData(user: any) {
+      return pick(user, this.config.jwt.fields);
+   }
+
+   private async login(strategy: Strategy, identifier: string, profile: ProfileExchange) {
+      if (!("email" in profile)) {
+         throw new Exception("Profile must have email");
+      }
+      if (typeof identifier !== "string" || identifier.length === 0) {
+         throw new Exception("Identifier must be a string");
+      }
+
+      const users = this.getUsersEntity();
+      this.toggleStrategyValueVisibility(true);
+      const result = await this.em
+         .repo(users as unknown as "users")
+         .findOne({ email: profile.email! });
+      this.toggleStrategyValueVisibility(false);
+      if (!result.data) {
+         throw new Exception("User not found", 404);
+      }
+
+      // compare strategy and identifier
+      if (result.data.strategy !== strategy.getName()) {
+         //console.log("!!! User registered with different strategy");
+         throw new Exception("User registered with different strategy");
+      }
+
+      if (result.data.strategy_value !== identifier) {
+         throw new Exception("Invalid credentials");
+      }
+
+      return this.filterUserData(result.data);
+   }
+
+   private async register(strategy: Strategy, identifier: string, profile: ProfileExchange) {
+      if (!("email" in profile)) {
+         throw new Exception("Profile must have an email");
+      }
+      if (typeof identifier !== "string" || identifier.length === 0) {
+         throw new Exception("Identifier must be a string");
+      }
+
+      const users = this.getUsersEntity();
+      const { data } = await this.em.repo(users).findOne({ email: profile.email! });
+      if (data) {
+         throw new Exception("User already exists");
+      }
+
+      const payload: any = {
+         ...profile,
+         strategy: strategy.getName(),
+         strategy_value: identifier,
+      };
+
+      const mutator = this.em.mutator(users);
+      mutator.__unstable_toggleSystemEntityCreation(false);
+      this.toggleStrategyValueVisibility(true);
+      const createResult = await mutator.insertOne(payload);
+      mutator.__unstable_toggleSystemEntityCreation(true);
+      this.toggleStrategyValueVisibility(false);
+      if (!createResult.data) {
+         throw new Error("Could not create user");
+      }
+
+      return this.filterUserData(createResult.data);
+   }
+
+   private toggleStrategyValueVisibility(visible: boolean) {
+      const toggle = (name: string, visible: boolean) => {
+         const field = this.getUsersEntity().field(name)!;
+
+         if (visible) {
+            field.config.hidden = false;
+            field.config.fillable = true;
+         } else {
+            // reset to normal
+            const template = AppAuth.usersFields.strategy_value.config;
+            field.config.hidden = template.hidden;
+            field.config.fillable = template.fillable;
+         }
+      };
+
+      toggle("strategy_value", visible);
+      toggle("strategy", visible);
+
+      // @todo: think about a PasswordField that automatically hashes on save?
+   }
+
    getUsersEntity(forceCreate?: boolean): Entity<"users", typeof AppAuth.usersFields> {
       const entity_name = this.config.entity_name;
       if (forceCreate || !this.em.hasEntity(entity_name)) {
@@ -168,7 +288,7 @@ export class AppAuth extends Module<typeof authConfigSchema> {
          throw new Error("Cannot create user, auth not enabled");
       }
 
-      const strategy = "password" as const;
+      const strategy = "password";
       const pw = this.authenticator.strategy(strategy) as PasswordStrategy;
       const strategy_value = await pw.hash(password);
       const mutator = this.em.mutator(this.config.entity_name as "users");
@@ -195,7 +315,8 @@ export class AppAuth extends Module<typeof authConfigSchema> {
          ...this.authenticator.toJSON(secrets),
          strategies: transformObject(strategies, (strategy) => ({
             enabled: this.isStrategyEnabled(strategy),
-            ...strategy.toJSON(secrets),
+            type: strategy.getType(),
+            config: strategy.toJSON(secrets),
          })),
       };
    }

app/src/auth/AppUserPool.ts

@@ -1,83 +0,0 @@
-import { AppAuth } from "auth/AppAuth";
-import type { CreateUser, SafeUser, User, UserPool } from "auth/authenticate/Authenticator";
-import { $console } from "core";
-import { pick } from "lodash-es";
-import {
-   InvalidConditionsException,
-   UnableToCreateUserException,
-   UserNotFoundException,
-} from "auth/errors";
-
-export class AppUserPool implements UserPool {
-   constructor(private appAuth: AppAuth) {}
-
-   get em() {
-      return this.appAuth.em;
-   }
-
-   get users() {
-      return this.appAuth.getUsersEntity();
-   }
-
-   async findBy(strategy: string, prop: keyof SafeUser, value: any) {
-      $console.debug("[AppUserPool:findBy]", { strategy, prop, value });
-      this.toggleStrategyValueVisibility(true);
-      const result = await this.em.repo(this.users).findOne({ [prop]: value, strategy });
-      this.toggleStrategyValueVisibility(false);
-
-      if (!result.data) {
-         $console.debug("[AppUserPool]: User not found");
-         throw new UserNotFoundException();
-      }
-
-      return result.data;
-   }
-
-   async create(strategy: string, payload: CreateUser & Partial<Omit<User, "id">>) {
-      $console.debug("[AppUserPool:create]", { strategy, payload });
-      if (!("strategy_value" in payload)) {
-         throw new InvalidConditionsException("Profile must have a strategy_value value");
-      }
-
-      const fields = this.users.getSelect(undefined, "create");
-      const safeProfile = pick(payload, fields) as any;
-      const createPayload: Omit<User, "id"> = {
-         ...safeProfile,
-         strategy,
-      };
-
-      const mutator = this.em.mutator(this.users);
-      mutator.__unstable_toggleSystemEntityCreation(false);
-      this.toggleStrategyValueVisibility(true);
-      const createResult = await mutator.insertOne(createPayload);
-      mutator.__unstable_toggleSystemEntityCreation(true);
-      this.toggleStrategyValueVisibility(false);
-      if (!createResult.data) {
-         throw new UnableToCreateUserException();
-      }
-
-      $console.debug("[AppUserPool]: User created", createResult.data);
-      return createResult.data;
-   }
-
-   private toggleStrategyValueVisibility(visible: boolean) {
-      const toggle = (name: string, visible: boolean) => {
-         const field = this.users.field(name)!;
-
-         if (visible) {
-            field.config.hidden = false;
-            field.config.fillable = true;
-         } else {
-            // reset to normal
-            const template = AppAuth.usersFields.strategy_value.config;
-            field.config.hidden = template.hidden;
-            field.config.fillable = template.fillable;
-         }
-      };
-
-      toggle("strategy_value", visible);
-      toggle("strategy", visible);
-
-      // @todo: think about a PasswordField that automatically hashes on save?
-   }
-}

app/src/auth/api/AuthController.ts

@@ -1,11 +1,9 @@
 import { type AppAuth, AuthPermissions, type SafeUser, type Strategy } from "auth";
 import { tbValidator as tb } from "core";
-import { TypeInvalidError, parse, transformObject } from "core/utils";
+import { Type, TypeInvalidError, parse, transformObject } from "core/utils";
 import { DataPermissions } from "data";
 import type { Hono } from "hono";
 import { Controller, type ServerEnv } from "modules/Controller";
-import * as tbbox from "@sinclair/typebox";
-const { Type } = tbbox;
 
 export type AuthActionResponse = {
    success: boolean;

app/src/auth/auth-schema.ts

@@ -1,8 +1,6 @@
 import { cookieConfig, jwtConfig } from "auth/authenticate/Authenticator";
 import { CustomOAuthStrategy, OAuthStrategy, PasswordStrategy } from "auth/authenticate/strategies";
-import { type Static, StringRecord, objectTransform } from "core/utils";
-import * as tbbox from "@sinclair/typebox";
-const { Type } = tbbox;
+import { type Static, StringRecord, Type, objectTransform } from "core/utils";
 
 export const Strategies = {
    password: {

app/src/auth/authenticate/Authenticator.ts

@@ -1,22 +1,19 @@
-import { $console, type DB, Exception } from "core";
+import { type DB, Exception } from "core";
 import { addFlashMessage } from "core/server/flash";
 import {
    type Static,
    StringEnum,
    type TObject,
+   Type,
    parse,
    runtimeSupports,
-   truncate,
+   transformObject,
 } from "core/utils";
 import type { Context, Hono } from "hono";
 import { deleteCookie, getSignedCookie, setSignedCookie } from "hono/cookie";
 import { sign, verify } from "hono/jwt";
 import type { CookieOptions } from "hono/utils/cookie";
 import type { ServerEnv } from "modules/Controller";
-import { pick } from "lodash-es";
-import * as tbbox from "@sinclair/typebox";
-import { InvalidConditionsException } from "auth/errors";
-const { Type } = tbbox;
 
 type Input = any; // workaround
 export type JWTPayload = Parameters<typeof sign>[0];
@@ -25,12 +22,11 @@ export const strategyActions = ["create", "change"] as const;
 export type StrategyActionName = (typeof strategyActions)[number];
 export type StrategyAction<S extends TObject = TObject> = {
    schema: S;
-   preprocess: (input: Static<S>) => Promise<Omit<DB["users"], "id" | "strategy">>;
+   preprocess: (input: unknown) => Promise<Omit<DB["users"], "id" | "strategy">>;
 };
 export type StrategyActions = Partial<Record<StrategyActionName, StrategyAction>>;
 
 // @todo: add schema to interface to ensure proper inference
-// @todo: add tests (e.g. invalid strategy_value)
 export interface Strategy {
    getController: (auth: Authenticator) => Hono<any>;
    getType: () => string;
@@ -40,22 +36,29 @@ export interface Strategy {
    getActions?: () => StrategyActions;
 }
 
-export type User = DB["users"];
+export type User = {
+   id: number;
+   email: string;
+   username: string;
+   password: string;
+   role: string;
+};
 
 export type ProfileExchange = {
    email?: string;
-   strategy?: string;
-   strategy_value?: string;
+   username?: string;
+   sub?: string;
+   password?: string;
    [key: string]: any;
 };
 
-export type SafeUser = Omit<User, "strategy_value">;
+export type SafeUser = Omit<User, "password">;
 export type CreateUser = Pick<User, "email"> & { [key: string]: any };
 export type AuthResponse = { user: SafeUser; token: string };
 
-export interface UserPool {
-   findBy: (strategy: string, prop: keyof SafeUser, value: string | number) => Promise<User>;
-   create: (strategy: string, user: CreateUser) => Promise<User>;
+export interface UserPool<Fields = "id" | "email" | "username"> {
+   findBy: (prop: Fields, value: string | number) => Promise<User | undefined>;
+   create: (user: CreateUser) => Promise<User | undefined>;
 }
 
 const defaultCookieExpires = 60 * 60 * 24 * 7; // 1 week in seconds
@@ -97,17 +100,12 @@ export const authenticatorConfig = Type.Object({
 
 type AuthConfig = Static<typeof authenticatorConfig>;
 export type AuthAction = "login" | "register";
-export type AuthResolveOptions = {
-   identifier?: "email" | string;
-   redirect?: string;
-   forceJsonResponse?: boolean;
-};
 export type AuthUserResolver = (
    action: AuthAction,
    strategy: Strategy,
+   identifier: string,
    profile: ProfileExchange,
-   opts?: AuthResolveOptions,
-) => Promise<ProfileExchange | undefined>;
+) => Promise<SafeUser | undefined>;
 type AuthClaims = SafeUser & {
    iat: number;
    iss?: string;
@@ -115,117 +113,33 @@ type AuthClaims = SafeUser & {
 };
 
 export class Authenticator<Strategies extends Record<string, Strategy> = Record<string, Strategy>> {
+   private readonly strategies: Strategies;
    private readonly config: AuthConfig;
+   private readonly userResolver: AuthUserResolver;
 
-   constructor(
-      private readonly strategies: Strategies,
-      private readonly userPool: UserPool,
-      config?: AuthConfig,
-   ) {
+   constructor(strategies: Strategies, userResolver?: AuthUserResolver, config?: AuthConfig) {
+      this.userResolver = userResolver ?? (async (a, s, i, p) => p as any);
+      this.strategies = strategies as Strategies;
       this.config = parse(authenticatorConfig, config ?? {});
    }
 
-   async resolveLogin(
-      c: Context,
+   async resolve(
+      action: AuthAction,
       strategy: Strategy,
-      profile: Partial<SafeUser>,
-      verify: (user: User) => Promise<void>,
-      opts?: AuthResolveOptions,
-   ) {
-      try {
-         // @todo: centralize identifier and checks
-         // @todo: check identifier value (if allowed)
-         const identifier = opts?.identifier || "email";
-         if (typeof identifier !== "string" || identifier.length === 0) {
-            throw new InvalidConditionsException("Identifier must be a string");
-         }
-         if (!(identifier in profile)) {
-            throw new InvalidConditionsException(`Profile must have identifier "${identifier}"`);
-         }
+      identifier: string,
+      profile: ProfileExchange,
+   ): Promise<AuthResponse> {
+      //console.log("resolve", { action, strategy: strategy.getName(), profile });
+      const user = await this.userResolver(action, strategy, identifier, profile);
 
-         const user = await this.userPool.findBy(
-            strategy.getName(),
-            identifier as any,
-            profile[identifier],
-         );
-
-         if (!user.strategy_value) {
-            throw new InvalidConditionsException("User must have a strategy value");
-         } else if (user.strategy !== strategy.getName()) {
-            throw new InvalidConditionsException("User signed up with a different strategy");
-         }
-
-         await verify(user);
-         const data = await this.safeAuthResponse(user);
-         return this.respondWithUser(c, data, opts);
-      } catch (e) {
-         return this.respondWithError(c, e as Error, opts);
-      }
-   }
-
-   async resolveRegister(
-      c: Context,
-      strategy: Strategy,
-      profile: CreateUser,
-      verify: (user: User) => Promise<void>,
-      opts?: AuthResolveOptions,
-   ) {
-      try {
-         const identifier = opts?.identifier || "email";
-         if (typeof identifier !== "string" || identifier.length === 0) {
-            throw new InvalidConditionsException("Identifier must be a string");
-         }
-         if (!(identifier in profile)) {
-            throw new InvalidConditionsException(`Profile must have identifier "${identifier}"`);
-         }
-         if (!("strategy_value" in profile)) {
-            throw new InvalidConditionsException("Profile must have a strategy value");
-         }
-
-         const user = await this.userPool.create(strategy.getName(), {
-            ...profile,
-            strategy_value: profile.strategy_value,
-         });
-
-         await verify(user);
-         const data = await this.safeAuthResponse(user);
-         return this.respondWithUser(c, data, opts);
-      } catch (e) {
-         return this.respondWithError(c, e as Error, opts);
-      }
-   }
-
-   private async respondWithUser(c: Context, data: AuthResponse, opts?: AuthResolveOptions) {
-      const successUrl = this.getSafeUrl(
-         c,
-         opts?.redirect ?? this.config.cookie.pathSuccess ?? "/",
-      );
-
-      if ("token" in data) {
-         await this.setAuthCookie(c, data.token);
-
-         if (this.isJsonRequest(c) || opts?.forceJsonResponse) {
-            return c.json(data);
-         }
-
-         // can't navigate to "/" – doesn't work on nextjs
-         return c.redirect(successUrl);
+      if (user) {
+         return {
+            user,
+            token: await this.jwt(user),
+         };
       }
 
-      throw new Exception("Invalid response");
-   }
-
-   async respondWithError(c: Context, error: Error, opts?: AuthResolveOptions) {
-      $console.error("respondWithError", error);
-      if (this.isJsonRequest(c) || opts?.forceJsonResponse) {
-         // let the server handle it
-         throw error;
-      }
-
-      await addFlashMessage(c, String(error), "error");
-
-      const referer = this.getSafeUrl(c, opts?.redirect ?? c.req.header("Referer") ?? "/");
-      return c.redirect(referer);
+      throw new Error("User could not be resolved");
    }
 
    getStrategies(): Strategies {
@@ -244,8 +158,13 @@ export class Authenticator<Strategies extends Record<string, Strategy> = Record<
    }
 
    // @todo: add jwt tests
-   async jwt(_user: SafeUser | ProfileExchange): Promise<string> {
-      const user = pick(_user, this.config.jwt.fields);
+   async jwt(user: Omit<User, "password">): Promise<string> {
+      const prohibited = ["password"];
+      for (const prop of prohibited) {
+         if (prop in user) {
+            throw new Error(`Property "${prop}" is prohibited`);
+         }
+      }
 
       const payload: JWTPayload = {
          ...user,
@@ -270,14 +189,6 @@ export class Authenticator<Strategies extends Record<string, Strategy> = Record<
       return sign(payload, secret, this.config.jwt?.alg ?? "HS256");
    }
 
-   async safeAuthResponse(_user: User): Promise<AuthResponse> {
-      const user = pick(_user, this.config.jwt.fields) as SafeUser;
-      return {
-         user,
-         token: await this.jwt(user),
-      };
-   }
-
    async verify(jwt: string): Promise<AuthClaims | undefined> {
       try {
          const payload = await verify(
@@ -319,7 +230,7 @@ export class Authenticator<Strategies extends Record<string, Strategy> = Record<
          return token;
       } catch (e: any) {
          if (e instanceof Error) {
-            $console.error("[getAuthCookie]", e.message);
+            console.error("[Error:getAuthCookie]", e.message);
          }
 
          return undefined;
@@ -336,13 +247,11 @@ export class Authenticator<Strategies extends Record<string, Strategy> = Record<
    }
 
    private async setAuthCookie(c: Context<ServerEnv>, token: string) {
-      $console.debug("setting auth cookie", truncate(token));
       const secret = this.config.jwt.secret;
       await setSignedCookie(c, "auth", token, secret, this.cookieOptions);
    }
 
    private async deleteAuthCookie(c: Context) {
-      $console.debug("deleting auth cookie");
       await deleteCookie(c, "auth", this.cookieOptions);
    }
 
@@ -358,6 +267,7 @@ export class Authenticator<Strategies extends Record<string, Strategy> = Record<
 
    // @todo: move this to a server helper
    isJsonRequest(c: Context): boolean {
+      //return c.req.header("Content-Type") === "application/x-www-form-urlencoded";
       return c.req.header("Content-Type") === "application/json";
    }
 
@@ -381,6 +291,37 @@ export class Authenticator<Strategies extends Record<string, Strategy> = Record<
       return p;
    }
 
+   async respond(c: Context, data: AuthResponse | Error | any, redirect?: string) {
+      const successUrl = this.getSafeUrl(c, redirect ?? this.config.cookie.pathSuccess ?? "/");
+      const referer = redirect ?? c.req.header("Referer") ?? successUrl;
+      //console.log("auth respond", { redirect, successUrl, successPath });
+
+      if ("token" in data) {
+         await this.setAuthCookie(c, data.token);
+
+         if (this.isJsonRequest(c)) {
+            return c.json(data);
+         }
+
+         // can't navigate to "/" – doesn't work on nextjs
+         //console.log("auth success, redirecting to", successUrl);
+         return c.redirect(successUrl);
+      }
+
+      if (this.isJsonRequest(c)) {
+         return c.json(data, 400);
+      }
+
+      let message = "An error occured";
+      if (data instanceof Exception) {
+         message = data.message;
+      }
+
+      await addFlashMessage(c, message, "error");
+      //console.log("auth failed, redirecting to", referer);
+      return c.redirect(referer);
+   }
+
    // @todo: don't extract user from token, but from the database or cache
    async resolveAuthFromRequest(c: Context): Promise<SafeUser | undefined> {
       let token: string | undefined;
@@ -405,3 +346,13 @@ export class Authenticator<Strategies extends Record<string, Strategy> = Record<
       };
    }
 }
+
+export function createStrategyAction<S extends TObject>(
+   schema: S,
+   preprocess: (input: Static<S>) => Promise<Partial<DB["users"]>>,
+) {
+   return {
+      schema,
+      preprocess,
+   } as StrategyAction<S>;
+}

app/src/auth/authenticate/strategies/PasswordStrategy.ts

@@ -1,135 +1,152 @@
-import { type Authenticator, InvalidCredentialsException, type User } from "auth";
-import { $console, tbValidator as tb } from "core";
-import { hash, parse, type Static, StrictObject, StringEnum } from "core/utils";
-import { Hono } from "hono";
-import { compare as bcryptCompare, genSalt as bcryptGenSalt, hash as bcryptHash } from "bcryptjs";
-import * as tbbox from "@sinclair/typebox";
-import { Strategy } from "./Strategy";
+import type { Authenticator, Strategy } from "auth";
+import { isDebug, tbValidator as tb } from "core";
+import { type Static, StringEnum, Type, parse } from "core/utils";
+import { hash } from "core/utils";
+import { type Context, Hono } from "hono";
+import { type StrategyAction, type StrategyActions, createStrategyAction } from "../Authenticator";
 
-const { Type } = tbbox;
+type LoginSchema = { username: string; password: string } | { email: string; password: string };
+type RegisterSchema = { email: string; password: string; [key: string]: any };
 
-const schema = StrictObject({
-   hashing: StringEnum(["plain", "sha256", "bcrypt"], { default: "sha256" }),
-   rounds: Type.Optional(Type.Number({ minimum: 1, maximum: 10 })),
+const schema = Type.Object({
+   hashing: StringEnum(["plain", "sha256" /*, "bcrypt"*/] as const, { default: "sha256" }),
 });
 
 export type PasswordStrategyOptions = Static<typeof schema>;
+/*export type PasswordStrategyOptions2 = {
+   hashing?: "plain" | "bcrypt" | "sha256";
+};*/
 
-export class PasswordStrategy extends Strategy<typeof schema> {
-   constructor(config: Partial<PasswordStrategyOptions> = {}) {
-      super(config as any, "password", "password", "form");
+export class PasswordStrategy implements Strategy {
+   private options: PasswordStrategyOptions;
 
-      this.registerAction("create", this.getPayloadSchema(), async ({ password, ...input }) => {
-         return {
-            ...input,
-            strategy_value: await this.hash(password),
-         };
-      });
+   constructor(options: Partial<PasswordStrategyOptions> = {}) {
+      this.options = parse(schema, options);
+   }
+
+   async hash(password: string) {
+      switch (this.options.hashing) {
+         case "sha256":
+            return hash.sha256(password);
+         default:
+            return password;
+      }
+   }
+
+   async login(input: LoginSchema) {
+      if (!("email" in input) || !("password" in input)) {
+         throw new Error("Invalid input: Email and password must be provided");
+      }
+
+      const hashedPassword = await this.hash(input.password);
+      return { ...input, password: hashedPassword };
+   }
+
+   async register(input: RegisterSchema) {
+      if (!input.email || !input.password) {
+         throw new Error("Invalid input: Email and password must be provided");
+      }
+
+      return {
+         ...input,
+         password: await this.hash(input.password),
+      };
+   }
+
+   getController(authenticator: Authenticator): Hono<any> {
+      const hono = new Hono();
+
+      return hono
+         .post(
+            "/login",
+            tb(
+               "query",
+               Type.Object({
+                  redirect: Type.Optional(Type.String()),
+               }),
+            ),
+            async (c) => {
+               const body = await authenticator.getBody(c);
+               const { redirect } = c.req.valid("query");
+
+               try {
+                  const payload = await this.login(body);
+                  const data = await authenticator.resolve(
+                     "login",
+                     this,
+                     payload.password,
+                     payload,
+                  );
+
+                  return await authenticator.respond(c, data, redirect);
+               } catch (e) {
+                  return await authenticator.respond(c, e);
+               }
+            },
+         )
+         .post(
+            "/register",
+            tb(
+               "query",
+               Type.Object({
+                  redirect: Type.Optional(Type.String()),
+               }),
+            ),
+            async (c) => {
+               const body = await authenticator.getBody(c);
+               const { redirect } = c.req.valid("query");
+
+               const payload = await this.register(body);
+               const data = await authenticator.resolve(
+                  "register",
+                  this,
+                  payload.password,
+                  payload,
+               );
+
+               return await authenticator.respond(c, data, redirect);
+            },
+         );
+   }
+
+   getActions(): StrategyActions {
+      return {
+         create: createStrategyAction(
+            Type.Object({
+               email: Type.String({
+                  pattern: "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$",
+               }),
+               password: Type.String({
+                  minLength: 8, // @todo: this should be configurable
+               }),
+            }),
+            async ({ password, ...input }) => {
+               return {
+                  ...input,
+                  strategy_value: await this.hash(password),
+               };
+            },
+         ),
+      };
    }
 
    getSchema() {
       return schema;
    }
 
-   private getPayloadSchema() {
-      return Type.Object({
-         email: Type.String({
-            pattern: "^[\\w-\\.\\+_]+@([\\w-]+\\.)+[\\w-]{2,4}$",
-         }),
-         password: Type.String({
-            minLength: 8, // @todo: this should be configurable
-         }),
-      });
+   getType() {
+      return "password";
    }
 
-   async hash(password: string) {
-      switch (this.config.hashing) {
-         case "sha256":
-            return hash.sha256(password);
-         case "bcrypt": {
-            const salt = await bcryptGenSalt(this.config.rounds ?? 4);
-            return bcryptHash(password, salt);
-         }
-         default:
-            return password;
-      }
+   getMode() {
+      return "form" as const;
    }
 
-   async compare(actual: string, compare: string): Promise<boolean> {
-      switch (this.config.hashing) {
-         case "sha256": {
-            const compareHashed = await this.hash(compare);
-            return actual === compareHashed;
-         }
-         case "bcrypt":
-            return await bcryptCompare(compare, actual);
-      }
-
-      return false;
+   getName() {
+      return "password" as const;
    }
 
-   verify(password: string) {
-      return async (user: User) => {
-         const compare = await this.compare(user?.strategy_value!, password);
-         if (compare !== true) {
-            throw new InvalidCredentialsException();
-         }
-      };
-   }
-
-   getController(authenticator: Authenticator): Hono<any> {
-      const hono = new Hono();
-      const redirectQuerySchema = Type.Object({
-         redirect: Type.Optional(Type.String()),
-      });
-      const payloadSchema = this.getPayloadSchema();
-
-      hono.post("/login", tb("query", redirectQuerySchema), async (c) => {
-         try {
-            const body = parse(payloadSchema, await authenticator.getBody(c), {
-               onError: (errors) => {
-                  $console.error("Invalid login payload", [...errors]);
-                  throw new InvalidCredentialsException();
-               },
-            });
-            const { redirect } = c.req.valid("query");
-
-            return await authenticator.resolveLogin(c, this, body, this.verify(body.password), {
-               redirect,
-            });
-         } catch (e) {
-            return authenticator.respondWithError(c, e as any);
-         }
-      });
-
-      hono.post("/register", tb("query", redirectQuerySchema), async (c) => {
-         try {
-            const { redirect } = c.req.valid("query");
-            const { password, email, ...body } = parse(
-               payloadSchema,
-               await authenticator.getBody(c),
-               {
-                  onError: (errors) => {
-                     $console.error("Invalid register payload", [...errors]);
-                     new InvalidCredentialsException();
-                  },
-               },
-            );
-
-            const profile = {
-               ...body,
-               email,
-               strategy_value: await this.hash(password),
-            };
-
-            return await authenticator.resolveRegister(c, this, profile, async () => void 0, {
-               redirect,
-            });
-         } catch (e) {
-            return authenticator.respondWithError(c, e as any);
-         }
-      });
-
-      return hono;
+   toJSON(secrets?: boolean) {
+      return secrets ? this.options : undefined;
    }
 }

app/src/auth/authenticate/strategies/Strategy.ts

@@ -1,63 +0,0 @@
-import type {
-   Authenticator,
-   StrategyAction,
-   StrategyActionName,
-   StrategyActions,
-} from "../Authenticator";
-import type { Hono } from "hono";
-import type { Static, TSchema } from "@sinclair/typebox";
-import { parse, type TObject } from "core/utils";
-
-export type StrategyMode = "form" | "external";
-
-export abstract class Strategy<Schema extends TSchema = TSchema> {
-   protected actions: StrategyActions = {};
-
-   constructor(
-      protected config: Static<Schema>,
-      public type: string,
-      public name: string,
-      public mode: StrategyMode,
-   ) {
-      // don't worry about typing, it'll throw if invalid
-      this.config = parse(this.getSchema(), (config ?? {}) as any) as Static<Schema>;
-   }
-
-   protected registerAction<S extends TObject = TObject>(
-      name: StrategyActionName,
-      schema: S,
-      preprocess: StrategyAction<S>["preprocess"],
-   ): void {
-      this.actions[name] = {
-         schema,
-         preprocess,
-      } as const;
-   }
-
-   protected abstract getSchema(): Schema;
-
-   abstract getController(auth: Authenticator): Hono;
-
-   getType(): string {
-      return this.type;
-   }
-
-   getMode() {
-      return this.mode;
-   }
-
-   getName(): string {
-      return this.name;
-   }
-
-   toJSON(secrets?: boolean): { type: string; config: Static<Schema> | {} | undefined } {
-      return {
-         type: this.getType(),
-         config: secrets ? this.config : undefined,
-      };
-   }
-
-   getActions(): StrategyActions {
-      return this.actions;
-   }
-}

app/src/auth/authenticate/strategies/index.ts

@@ -5,8 +5,8 @@ import { OAuthCallbackException, OAuthStrategy } from "./oauth/OAuthStrategy";
 export * as issuers from "./oauth/issuers";
 
 export {
-   type PasswordStrategyOptions,
    PasswordStrategy,
+   type PasswordStrategyOptions,
    OAuthStrategy,
    OAuthCallbackException,
    CustomOAuthStrategy,

app/src/auth/authenticate/strategies/oauth/CustomOAuthStrategy.ts

@@ -1,35 +1,43 @@
-import { type Static, StrictObject, StringEnum } from "core/utils";
-import * as tbbox from "@sinclair/typebox";
+import { type Static, StringEnum, Type } from "core/utils";
 import type * as oauth from "oauth4webapi";
 import { OAuthStrategy } from "./OAuthStrategy";
-const { Type } = tbbox;
 
 type SupportedTypes = "oauth2" | "oidc";
 
 type RequireKeys<T extends object, K extends keyof T> = Required<Pick<T, K>> & Omit<T, K>;
 
 const UrlString = Type.String({ pattern: "^(https?|wss?)://[^\\s/$.?#].[^\\s]*$" });
-const oauthSchemaCustom = StrictObject(
+const oauthSchemaCustom = Type.Object(
    {
       type: StringEnum(["oidc", "oauth2"] as const, { default: "oidc" }),
       name: Type.String(),
-      client: StrictObject({
-         client_id: Type.String(),
-         client_secret: Type.String(),
-         token_endpoint_auth_method: StringEnum(["client_secret_basic"]),
-      }),
-      as: StrictObject({
-         issuer: Type.String(),
-         code_challenge_methods_supported: Type.Optional(StringEnum(["S256"])),
-         scopes_supported: Type.Optional(Type.Array(Type.String())),
-         scope_separator: Type.Optional(Type.String({ default: " " })),
-         authorization_endpoint: Type.Optional(UrlString),
-         token_endpoint: Type.Optional(UrlString),
-         userinfo_endpoint: Type.Optional(UrlString),
-      }),
+      client: Type.Object(
+         {
+            client_id: Type.String(),
+            client_secret: Type.String(),
+            token_endpoint_auth_method: StringEnum(["client_secret_basic"]),
+         },
+         {
+            additionalProperties: false,
+         },
+      ),
+      as: Type.Object(
+         {
+            issuer: Type.String(),
+            code_challenge_methods_supported: Type.Optional(StringEnum(["S256"])),
+            scopes_supported: Type.Optional(Type.Array(Type.String())),
+            scope_separator: Type.Optional(Type.String({ default: " " })),
+            authorization_endpoint: Type.Optional(UrlString),
+            token_endpoint: Type.Optional(UrlString),
+            userinfo_endpoint: Type.Optional(UrlString),
+         },
+         {
+            additionalProperties: false,
+         },
+      ),
       // @todo: profile mapping
    },
-   { title: "Custom OAuth" },
+   { title: "Custom OAuth", additionalProperties: false },
 );
 
 type OAuthConfigCustom = Static<typeof oauthSchemaCustom>;
@@ -54,11 +62,6 @@ export type IssuerConfig<UserInfo = any> = {
 };
 
 export class CustomOAuthStrategy extends OAuthStrategy {
-   constructor(config: OAuthConfigCustom) {
-      super(config as any);
-      this.type = "custom_oauth";
-   }
-
    override getIssuerConfig(): IssuerConfig {
       return { ...this.config, profile: async (info) => info } as any;
    }
@@ -67,4 +70,8 @@ export class CustomOAuthStrategy extends OAuthStrategy {
    override getSchema() {
       return oauthSchemaCustom;
    }
+
+   override getType() {
+      return "custom_oauth";
+   }
 }

app/src/auth/authenticate/strategies/oauth/OAuthStrategy.ts

@@ -1,13 +1,10 @@
-import type { AuthAction, Authenticator } from "auth";
+import type { AuthAction, Authenticator, Strategy } from "auth";
 import { Exception, isDebug } from "core";
-import { type Static, StringEnum, filterKeys, StrictObject } from "core/utils";
+import { type Static, StringEnum, type TSchema, Type, filterKeys, parse } from "core/utils";
 import { type Context, Hono } from "hono";
 import { getSignedCookie, setSignedCookie } from "hono/cookie";
 import * as oauth from "oauth4webapi";
 import * as issuers from "./issuers";
-import * as tbbox from "@sinclair/typebox";
-import { Strategy } from "auth/authenticate/strategies/Strategy";
-const { Type } = tbbox;
 
 type ConfiguredIssuers = keyof typeof issuers;
 type SupportedTypes = "oauth2" | "oidc";
@@ -16,12 +13,17 @@ type RequireKeys<T extends object, K extends keyof T> = Required<Pick<T, K>> & O
 
 const schemaProvided = Type.Object(
    {
+      //type: StringEnum(["oidc", "oauth2"] as const, { default: "oidc" }),
       name: StringEnum(Object.keys(issuers) as ConfiguredIssuers[]),
-      type: StringEnum(["oidc", "oauth2"] as const, { default: "oauth2" }),
-      client: StrictObject({
-         client_id: Type.String(),
-         client_secret: Type.String(),
-      }),
+      client: Type.Object(
+         {
+            client_id: Type.String(),
+            client_secret: Type.String(),
+         },
+         {
+            additionalProperties: false,
+         },
+      ),
    },
    { title: "OAuth" },
 );
@@ -69,13 +71,11 @@ export class OAuthCallbackException extends Exception {
    }
 }
 
-export class OAuthStrategy extends Strategy<typeof schemaProvided> {
-   constructor(config: ProvidedOAuthConfig) {
-      super(config, "oauth", config.name, "external");
-   }
+export class OAuthStrategy implements Strategy {
+   constructor(private _config: OAuthConfig) {}
 
-   getSchema() {
-      return schemaProvided;
+   get config() {
+      return this._config;
    }
 
    getIssuerConfig(): IssuerConfig {
@@ -103,7 +103,7 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
          type: info.type,
          client: {
             ...info.client,
-            ...this.config.client,
+            ...this._config.client,
          },
       };
    }
@@ -172,7 +172,8 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
    ) {
       const config = await this.getConfig();
       const { client, as, type } = config;
-
+      //console.log("config", config);
+      console.log("callbackParams", callbackParams, options);
       const parameters = oauth.validateAuthResponse(
          as,
          client, // no client_secret required
@@ -180,9 +181,13 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
          oauth.expectNoState,
       );
       if (oauth.isOAuth2Error(parameters)) {
+         //console.log("callback.error", parameters);
          throw new OAuthCallbackException(parameters, "validateAuthResponse");
       }
-
+      /*console.log(
+         "callback.parameters",
+         JSON.stringify(Object.fromEntries(parameters.entries()), null, 2),
+      );*/
       const response = await oauth.authorizationCodeGrantRequest(
          as,
          client,
@@ -190,9 +195,13 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
          options.redirect_uri,
          options.state,
       );
+      //console.log("callback.response", response);
 
       const challenges = oauth.parseWwwAuthenticateChallenges(response);
       if (challenges) {
+         for (const challenge of challenges) {
+            //console.log("callback.challenge", challenge);
+         }
          // @todo: Handle www-authenticate challenges as needed
          throw new OAuthCallbackException(challenges, "www-authenticate");
       }
@@ -207,13 +216,20 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
          expectedNonce,
       );
       if (oauth.isOAuth2Error(result)) {
+         console.log("callback.error", result);
          // @todo: Handle OAuth 2.0 response body error
          throw new OAuthCallbackException(result, "processAuthorizationCodeOpenIDResponse");
       }
 
+      //console.log("callback.result", result);
+
       const claims = oauth.getValidatedIdTokenClaims(result);
+      //console.log("callback.IDTokenClaims", claims);
+
       const infoRequest = await oauth.userInfoRequest(as, client, result.access_token!);
+
       const resultUser = await oauth.processUserInfoResponse(as, client, claims.sub, infoRequest);
+      //console.log("callback.resultUser", resultUser);
 
       return await config.profile(resultUser, config, claims); // @todo: check claims
    }
@@ -224,7 +240,8 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
    ) {
       const config = await this.getConfig();
       const { client, type, as, profile } = config;
-
+      console.log("config", { client, as, type });
+      console.log("callbackParams", callbackParams, options);
       const parameters = oauth.validateAuthResponse(
          as,
          client, // no client_secret required
@@ -232,9 +249,13 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
          oauth.expectNoState,
       );
       if (oauth.isOAuth2Error(parameters)) {
+         console.log("callback.error", parameters);
          throw new OAuthCallbackException(parameters, "validateAuthResponse");
       }
-
+      console.log(
+         "callback.parameters",
+         JSON.stringify(Object.fromEntries(parameters.entries()), null, 2),
+      );
       const response = await oauth.authorizationCodeGrantRequest(
          as,
          client,
@@ -245,6 +266,9 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
 
       const challenges = oauth.parseWwwAuthenticateChallenges(response);
       if (challenges) {
+         for (const challenge of challenges) {
+            //console.log("callback.challenge", challenge);
+         }
          // @todo: Handle www-authenticate challenges as needed
          throw new OAuthCallbackException(challenges, "www-authenticate");
       }
@@ -255,15 +279,19 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
       try {
          result = await oauth.processAuthorizationCodeOAuth2Response(as, client, response);
          if (oauth.isOAuth2Error(result)) {
+            console.log("error", result);
             throw new Error(); // Handle OAuth 2.0 response body error
          }
       } catch (e) {
          result = (await copy.json()) as any;
+         console.log("failed", result);
       }
 
       const res2 = await oauth.userInfoRequest(as, client, result.access_token!);
       const user = await res2.json();
+      console.log("res2", res2, user);
 
+      console.log("result", result);
       return await config.profile(user, config, result);
    }
 
@@ -273,6 +301,7 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
    ): Promise<UserProfile> {
       const type = this.getIssuerConfig().type;
 
+      console.log("type", type);
       switch (type) {
          case "oidc":
             return await this.oidc(callbackParams, options);
@@ -296,6 +325,7 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
       };
 
       const setState = async (c: Context, config: TState): Promise<void> => {
+         console.log("--- setting state", config);
          await setSignedCookie(c, cookie_name, JSON.stringify(config), secret, {
             secure: true,
             httpOnly: true,
@@ -326,6 +356,7 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
          const params = new URLSearchParams(url.search);
 
          const state = await getState(c);
+         console.log("state", state);
 
          // @todo: add config option to determine if state.action is allowed
          const redirect_uri =
@@ -338,28 +369,21 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
             state: state.state,
          });
 
-         const safeProfile = {
-            email: profile.email,
-            strategy_value: profile.sub,
-         } as const;
+         try {
+            const data = await auth.resolve(state.action, this, profile.sub, profile);
+            console.log("******** RESOLVED ********", data);
 
-         const verify = async (user) => {
-            if (user.strategy_value !== profile.sub) {
-               throw new Exception("Invalid credentials");
+            if (state.mode === "cookie") {
+               return await auth.respond(c, data, state.redirect);
             }
-         };
-         const opts = {
-            redirect: state.redirect,
-            forceJsonResponse: state.mode !== "cookie",
-         } as const;
 
-         switch (state.action) {
-            case "login":
-               return auth.resolveLogin(c, this, safeProfile, verify, opts);
-            case "register":
-               return auth.resolveRegister(c, this, safeProfile, verify, opts);
-            default:
-               throw new Error("Invalid action");
+            return c.json(data);
+         } catch (e) {
+            if (state.mode === "cookie") {
+               return await auth.respond(c, e, state.redirect);
+            }
+
+            throw e;
          }
       });
 
@@ -388,8 +412,10 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
             redirect_uri,
             state,
          });
+         //console.log("_state", state);
 
          await setState(c, { state, action, redirect: referer.toString(), mode: "cookie" });
+         console.log("--redirecting to", response.url);
 
          return c.redirect(response.url);
       });
@@ -430,15 +456,28 @@ export class OAuthStrategy extends Strategy<typeof schemaProvided> {
       return hono;
    }
 
-   override toJSON(secrets?: boolean) {
+   getType() {
+      return "oauth";
+   }
+
+   getMode() {
+      return "external" as const;
+   }
+
+   getName() {
+      return this.config.name;
+   }
+
+   getSchema() {
+      return schemaProvided;
+   }
+
+   toJSON(secrets?: boolean) {
       const config = secrets ? this.config : filterKeys(this.config, ["secret", "client_id"]);
 
       return {
-         ...super.toJSON(secrets),
-         config: {
-            ...config,
-            type: this.getIssuerConfig().type,
-         },
+         type: this.getIssuerConfig().type,
+         ...config,
       };
    }
 }