move sort plugin to data plugins

- Introduced a new sort plugin that allows sorting of entities based on a specified field.
- Added API endpoints for reordering items and recalculating sort order.
- Implemented tests to ensure correct functionality of sorting and reordering features.

.github/workflows/test.yml

@@ -9,21 +9,6 @@ jobs:
   test:
     runs-on: ubuntu-latest
     
-    services:
-      postgres:
-        image: postgres:17
-        env:
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_USER: postgres
-          POSTGRES_DB: bknd
-        ports:
-          - 5430:5432
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-    
     steps:
       - uses: actions/checkout@v4
       
@@ -39,7 +24,7 @@ jobs:
 
       - name: Install dependencies
         working-directory: ./app
-        run: bun install #--linker=hoisted
+        run: bun install
 
       - name: Build
         working-directory: ./app

LICENSE.md

@@ -1,202 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
 
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+## Abbreviation
 
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+FSL-1.1-MIT
 
-1. Definitions.
+## Notice
 
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
+Copyright 2025 Dennis Senn
 
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
+## Terms and Conditions
 
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
+### Licensor ("We")
 
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
+The party offering the Software under these Terms and Conditions.
 
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
+### The Software
 
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
 
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
+### License Grant
 
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
 
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
+### Permitted Purpose
 
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
 
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
+1. substitutes for the Software;
 
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
 
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
+3. offers the same or substantially similar functionality as the Software.
 
-   (a) You must give any other recipients of the Work or
-   Derivative Works a copy of this License; and
+Permitted Purposes specifically include using the Software:
 
-   (b) You must cause any modified files to carry prominent notices
-   stating that You changed the files; and
+1. for your internal use and access;
 
-   (c) You must retain, in the Source form of any Derivative Works
-   that You distribute, all copyright, patent, trademark, and
-   attribution notices from the Source form of the Work,
-   excluding those notices that do not pertain to any part of
-   the Derivative Works; and
+2. for non-commercial education;
 
-   (d) If the Work includes a "NOTICE" text file as part of its
-   distribution, then any Derivative Works that You distribute must
-   include a readable copy of the attribution notices contained
-   within such NOTICE file, excluding those notices that do not
-   pertain to any part of the Derivative Works, in at least one
-   of the following places: within a NOTICE text file distributed
-   as part of the Derivative Works; within the Source form or
-   documentation, if provided along with the Derivative Works; or,
-   within a display generated by the Derivative Works, if and
-   wherever such third-party notices normally appear. The contents
-   of the NOTICE file are for informational purposes only and
-   do not modify the License. You may add Your own attribution
-   notices within Derivative Works that You distribute, alongside
-   or as an addendum to the NOTICE text from the Work, provided
-   that such additional attribution notices cannot be construed
-   as modifying the License.
+3. for non-commercial research; and
 
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
 
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
+### Patents
 
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
 
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
+### Redistribution
 
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
 
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
 
-END OF TERMS AND CONDITIONS
+### Disclaimer
 
-APPENDIX: How to apply the Apache License to your work.
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
 
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
 
-Copyright 2026 Dennis Senn
+### Trademarks
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
 
-       http://www.apache.org/licenses/LICENSE-2.0
+## Grant of Future License
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -17,7 +17,7 @@ It's designed to avoid vendor lock-in and architectural limitations. Built exclu
   * SQLite: LibSQL, Node SQLite, Bun SQLite, Cloudflare D1, Cloudflare Durable Objects SQLite, SQLocal
   * Postgres: Vanilla Postgres, Supabase, Neon, Xata
 * **Frameworks**: React, Next.js, React Router, Astro, Vite, Waku
-* **Storage**: AWS S3, S3-compatible (Tigris, R2, Minio, etc.), Cloudflare R2 (binding), Cloudinary, Filesystem, Origin Private File System (OPFS)
+* **Storage**: AWS S3, S3-compatible (Tigris, R2, Minio, etc.), Cloudflare R2 (binding), Cloudinary, Filesystem
 * **Deployment**: Standalone, Docker, Cloudflare Workers, Vercel, Netlify, Deno Deploy, AWS Lambda, Valtown etc.
 
 **For documentation and examples, please visit https://docs.bknd.io.**

app/__test__/api/MediaApi.spec.ts

@@ -67,7 +67,7 @@ describe("MediaApi", () => {
       const res = await mockedBackend.request("/api/media/file/" + name);
       await Bun.write(path, res);
 
-      const file = Bun.file(path);
+      const file = await Bun.file(path);
       expect(file.size).toBeGreaterThan(0);
       expect(file.type).toBe("image/png");
       await file.delete();
@@ -154,12 +154,15 @@ describe("MediaApi", () => {
       }
 
       // upload via readable from bun
-      await matches(api.upload(file.stream(), { filename: "readable.png" }), "readable.png");
+      await matches(await api.upload(file.stream(), { filename: "readable.png" }), "readable.png");
 
       // upload via readable from response
       {
          const response = (await mockedBackend.request(url)) as Response;
-         await matches(api.upload(response.body!, { filename: "readable.png" }), "readable.png");
+         await matches(
+            await api.upload(response.body!, { filename: "readable.png" }),
+            "readable.png",
+         );
       }
    });
 });

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

@@ -1,12 +1,8 @@
-import { describe, expect, mock, test, beforeAll, afterAll } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 import { createApp as internalCreateApp, type CreateAppConfig } from "bknd";
 import { getDummyConnection } from "../../__test__/helper";
 import { ModuleManager } from "modules/ModuleManager";
 import { em, entity, text } from "data/prototype";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
 
 async function createApp(config: CreateAppConfig = {}) {
    const app = internalCreateApp({

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

@@ -1,11 +1,7 @@
 import { AppEvents } from "App";
-import { describe, test, expect, beforeAll, mock, afterAll } from "bun:test";
+import { describe, test, expect, beforeAll, mock } from "bun:test";
 import { type App, createApp, createMcpToolCaller } from "core/test/utils";
 import type { McpServer } from "bknd/utils";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
 
 /**
  * - [x] system_config

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

@@ -1,12 +1,8 @@
-import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import { Guard, type GuardConfig } from "auth/authorize/Guard";
 import { Permission } from "auth/authorize/Permission";
 import { Role, type RoleSchema } from "auth/authorize/Role";
 import { objectTransform, s } from "bknd/utils";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
 
 function createGuard(
    permissionNames: string[],

app/__test__/auth/authorize/data.permissions.test.ts

@@ -7,8 +7,8 @@ import type { App, DB } from "bknd";
 import type { CreateUserPayload } from "auth/AppAuth";
 import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
 
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
+beforeAll(() => disableConsoleLog());
+afterAll(() => enableConsoleLog());
 
 async function makeApp(config: Partial<CreateAppConfig["config"]> = {}) {
    const app = createApp({

app/__test__/auth/authorize/http/DataController.test.ts

@@ -1,40 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { createAuthTestApp } from "./shared";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-import { em, entity, text } from "data/prototype";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-const schema = em(
-   {
-      posts: entity("posts", {
-         title: text(),
-         content: text(),
-      }),
-      comments: entity("comments", {
-         content: text(),
-      }),
-   },
-   ({ relation }, { posts, comments }) => {
-      relation(posts).manyToOne(comments);
-   },
-);
-
-describe("DataController (auth)", () => {
-   test("reading schema.json", async () => {
-      const { request } = await createAuthTestApp(
-         {
-            permission: ["system.access.api", "data.entity.read", "system.schema.read"],
-            request: new Request("http://localhost/api/data/schema.json"),
-         },
-         {
-            config: { data: schema.toJSON() },
-         },
-      );
-      expect((await request.guest()).status).toBe(403);
-      expect((await request.member()).status).toBe(403);
-      expect((await request.authorized()).status).toBe(200);
-      expect((await request.admin()).status).toBe(200);
-   });
-});

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

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "bun:test";
+import { SystemController } from "modules/server/SystemController";
+import { createApp } from "core/test/utils";
+import type { CreateAppConfig } from "App";
+import { getPermissionRoutes } from "auth/middlewares/permission.middleware";
+
+async function makeApp(config: Partial<CreateAppConfig> = {}) {
+   const app = createApp(config);
+   await app.build();
+   return app;
+}
+
+describe.skip("SystemController", () => {
+   it("...", async () => {
+      const app = await makeApp();
+      const controller = new SystemController(app);
+      const hono = controller.getController();
+      console.log(getPermissionRoutes(hono));
+   });
+});

app/__test__/auth/authorize/http/SystemController.test.ts

@@ -1,41 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { createAuthTestApp } from "./shared";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-describe("SystemController (auth)", () => {
-   test("reading info", async () => {
-      const { request } = await createAuthTestApp({
-         permission: ["system.access.api", "system.info"],
-         request: new Request("http://localhost/api/system/info"),
-      });
-      expect((await request.guest()).status).toBe(403);
-      expect((await request.member()).status).toBe(403);
-      expect((await request.authorized()).status).toBe(200);
-      expect((await request.admin()).status).toBe(200);
-   });
-
-   test("reading permissions", async () => {
-      const { request } = await createAuthTestApp({
-         permission: ["system.access.api", "system.schema.read"],
-         request: new Request("http://localhost/api/system/permissions"),
-      });
-      expect((await request.guest()).status).toBe(403);
-      expect((await request.member()).status).toBe(403);
-      expect((await request.authorized()).status).toBe(200);
-      expect((await request.admin()).status).toBe(200);
-   });
-
-   test("access openapi", async () => {
-      const { request } = await createAuthTestApp({
-         permission: ["system.access.api", "system.openapi"],
-         request: new Request("http://localhost/api/system/openapi.json"),
-      });
-      expect((await request.guest()).status).toBe(403);
-      expect((await request.member()).status).toBe(403);
-      expect((await request.authorized()).status).toBe(200);
-      expect((await request.admin()).status).toBe(200);
-   });
-});

app/__test__/auth/authorize/http/shared.ts

@@ -1,171 +0,0 @@
-import { createApp } from "core/test/utils";
-import type { CreateAppConfig } from "App";
-import type { RoleSchema } from "auth/authorize/Role";
-import { isPlainObject } from "core/utils";
-
-export type AuthTestConfig = {
-   guest?: RoleSchema;
-   member?: RoleSchema;
-   authorized?: RoleSchema;
-};
-
-export async function createAuthTestApp(
-   testConfig: {
-      permission: AuthTestConfig | string | string[];
-      request: Request;
-   },
-   config: Partial<CreateAppConfig> = {},
-) {
-   let member: RoleSchema | undefined;
-   let authorized: RoleSchema | undefined;
-   let guest: RoleSchema | undefined;
-   if (isPlainObject(testConfig.permission)) {
-      if (testConfig.permission.guest)
-         guest = {
-            ...testConfig.permission.guest,
-            is_default: true,
-         };
-      if (testConfig.permission.member) member = testConfig.permission.member;
-      if (testConfig.permission.authorized) authorized = testConfig.permission.authorized;
-   } else {
-      member = {
-         permissions: [],
-      };
-      authorized = {
-         permissions: Array.isArray(testConfig.permission)
-            ? testConfig.permission
-            : [testConfig.permission],
-      };
-      guest = {
-         permissions: [],
-         is_default: true,
-      };
-   }
-
-   console.log("authorized", authorized);
-
-   const app = createApp({
-      ...config,
-      config: {
-         ...config.config,
-         auth: {
-            ...config.config?.auth,
-            enabled: true,
-            guard: {
-               enabled: true,
-               ...config.config?.auth?.guard,
-            },
-            jwt: {
-               ...config.config?.auth?.jwt,
-               secret: "secret",
-            },
-            roles: {
-               ...config.config?.auth?.roles,
-               guest,
-               member,
-               authorized,
-               admin: {
-                  implicit_allow: true,
-               },
-            },
-         },
-      },
-   });
-   await app.build();
-
-   const users = {
-      guest: null,
-      member: await app.createUser({
-         email: "member@test.com",
-         password: "12345678",
-         role: "member",
-      }),
-      authorized: await app.createUser({
-         email: "authorized@test.com",
-         password: "12345678",
-         role: "authorized",
-      }),
-      admin: await app.createUser({
-         email: "admin@test.com",
-         password: "12345678",
-         role: "admin",
-      }),
-   } as const;
-
-   const tokens = {} as Record<keyof typeof users, string>;
-   for (const [key, user] of Object.entries(users)) {
-      if (user) {
-         tokens[key as keyof typeof users] = await app.module.auth.authenticator.jwt(user);
-      }
-   }
-
-   async function makeRequest(user: keyof typeof users, input: string, init: RequestInit = {}) {
-      const headers = new Headers(init.headers ?? {});
-      if (user in tokens) {
-         headers.set("Authorization", `Bearer ${tokens[user as keyof typeof tokens]}`);
-      }
-      const res = await app.server.request(input, {
-         ...init,
-         headers,
-      });
-
-      let data: any;
-      if (res.headers.get("Content-Type")?.startsWith("application/json")) {
-         data = await res.json();
-      } else if (res.headers.get("Content-Type")?.startsWith("text/")) {
-         data = await res.text();
-      }
-
-      return {
-         status: res.status,
-         ok: res.ok,
-         headers: Object.fromEntries(res.headers.entries()),
-         data,
-      };
-   }
-
-   const requestFn = new Proxy(
-      {},
-      {
-         get(_, prop: keyof typeof users) {
-            return async (input: string, init: RequestInit = {}) => {
-               return makeRequest(prop, input, init);
-            };
-         },
-      },
-   ) as {
-      [K in keyof typeof users]: (
-         input: string,
-         init?: RequestInit,
-      ) => Promise<{
-         status: number;
-         ok: boolean;
-         headers: Record<string, string>;
-         data: any;
-      }>;
-   };
-
-   const request = new Proxy(
-      {},
-      {
-         get(_, prop: keyof typeof users) {
-            return async () => {
-               return makeRequest(prop, testConfig.request.url, {
-                  headers: testConfig.request.headers,
-                  method: testConfig.request.method,
-                  body: testConfig.request.body,
-               });
-            };
-         },
-      },
-   ) as {
-      [K in keyof typeof users]: () => Promise<{
-         status: number;
-         ok: boolean;
-         headers: Record<string, string>;
-         data: any;
-      }>;
-   };
-
-   return { app, users, request, requestFn };
-}

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

@@ -1,13 +0,0 @@
-import { PasswordStrategy } from "auth/authenticate/strategies/PasswordStrategy";
-import { describe, expect, it } from "bun:test";
-
-describe("PasswordStrategy", () => {
-   it("should enforce provided minimum length", async () => {
-      const strategy = new PasswordStrategy({ minLength: 8, hashing: "plain" });
-
-      expect(strategy.verify("password")({} as any)).rejects.toThrow();
-      expect(
-         strategy.verify("password1234")({ strategy_value: "password1234" } as any),
-      ).resolves.toBeUndefined();
-   });
-});

app/__test__/data/postgres.test.ts

@@ -1,85 +0,0 @@
-import { describe, beforeAll, afterAll, test } from "bun:test";
-import type { PostgresConnection } from "data/connection/postgres/PostgresConnection";
-import { pg, postgresJs } from "bknd";
-import { Pool } from "pg";
-import postgres from "postgres";
-import { disableConsoleLog, enableConsoleLog, $waitUntil } from "bknd/utils";
-import { $ } from "bun";
-import { connectionTestSuite } from "data/connection/connection-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-
-const credentials = {
-   host: "localhost",
-   port: 5430,
-   user: "postgres",
-   password: "postgres",
-   database: "bknd",
-};
-
-async function cleanDatabase(connection: InstanceType<typeof PostgresConnection>) {
-   const kysely = connection.kysely;
-
-   // drop all tables+indexes & create new schema
-   await kysely.schema.dropSchema("public").ifExists().cascade().execute();
-   await kysely.schema.dropIndex("public").ifExists().cascade().execute();
-   await kysely.schema.createSchema("public").execute();
-}
-
-async function isPostgresRunning() {
-   try {
-      // Try to actually connect to PostgreSQL
-      const conn = pg({ pool: new Pool(credentials) });
-      await conn.ping();
-      await conn.close();
-      return true;
-   } catch (e) {
-      return false;
-   }
-}
-
-describe("postgres", () => {
-   beforeAll(async () => {
-      if (!(await isPostgresRunning())) {
-         await $`docker run --rm --name bknd-test-postgres -d -e POSTGRES_PASSWORD=${credentials.password} -e POSTGRES_USER=${credentials.user} -e POSTGRES_DB=${credentials.database} -p ${credentials.port}:5432 postgres:17`;
-         await $waitUntil("Postgres is running", isPostgresRunning);
-         await new Promise((resolve) => setTimeout(resolve, 500));
-      }
-
-      disableConsoleLog();
-   });
-   afterAll(async () => {
-      if (await isPostgresRunning()) {
-         try {
-            await $`docker stop bknd-test-postgres`;
-         } catch (e) {}
-      }
-
-      enableConsoleLog();
-   });
-
-   describe.serial.each([
-      ["pg", () => pg({ pool: new Pool(credentials) })],
-      ["postgresjs", () => postgresJs({ postgres: postgres(credentials) })],
-   ])("%s", (name, createConnection) => {
-      connectionTestSuite(
-         {
-            ...bunTestRunner,
-            test: test.serial,
-         },
-         {
-            makeConnection: () => {
-               const connection = createConnection();
-               return {
-                  connection,
-                  dispose: async () => {
-                     await cleanDatabase(connection);
-                     await connection.close();
-                  },
-               };
-            },
-            rawDialectDetails: [],
-            disableConsoleLog: false,
-         },
-      );
-   });
-});

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

@@ -124,81 +124,6 @@ describe("[Repository]", async () => {
             .then((r) => [r.count, r.total]),
       ).resolves.toEqual([undefined, undefined]);
    });
-
-   test("auto join", async () => {
-      const schema = $em(
-         {
-            posts: $entity("posts", {
-               title: $text(),
-               content: $text(),
-            }),
-            comments: $entity("comments", {
-               content: $text(),
-            }),
-            another: $entity("another", {
-               title: $text(),
-            }),
-         },
-         ({ relation }, { posts, comments }) => {
-            relation(comments).manyToOne(posts);
-         },
-      );
-      const em = schema.proto.withConnection(getDummyConnection().dummyConnection);
-      await em.schema().sync({ force: true });
-
-      await em.mutator("posts").insertOne({ title: "post1", content: "content1" });
-      await em
-         .mutator("comments")
-         .insertMany([{ content: "comment1", posts_id: 1 }, { content: "comment2" }] as any);
-
-      const res = await em.repo("comments").findMany({
-         where: {
-            "posts.title": "post1",
-         },
-      });
-      expect(res.data as any).toEqual([
-         {
-            id: 1,
-            content: "comment1",
-            posts_id: 1,
-         },
-      ]);
-
-      {
-         // manual join should still work
-         const res = await em.repo("comments").findMany({
-            join: ["posts"],
-            where: {
-               "posts.title": "post1",
-            },
-         });
-         expect(res.data as any).toEqual([
-            {
-               id: 1,
-               content: "comment1",
-               posts_id: 1,
-            },
-         ]);
-      }
-
-      // inexistent should be detected and thrown
-      expect(
-         em.repo("comments").findMany({
-            where: {
-               "random.title": "post1",
-            },
-         }),
-      ).rejects.toThrow(/Invalid where field/);
-
-      // existing alias, but not a relation should throw
-      expect(
-         em.repo("comments").findMany({
-            where: {
-               "another.title": "post1",
-            },
-         }),
-      ).rejects.toThrow(/Invalid where field/);
-   });
 });
 
 describe("[data] Repository (Events)", async () => {

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

@@ -59,7 +59,7 @@ describe("SqliteIntrospector", () => {
                   dataType: "INTEGER",
                   isNullable: false,
                   isAutoIncrementing: true,
-                  hasDefaultValue: true,
+                  hasDefaultValue: false,
                   comment: undefined,
                },
                {
@@ -89,7 +89,7 @@ describe("SqliteIntrospector", () => {
                   dataType: "INTEGER",
                   isNullable: false,
                   isAutoIncrementing: true,
-                  hasDefaultValue: true,
+                  hasDefaultValue: false,
                   comment: undefined,
                },
                {

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

@@ -1,15 +1,9 @@
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
 import { App, createApp, type AuthResponse } from "../../src";
 import { auth } from "../../src/modules/middlewares";
-import {
-   mergeObject,
-   randomString,
-   secureRandomString,
-   withDisabledConsole,
-} from "../../src/core/utils";
+import { randomString, secureRandomString, withDisabledConsole } from "../../src/core/utils";
 import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
 import { getDummyConnection } from "../helper";
-import type { AppAuthSchema } from "auth/auth-schema";
 
 beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
@@ -68,12 +62,12 @@ const configs = {
    },
 };
 
-function createAuthApp(config?: Partial<AppAuthSchema>) {
+function createAuthApp() {
    const { dummyConnection } = getDummyConnection();
    const app = createApp({
       connection: dummyConnection,
       config: {
-         auth: mergeObject(configs.auth, config ?? {}),
+         auth: configs.auth,
       },
    });
 
@@ -138,16 +132,6 @@ const fns = <Mode extends "cookie" | "token" = "token">(app: App, mode?: Mode) =
 
          return { res, data };
       },
-      register: async (user: any): Promise<{ res: Response; data: AuthResponse }> => {
-         const res = (await app.server.request("/api/auth/password/register", {
-            method: "POST",
-            headers: headers(),
-            body: body(user),
-         })) as Response;
-         const data = mode === "cookie" ? getCookie(res, "auth") : await res.json();
-
-         return { res, data };
-      },
       me: async (token?: string): Promise<Pick<AuthResponse, "user">> => {
          const res = (await app.server.request("/api/auth/me", {
             method: "GET",
@@ -261,61 +245,4 @@ describe("integration auth", () => {
          expect(await $fns.me()).toEqual({ user: null as any });
       }
    });
-
-   it("should register users with default role", async () => {
-      const app = createAuthApp({ default_role_register: "guest" });
-      await app.build();
-      const $fns = fns(app);
-
-      // takes default role
-      expect(
-         await app
-            .createUser({
-               email: "test@bknd.io",
-               password: "12345678",
-            })
-            .then((r) => r.role),
-      ).toBe("guest");
-
-      // throws error if role doesn't exist
-      expect(
-         app.createUser({
-            email: "test@bknd.io",
-            password: "12345678",
-            role: "doesnt exist",
-         }),
-      ).rejects.toThrow();
-
-      // takes role if provided
-      expect(
-         await app
-            .createUser({
-               email: "test2@bknd.io",
-               password: "12345678",
-               role: "admin",
-            })
-            .then((r) => r.role),
-      ).toBe("admin");
-
-      // registering with role is not allowed
-      expect(
-         await $fns
-            .register({
-               email: "test3@bknd.io",
-               password: "12345678",
-               role: "admin",
-            })
-            .then((r) => r.res.ok),
-      ).toBe(false);
-
-      // takes default role
-      expect(
-         await $fns
-            .register({
-               email: "test3@bknd.io",
-               password: "12345678",
-            })
-            .then((r) => r.data.user.role),
-      ).toBe("guest");
-   });
 });

app/__test__/media/MediaController.spec.ts

@@ -10,7 +10,7 @@ import { assetsPath, assetsTmpPath } from "../helper";
 import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
 
 beforeAll(() => {
-   disableConsoleLog();
+   //disableConsoleLog();
    registries.media.register("local", StorageLocalAdapter);
 });
 afterAll(enableConsoleLog);

app/__test__/modules/AppAuth.spec.ts

@@ -10,6 +10,12 @@ beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
 
 describe("AppAuth", () => {
+   test.skip("...", () => {
+      const auth = new AppAuth({});
+      console.log(auth.toJSON());
+      console.log(auth.config);
+   });
+
    moduleTestSuite(AppAuth);
 
    let ctx: ModuleBuildContext;
@@ -33,9 +39,11 @@ describe("AppAuth", () => {
       await auth.build();
 
       const oldConfig = auth.toJSON(true);
+      //console.log(oldConfig);
       await auth.schema().patch("enabled", true);
       await auth.build();
       const newConfig = auth.toJSON(true);
+      //console.log(newConfig);
       expect(newConfig.jwt.secret).not.toBe(oldConfig.jwt.secret);
    });
 
@@ -61,6 +69,7 @@ describe("AppAuth", () => {
       const app = new AuthController(auth).getController();
 
       {
+         disableConsoleLog();
          const res = await app.request("/password/register", {
             method: "POST",
             headers: {
@@ -71,6 +80,7 @@ describe("AppAuth", () => {
                password: "12345678",
             }),
          });
+         enableConsoleLog();
          expect(res.status).toBe(200);
 
          const { data: users } = await ctx.em.repository("users").findMany();
@@ -109,6 +119,7 @@ describe("AppAuth", () => {
       const app = new AuthController(auth).getController();
 
       {
+         disableConsoleLog();
          const res = await app.request("/password/register", {
             method: "POST",
             headers: {
@@ -119,6 +130,7 @@ describe("AppAuth", () => {
                password: "12345678",
             }),
          });
+         enableConsoleLog();
          expect(res.status).toBe(200);
 
          const { data: users } = await ctx.em.repository("users").findMany();
@@ -223,32 +235,4 @@ describe("AppAuth", () => {
          }
       }
    });
-
-   test("default role for registration must be a valid role", async () => {
-      const app = createApp({
-         config: {
-            auth: {
-               enabled: true,
-               jwt: {
-                  secret: "123456",
-               },
-               allow_register: true,
-               roles: {
-                  guest: {
-                     is_default: true,
-                  },
-               },
-            },
-         },
-      });
-
-      await app.build();
-
-      const auth = app.module.auth;
-      // doesn't allow invalid role
-      expect(auth.schema().patch("default_role_register", "admin")).rejects.toThrow();
-      // allows valid role
-      await auth.schema().patch("default_role_register", "guest");
-      expect(auth.toJSON().default_role_register).toBe("guest");
-   });
 });

app/__test__/modules/AppMedia.spec.ts

@@ -1,14 +1,10 @@
-import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import { createApp } from "core/test/utils";
 import { em, entity, text } from "data/prototype";
 import { registries } from "modules/registries";
 import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
 import { AppMedia } from "../../src/media/AppMedia";
 import { moduleTestSuite } from "./module-test-suite";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
 
 describe("AppMedia", () => {
    test.skip("...", () => {

app/__test__/modules/DbModuleManager.spec.ts

@@ -1,11 +1,7 @@
-import { it, expect, describe, beforeAll, afterAll } from "bun:test";
+import { it, expect, describe } from "bun:test";
 import { DbModuleManager } from "modules/db/DbModuleManager";
 import { getDummyConnection } from "../helper";
 import { TABLE_NAME } from "modules/db/migrations";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
 
 describe("DbModuleManager", () => {
    it("should extract secrets", async () => {

app/__test__/modules/ModuleManager.spec.ts

@@ -11,7 +11,7 @@ import { s, stripMark } from "core/utils/schema";
 import { Connection } from "data/connection/Connection";
 import { entity, text } from "data/prototype";
 
-beforeAll(() => disableConsoleLog());
+beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
 
 describe("ModuleManager", async () => {
@@ -82,6 +82,7 @@ describe("ModuleManager", async () => {
             },
          },
       } as any;
+      //const { version, ...json } = mm.toJSON() as any;
 
       const { dummyConnection } = getDummyConnection();
       const db = dummyConnection.kysely;
@@ -96,6 +97,10 @@ describe("ModuleManager", async () => {
 
       await mm2.build();
 
+      /* console.log({
+         json,
+         configs: mm2.configs(),
+      }); */
       //expect(stripMark(json)).toEqual(stripMark(mm2.configs()));
       expect(mm2.configs().data.entities?.test).toBeDefined();
       expect(mm2.configs().data.entities?.test?.fields?.content).toBeDefined();
@@ -223,6 +228,8 @@ describe("ModuleManager", async () => {
       const c = getDummyConnection();
       const mm = new ModuleManager(c.dummyConnection);
       await mm.build();
+      console.log("==".repeat(30));
+      console.log("");
       const json = mm.configs();
 
       const c2 = getDummyConnection();
@@ -268,6 +275,7 @@ describe("ModuleManager", async () => {
          }
 
          override async build() {
+            //console.log("building FailingModule", this.config);
             if (this.config.value && this.config.value < 0) {
                throw new Error("value must be positive, given: " + this.config.value);
             }
@@ -288,6 +296,9 @@ describe("ModuleManager", async () => {
          }
       }
 
+      beforeEach(() => disableConsoleLog(["log", "warn", "error"]));
+      afterEach(enableConsoleLog);
+
       test("it builds", async () => {
          const { dummyConnection } = getDummyConnection();
          const mm = new TestModuleManager(dummyConnection);

app/build.ts

@@ -2,8 +2,6 @@ import { $ } from "bun";
 import * as tsup from "tsup";
 import pkg from "./package.json" with { type: "json" };
 import c from "picocolors";
-import { watch as fsWatch } from "node:fs";
-import { join } from "node:path";
 
 const args = process.argv.slice(2);
 const watch = args.includes("--watch");
@@ -85,8 +83,7 @@ async function buildApi() {
    await tsup.build({
       minify,
       sourcemap,
-      // don't use tsup's broken watch, we'll handle it ourselves
-      watch: false,
+      watch,
       define,
       entry: [
          "src/index.ts",
@@ -124,7 +121,7 @@ async function buildUi() {
    const base = {
       minify,
       sourcemap,
-      watch: false,
+      watch,
       define,
       external: [
          ...external,
@@ -183,15 +180,12 @@ async function buildUiElements() {
    await tsup.build({
       minify,
       sourcemap,
-      watch: false,
+      watch,
       define,
       entry: ["src/ui/elements/index.ts"],
       outDir: "dist/ui/elements",
       external: [
          "ui/client",
-         "bknd",
-         /^bknd\/.*/,
-         "wouter",
          "react",
          "react-dom",
          "react/jsx-runtime",
@@ -228,7 +222,7 @@ function baseConfig(adapter: string, overrides: Partial<tsup.Options> = {}): tsu
    return {
       minify,
       sourcemap,
-      watch: false,
+      watch,
       entry: [`src/adapter/${adapter}/index.ts`],
       format: ["esm"],
       platform: "neutral",
@@ -271,11 +265,6 @@ async function buildAdapters() {
 
       // specific adatpers
       tsup.build(baseConfig("react-router")),
-      tsup.build(
-         baseConfig("browser", {
-            external: [/^sqlocal\/?.*?/, "wouter"],
-         }),
-      ),
       tsup.build(
          baseConfig("bun", {
             external: [/^bun\:.*/],
@@ -308,11 +297,6 @@ async function buildAdapters() {
          platform: "node",
       }),
 
-      tsup.build({
-         ...baseConfig("sveltekit"),
-         platform: "node",
-      }),
-
       tsup.build({
          ...baseConfig("node"),
          platform: "node",
@@ -343,48 +327,4 @@ async function buildAdapters() {
    ]);
 }
 
-async function buildAll() {
-   await Promise.all([buildApi(), buildUi(), buildUiElements(), buildAdapters()]);
-}
-
-// initial build
-await buildAll();
-
-// custom watcher since tsup's watch is broken in 8.3.5+
-if (watch) {
-   oldConsole.log(c.cyan("[Watch]"), "watching for changes in src/...");
-
-   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
-   let isBuilding = false;
-
-   const rebuild = async () => {
-      if (isBuilding) return;
-      isBuilding = true;
-      oldConsole.log(c.cyan("[Watch]"), "rebuilding...");
-      try {
-         await buildAll();
-         oldConsole.log(c.cyan("[Watch]"), c.green("done"));
-      } catch (e) {
-         oldConsole.warn(c.cyan("[Watch]"), c.red("build failed"), e);
-      }
-      isBuilding = false;
-   };
-
-   const debouncedRebuild = () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(rebuild, 100);
-   };
-
-   // watch src directory recursively
-   fsWatch(join(import.meta.dir, "src"), { recursive: true }, (event, filename) => {
-      if (!filename) return;
-      // ignore non-source files
-      if (!filename.endsWith(".ts") && !filename.endsWith(".tsx") && !filename.endsWith(".css"))
-         return;
-      oldConsole.log(c.cyan("[Watch]"), c.dim(`${event}: ${filename}`));
-      debouncedRebuild();
-   });
-
-   // keep process alive
-   await new Promise(() => {});
-}
+await Promise.all([buildApi(), buildUi(), buildUiElements(), buildAdapters()]);

app/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "sideEffects": false,
   "bin": "./dist/cli/index.js",
-  "version": "0.20.0",
+  "version": "0.19.0",
   "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": {
@@ -65,7 +65,7 @@
     "hono": "4.10.4",
     "json-schema-library": "10.0.0-rc7",
     "json-schema-to-ts": "^3.1.1",
-    "jsonv-ts": "^0.10.1",
+    "jsonv-ts": "0.9.3",
     "kysely": "0.28.8",
     "lodash-es": "^4.17.21",
     "oauth4webapi": "^2.11.1",
@@ -99,7 +99,6 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.2.0",
     "@types/node": "^24.10.0",
-    "@types/pg": "^8.15.6",
     "@types/react": "^19.0.10",
     "@types/react-dom": "^19.0.4",
     "@vitejs/plugin-react": "^5.1.0",
@@ -111,17 +110,14 @@
     "jotai": "^2.12.2",
     "jsdom": "^26.1.0",
     "kysely-generic-sqlite": "^1.2.1",
-    "kysely-postgres-js": "^2.0.0",
     "libsql": "^0.5.22",
     "libsql-stateless-easy": "^1.8.0",
     "miniflare": "^4.20251011.2",
     "open": "^10.2.0",
     "openapi-types": "^12.1.3",
-    "pg": "^8.16.3",
     "postcss": "^8.5.3",
     "postcss-preset-mantine": "^1.18.0",
     "postcss-simple-vars": "^7.0.1",
-    "postgres": "^3.4.7",
     "posthog-js-lite": "^3.6.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
@@ -129,7 +125,6 @@
     "react-icons": "5.5.0",
     "react-json-view-lite": "^2.5.0",
     "sql-formatter": "^15.6.10",
-    "sqlocal": "^0.16.0",
     "tailwind-merge": "^3.0.2",
     "tailwindcss": "^4.1.16",
     "tailwindcss-animate": "^1.0.7",
@@ -253,21 +248,11 @@
       "import": "./dist/adapter/astro/index.js",
       "require": "./dist/adapter/astro/index.js"
     },
-    "./adapter/sveltekit": {
-      "types": "./dist/types/adapter/sveltekit/index.d.ts",
-      "import": "./dist/adapter/sveltekit/index.js",
-      "require": "./dist/adapter/sveltekit/index.js"
-    },
     "./adapter/aws": {
       "types": "./dist/types/adapter/aws/index.d.ts",
       "import": "./dist/adapter/aws/index.js",
       "require": "./dist/adapter/aws/index.js"
     },
-    "./adapter/browser": {
-      "types": "./dist/types/adapter/browser/index.d.ts",
-      "import": "./dist/adapter/browser/index.js",
-      "require": "./dist/adapter/browser/index.js"
-    },
     "./dist/main.css": "./dist/ui/main.css",
     "./dist/styles.css": "./dist/ui/styles.css",
     "./dist/manifest.json": "./dist/static/.vite/manifest.json",
@@ -285,7 +270,6 @@
       "adapter/react-router": ["./dist/types/adapter/react-router/index.d.ts"],
       "adapter/bun": ["./dist/types/adapter/bun/index.d.ts"],
       "adapter/node": ["./dist/types/adapter/node/index.d.ts"],
-      "adapter/sveltekit": ["./dist/types/adapter/sveltekit/index.d.ts"],
       "adapter/sqlite": ["./dist/types/adapter/sqlite/edge.d.ts"]
     }
   },
@@ -315,8 +299,6 @@
     "remix",
     "react-router",
     "astro",
-    "sveltekit",
-    "svelte",
     "bun",
     "node"
   ]

app/src/Api.ts

@@ -61,7 +61,7 @@ export class Api {
    private token?: string;
    private user?: TApiUser;
    private verified = false;
-   public token_transport: "header" | "cookie" | "none" = "header";
+   private token_transport: "header" | "cookie" | "none" = "header";
 
    public system!: SystemApi;
    public data!: DataApi;

app/src/adapter/browser/BkndBrowserApp.tsx

@@ -1,153 +0,0 @@
-import {
-   createContext,
-   lazy,
-   Suspense,
-   useContext,
-   useEffect,
-   useState,
-   type ReactNode,
-} from "react";
-import { checksum } from "bknd/utils";
-import { App, registries, sqlocal, type BkndConfig } from "bknd";
-import { Route, Router, Switch } from "wouter";
-import { ClientProvider } from "bknd/client";
-import { SQLocalKysely } from "sqlocal/kysely";
-import type { ClientConfig, DatabasePath } from "sqlocal";
-import { OpfsStorageAdapter } from "bknd/adapter/browser";
-import type { BkndAdminConfig } from "bknd/ui";
-
-const Admin = lazy(() =>
-   Promise.all([
-      import("bknd/ui"),
-      // @ts-ignore
-      import("bknd/dist/styles.css"),
-   ]).then(([mod]) => ({
-      default: mod.Admin,
-   })),
-);
-
-function safeViewTransition(fn: () => void) {
-   if (document.startViewTransition) {
-      document.startViewTransition(fn);
-   } else {
-      fn();
-   }
-}
-
-export type BrowserBkndConfig<Args = ImportMetaEnv> = Omit<
-   BkndConfig<Args>,
-   "connection" | "app"
-> & {
-   adminConfig?: BkndAdminConfig;
-   connection?: ClientConfig | DatabasePath;
-};
-
-export type BkndBrowserAppProps = {
-   children: ReactNode;
-   header?: ReactNode;
-   loading?: ReactNode;
-   notFound?: ReactNode;
-} & BrowserBkndConfig;
-
-const BkndBrowserAppContext = createContext<{
-   app: App;
-   hash: string;
-}>(undefined!);
-
-export function BkndBrowserApp({
-   children,
-   adminConfig,
-   header,
-   loading,
-   notFound,
-   ...config
-}: BkndBrowserAppProps) {
-   const [app, setApp] = useState<App | undefined>(undefined);
-   const [hash, setHash] = useState<string>("");
-   const adminRoutePath = (adminConfig?.basepath ?? "") + "/*?";
-
-   async function onBuilt(app: App) {
-      safeViewTransition(async () => {
-         setApp(app);
-         setHash(await checksum(app.toJSON()));
-      });
-   }
-
-   useEffect(() => {
-      setup({ ...config, adminConfig })
-         .then((app) => onBuilt(app as any))
-         .catch(console.error);
-   }, []);
-
-   if (!app) {
-      return (
-         loading ?? (
-            <Center>
-               <span style={{ opacity: 0.2 }}>Loading...</span>
-            </Center>
-         )
-      );
-   }
-
-   return (
-      <BkndBrowserAppContext.Provider value={{ app, hash }}>
-         <ClientProvider storage={window.localStorage} fetcher={app.server.request}>
-            {header}
-            <Router key={hash}>
-               <Switch>
-                  {children}
-
-                  <Route path={adminRoutePath}>
-                     <Suspense>
-                        <Admin config={adminConfig} />
-                     </Suspense>
-                  </Route>
-                  <Route path="*">
-                     {notFound ?? (
-                        <Center style={{ fontSize: "48px", fontFamily: "monospace" }}>404</Center>
-                     )}
-                  </Route>
-               </Switch>
-            </Router>
-         </ClientProvider>
-      </BkndBrowserAppContext.Provider>
-   );
-}
-
-export function useApp() {
-   return useContext(BkndBrowserAppContext);
-}
-
-const Center = (props: React.HTMLAttributes<HTMLDivElement>) => (
-   <div
-      {...props}
-      style={{
-         width: "100%",
-         minHeight: "100vh",
-         display: "flex",
-         justifyContent: "center",
-         alignItems: "center",
-         ...(props.style ?? {}),
-      }}
-   />
-);
-
-let initialized = false;
-async function setup(config: BrowserBkndConfig = {}) {
-   if (initialized) return;
-   initialized = true;
-
-   registries.media.register("opfs", OpfsStorageAdapter);
-
-   const app = App.create({
-      ...config,
-      // @ts-ignore
-      connection: sqlocal(new SQLocalKysely(config.connection ?? ":localStorage:")),
-   });
-
-   await config.beforeBuild?.(app);
-   await app.build({ sync: true });
-   await config.onBuilt?.(app);
-
-   return app;
-}

app/src/adapter/browser/OpfsStorageAdapter.spec.ts

@@ -1,34 +0,0 @@
-import { describe, beforeAll, vi, afterAll, spyOn } from "bun:test";
-import { OpfsStorageAdapter } from "./OpfsStorageAdapter";
-// @ts-ignore
-import { assetsPath } from "../../../__test__/helper";
-import { adapterTestSuite } from "media/storage/adapters/adapter-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-import { MockFileSystemDirectoryHandle } from "adapter/browser/mock";
-
-describe("OpfsStorageAdapter", async () => {
-   let mockRoot: MockFileSystemDirectoryHandle;
-   let testSuiteAdapter: OpfsStorageAdapter;
-
-   const _mock = spyOn(global, "navigator");
-
-   beforeAll(() => {
-      // mock navigator.storage.getDirectory()
-      mockRoot = new MockFileSystemDirectoryHandle("opfs-root");
-      const mockNavigator = {
-         storage: {
-            getDirectory: vi.fn().mockResolvedValue(mockRoot),
-         },
-      };
-      // @ts-ignore
-      _mock.mockReturnValue(mockNavigator);
-      testSuiteAdapter = new OpfsStorageAdapter();
-   });
-
-   afterAll(() => {
-      _mock.mockRestore();
-   });
-
-   const file = Bun.file(`${assetsPath}/image.png`);
-   await adapterTestSuite(bunTestRunner, () => testSuiteAdapter, file);
-});

app/src/adapter/browser/OpfsStorageAdapter.ts

@@ -1,265 +0,0 @@
-import type { FileBody, FileListObject, FileMeta, FileUploadPayload } from "bknd";
-import { StorageAdapter, guessMimeType } from "bknd";
-import { parse, s, isFile, isBlob } from "bknd/utils";
-
-export const opfsAdapterConfig = s.object(
-   {
-      root: s.string({ default: "" }).optional(),
-   },
-   {
-      title: "OPFS",
-      description: "Origin Private File System storage",
-      additionalProperties: false,
-   },
-);
-export type OpfsAdapterConfig = s.Static<typeof opfsAdapterConfig>;
-
-/**
- * Storage adapter for OPFS (Origin Private File System)
- * Provides browser-based file storage using the File System Access API
- */
-export class OpfsStorageAdapter extends StorageAdapter {
-   private config: OpfsAdapterConfig;
-   private rootPromise: Promise<FileSystemDirectoryHandle>;
-
-   constructor(config: Partial<OpfsAdapterConfig> = {}) {
-      super();
-      this.config = parse(opfsAdapterConfig, config);
-      this.rootPromise = this.initializeRoot();
-   }
-
-   private async initializeRoot(): Promise<FileSystemDirectoryHandle> {
-      const opfsRoot = await navigator.storage.getDirectory();
-      if (!this.config.root) {
-         return opfsRoot;
-      }
-
-      // navigate to or create nested directory structure
-      const parts = this.config.root.split("/").filter(Boolean);
-      let current = opfsRoot;
-      for (const part of parts) {
-         current = await current.getDirectoryHandle(part, { create: true });
-      }
-      return current;
-   }
-
-   getSchema() {
-      return opfsAdapterConfig;
-   }
-
-   getName(): string {
-      return "opfs";
-   }
-
-   async listObjects(prefix?: string): Promise<FileListObject[]> {
-      const root = await this.rootPromise;
-      const files: FileListObject[] = [];
-
-      for await (const [name, handle] of root.entries()) {
-         if (handle.kind === "file") {
-            if (!prefix || name.startsWith(prefix)) {
-               const file = await (handle as FileSystemFileHandle).getFile();
-               files.push({
-                  key: name,
-                  last_modified: new Date(file.lastModified),
-                  size: file.size,
-               });
-            }
-         }
-      }
-
-      return files;
-   }
-
-   private async computeEtagFromArrayBuffer(buffer: ArrayBuffer): Promise<string> {
-      const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
-      const hashArray = Array.from(new Uint8Array(hashBuffer));
-      const hashHex = hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
-
-      // wrap the hex string in quotes for ETag format
-      return `"${hashHex}"`;
-   }
-
-   async putObject(key: string, body: FileBody): Promise<string | FileUploadPayload> {
-      if (body === null) {
-         throw new Error("Body is empty");
-      }
-
-      const root = await this.rootPromise;
-      const fileHandle = await root.getFileHandle(key, { create: true });
-      const writable = await fileHandle.createWritable();
-
-      try {
-         let contentBuffer: ArrayBuffer;
-
-         if (isFile(body)) {
-            contentBuffer = await body.arrayBuffer();
-            await writable.write(contentBuffer);
-         } else if (body instanceof ReadableStream) {
-            const chunks: Uint8Array[] = [];
-            const reader = body.getReader();
-            try {
-               while (true) {
-                  const { done, value } = await reader.read();
-                  if (done) break;
-                  chunks.push(value);
-                  await writable.write(value);
-               }
-            } finally {
-               reader.releaseLock();
-            }
-            // compute total size and combine chunks for etag
-            const totalSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-            const combined = new Uint8Array(totalSize);
-            let offset = 0;
-            for (const chunk of chunks) {
-               combined.set(chunk, offset);
-               offset += chunk.length;
-            }
-            contentBuffer = combined.buffer;
-         } else if (isBlob(body)) {
-            contentBuffer = await (body as Blob).arrayBuffer();
-            await writable.write(contentBuffer);
-         } else {
-            // body is ArrayBuffer or ArrayBufferView
-            if (ArrayBuffer.isView(body)) {
-               const view = body as ArrayBufferView;
-               contentBuffer = view.buffer.slice(
-                  view.byteOffset,
-                  view.byteOffset + view.byteLength,
-               ) as ArrayBuffer;
-            } else {
-               contentBuffer = body as ArrayBuffer;
-            }
-            await writable.write(body);
-         }
-
-         await writable.close();
-         return await this.computeEtagFromArrayBuffer(contentBuffer);
-      } catch (error) {
-         await writable.abort();
-         throw error;
-      }
-   }
-
-   async deleteObject(key: string): Promise<void> {
-      try {
-         const root = await this.rootPromise;
-         await root.removeEntry(key);
-      } catch {
-         // file doesn't exist, which is fine
-      }
-   }
-
-   async objectExists(key: string): Promise<boolean> {
-      try {
-         const root = await this.rootPromise;
-         await root.getFileHandle(key);
-         return true;
-      } catch {
-         return false;
-      }
-   }
-
-   private parseRangeHeader(
-      rangeHeader: string,
-      fileSize: number,
-   ): { start: number; end: number } | null {
-      // parse "bytes=start-end" format
-      const match = rangeHeader.match(/^bytes=(\d*)-(\d*)$/);
-      if (!match) return null;
-
-      const [, startStr, endStr] = match;
-      let start = startStr ? Number.parseInt(startStr, 10) : 0;
-      let end = endStr ? Number.parseInt(endStr, 10) : fileSize - 1;
-
-      // handle suffix-byte-range-spec (e.g., "bytes=-500")
-      if (!startStr && endStr) {
-         start = Math.max(0, fileSize - Number.parseInt(endStr, 10));
-         end = fileSize - 1;
-      }
-
-      // validate range
-      if (start < 0 || end >= fileSize || start > end) {
-         return null;
-      }
-
-      return { start, end };
-   }
-
-   async getObject(key: string, headers: Headers): Promise<Response> {
-      try {
-         const root = await this.rootPromise;
-         const fileHandle = await root.getFileHandle(key);
-         const file = await fileHandle.getFile();
-         const fileSize = file.size;
-         const mimeType = guessMimeType(key);
-
-         const responseHeaders = new Headers({
-            "Accept-Ranges": "bytes",
-            "Content-Type": mimeType || "application/octet-stream",
-         });
-
-         const rangeHeader = headers.get("range");
-
-         if (rangeHeader) {
-            const range = this.parseRangeHeader(rangeHeader, fileSize);
-
-            if (!range) {
-               // invalid range - return 416 Range Not Satisfiable
-               responseHeaders.set("Content-Range", `bytes */${fileSize}`);
-               return new Response("", {
-                  status: 416,
-                  headers: responseHeaders,
-               });
-            }
-
-            const { start, end } = range;
-            const arrayBuffer = await file.arrayBuffer();
-            const chunk = arrayBuffer.slice(start, end + 1);
-
-            responseHeaders.set("Content-Range", `bytes ${start}-${end}/${fileSize}`);
-            responseHeaders.set("Content-Length", chunk.byteLength.toString());
-
-            return new Response(chunk, {
-               status: 206, // Partial Content
-               headers: responseHeaders,
-            });
-         } else {
-            // normal request - return entire file
-            const content = await file.arrayBuffer();
-            responseHeaders.set("Content-Length", content.byteLength.toString());
-
-            return new Response(content, {
-               status: 200,
-               headers: responseHeaders,
-            });
-         }
-      } catch {
-         // handle file reading errors
-         return new Response("", { status: 404 });
-      }
-   }
-
-   getObjectUrl(_key: string): string {
-      throw new Error("Method not implemented.");
-   }
-
-   async getObjectMeta(key: string): Promise<FileMeta> {
-      const root = await this.rootPromise;
-      const fileHandle = await root.getFileHandle(key);
-      const file = await fileHandle.getFile();
-
-      return {
-         type: guessMimeType(key) || "application/octet-stream",
-         size: file.size,
-      };
-   }
-
-   toJSON(_secrets?: boolean) {
-      return {
-         type: this.getName(),
-         config: this.config,
-      };
-   }
-}

app/src/adapter/browser/index.ts

@@ -1,2 +0,0 @@
-export * from "./OpfsStorageAdapter";
-export * from "./BkndBrowserApp";

app/src/adapter/browser/mock.ts

@@ -1,136 +0,0 @@
-// mock OPFS API for testing
-class MockFileSystemFileHandle {
-   kind: "file" = "file";
-   name: string;
-   private content: ArrayBuffer;
-   private lastModified: number;
-
-   constructor(name: string, content: ArrayBuffer = new ArrayBuffer(0)) {
-      this.name = name;
-      this.content = content;
-      this.lastModified = Date.now();
-   }
-
-   async getFile(): Promise<File> {
-      return new File([this.content], this.name, {
-         lastModified: this.lastModified,
-         type: this.guessMimeType(),
-      });
-   }
-
-   async createWritable(): Promise<FileSystemWritableFileStream> {
-      const handle = this;
-      return {
-         async write(data: any) {
-            if (data instanceof ArrayBuffer) {
-               handle.content = data;
-            } else if (ArrayBuffer.isView(data)) {
-               handle.content = data.buffer.slice(
-                  data.byteOffset,
-                  data.byteOffset + data.byteLength,
-               ) as ArrayBuffer;
-            } else if (data instanceof Blob) {
-               handle.content = await data.arrayBuffer();
-            }
-            handle.lastModified = Date.now();
-         },
-         async close() {},
-         async abort() {},
-         async seek(_position: number) {},
-         async truncate(_size: number) {},
-      } as FileSystemWritableFileStream;
-   }
-
-   private guessMimeType(): string {
-      const ext = this.name.split(".").pop()?.toLowerCase();
-      const mimeTypes: Record<string, string> = {
-         png: "image/png",
-         jpg: "image/jpeg",
-         jpeg: "image/jpeg",
-         gif: "image/gif",
-         webp: "image/webp",
-         svg: "image/svg+xml",
-         txt: "text/plain",
-         json: "application/json",
-         pdf: "application/pdf",
-      };
-      return mimeTypes[ext || ""] || "application/octet-stream";
-   }
-}
-
-export class MockFileSystemDirectoryHandle {
-   kind: "directory" = "directory";
-   name: string;
-   private files: Map<string, MockFileSystemFileHandle> = new Map();
-   private directories: Map<string, MockFileSystemDirectoryHandle> = new Map();
-
-   constructor(name: string = "root") {
-      this.name = name;
-   }
-
-   async getFileHandle(
-      name: string,
-      options?: FileSystemGetFileOptions,
-   ): Promise<FileSystemFileHandle> {
-      if (this.files.has(name)) {
-         return this.files.get(name) as any;
-      }
-      if (options?.create) {
-         const handle = new MockFileSystemFileHandle(name);
-         this.files.set(name, handle);
-         return handle as any;
-      }
-      throw new Error(`File not found: ${name}`);
-   }
-
-   async getDirectoryHandle(
-      name: string,
-      options?: FileSystemGetDirectoryOptions,
-   ): Promise<FileSystemDirectoryHandle> {
-      if (this.directories.has(name)) {
-         return this.directories.get(name) as any;
-      }
-      if (options?.create) {
-         const handle = new MockFileSystemDirectoryHandle(name);
-         this.directories.set(name, handle);
-         return handle as any;
-      }
-      throw new Error(`Directory not found: ${name}`);
-   }
-
-   async removeEntry(name: string, _options?: FileSystemRemoveOptions): Promise<void> {
-      this.files.delete(name);
-      this.directories.delete(name);
-   }
-
-   async *entries(): AsyncIterableIterator<[string, FileSystemHandle]> {
-      for (const [name, handle] of this.files) {
-         yield [name, handle as any];
-      }
-      for (const [name, handle] of this.directories) {
-         yield [name, handle as any];
-      }
-   }
-
-   async *keys(): AsyncIterableIterator<string> {
-      for (const name of this.files.keys()) {
-         yield name;
-      }
-      for (const name of this.directories.keys()) {
-         yield name;
-      }
-   }
-
-   async *values(): AsyncIterableIterator<FileSystemHandle> {
-      for (const handle of this.files.values()) {
-         yield handle as any;
-      }
-      for (const handle of this.directories.values()) {
-         yield handle as any;
-      }
-   }
-
-   [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileSystemHandle]> {
-      return this.entries();
-   }
-}

app/src/adapter/node/node.adapter.vi-test.ts

@@ -1,4 +1,4 @@
-import { describe } from "vitest";
+import { describe, beforeAll, afterAll } from "vitest";
 import * as node from "./node.adapter";
 import { adapterTestSuite } from "adapter/adapter-test-suite";
 import { viTestRunner } from "adapter/node/vitest";

app/src/adapter/sveltekit/index.ts

@@ -1 +0,0 @@
-export * from "./sveltekit.adapter";

app/src/adapter/sveltekit/sveltekit.adapter.spec.ts

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

app/src/adapter/sveltekit/sveltekit.adapter.ts

@@ -1,33 +0,0 @@
-import { createRuntimeApp, type RuntimeBkndConfig } from "bknd/adapter";
-
-type TSvelteKit = {
-   request: Request;
-};
-
-export type SvelteKitBkndConfig<Env> = Pick<RuntimeBkndConfig<Env>, "adminOptions">;
-
-/**
- * Get bknd app instance
- * @param config - bknd configuration
- * @param args - environment variables (use $env/dynamic/private for universal runtime support)
- */
-export async function getApp<Env>(
-   config: SvelteKitBkndConfig<Env> = {} as SvelteKitBkndConfig<Env>,
-   args: Env,
-) {
-   return await createRuntimeApp(config, args);
-}
-
-/**
- * Create request handler for hooks.server.ts
- * @param config - bknd configuration
- * @param args - environment variables (use $env/dynamic/private for universal runtime support)
- */
-export function serve<Env>(
-   config: SvelteKitBkndConfig<Env> = {} as SvelteKitBkndConfig<Env>,
-   args: Env,
-) {
-   return async (fnArgs: TSvelteKit) => {
-      return (await getApp(config, args)).fetch(fnArgs.request);
-   };
-}

app/src/auth/AppAuth.ts

@@ -46,22 +46,6 @@ export class AppAuth extends Module<AppAuthSchema> {
          to.strategies!.password!.enabled = true;
       }
 
-      if (to.default_role_register && to.default_role_register?.length > 0) {
-         const valid_to_role = Object.keys(to.roles ?? {}).includes(to.default_role_register);
-
-         if (!valid_to_role) {
-            const msg = `Default role for registration not found: ${to.default_role_register}`;
-            // if changing to a new value
-            if (from.default_role_register !== to.default_role_register) {
-               throw new Error(msg);
-            }
-
-            // resetting gracefully, since role doesn't exist anymore
-            $console.warn(`${msg}, resetting to undefined`);
-            to.default_role_register = undefined;
-         }
-      }
-
       return to;
    }
 
@@ -98,7 +82,6 @@ export class AppAuth extends Module<AppAuthSchema> {
       this._authenticator = new Authenticator(strategies, new AppUserPool(this), {
          jwt: this.config.jwt,
          cookie: this.config.cookie,
-         default_role_register: this.config.default_role_register,
       });
 
       this.registerEntities();
@@ -188,20 +171,10 @@ export class AppAuth extends Module<AppAuthSchema> {
       } catch (e) {}
    }
 
-   async createUser({
-      email,
-      password,
-      role,
-      ...additional
-   }: CreateUserPayload): Promise<DB["users"]> {
+   async createUser({ email, password, ...additional }: CreateUserPayload): Promise<DB["users"]> {
       if (!this.enabled) {
          throw new Error("Cannot create user, auth not enabled");
       }
-      if (role) {
-         if (!Object.keys(this.config.roles ?? {}).includes(role)) {
-            throw new Error(`Role "${role}" not found`);
-         }
-      }
 
       const strategy = "password" as const;
       const pw = this.authenticator.strategy(strategy) as PasswordStrategy;
@@ -210,7 +183,6 @@ export class AppAuth extends Module<AppAuthSchema> {
       mutator.__unstable_toggleSystemEntityCreation(false);
       const { data: created } = await mutator.insertOne({
          ...(additional as any),
-         role: role || this.config.default_role_register || undefined,
          email,
          strategy,
          strategy_value,

app/src/auth/api/AuthController.ts

@@ -13,7 +13,6 @@ import {
    InvalidSchemaError,
    transformObject,
    mcpTool,
-   $console,
 } from "bknd/utils";
 import type { PasswordStrategy } from "auth/authenticate/strategies";
 
@@ -211,7 +210,7 @@ export class AuthController extends Controller {
       const idType = s.anyOf([s.number({ title: "Integer" }), s.string({ title: "UUID" })]);
 
       const getUser = async (params: { id?: string | number; email?: string }) => {
-         let user: DB["users"] | undefined;
+         let user: DB["users"] | undefined = undefined;
          if (params.id) {
             const { data } = await this.userRepo.findId(params.id);
             user = data;
@@ -226,33 +225,26 @@ export class AuthController extends Controller {
       };
 
       const roles = Object.keys(this.auth.config.roles ?? {});
-      try {
-         const actions = this.auth.authenticator.strategy("password").getActions();
-         if (actions.create) {
-            const schema = actions.create.schema;
-            mcp.tool(
-               "auth_user_create",
-               {
-                  description: "Create a new user",
-                  inputSchema: s.object({
-                     ...schema.properties,
-                     role: s
-                        .string({
-                           enum: roles.length > 0 ? roles : undefined,
-                        })
-                        .optional(),
-                  }),
-               },
-               async (params, c) => {
-                  await c.context.ctx().helper.granted(c, AuthPermissions.createUser);
+      mcp.tool(
+         "auth_user_create",
+         {
+            description: "Create a new user",
+            inputSchema: s.object({
+               email: s.string({ format: "email" }),
+               password: s.string({ minLength: 8 }),
+               role: s
+                  .string({
+                     enum: roles.length > 0 ? roles : undefined,
+                  })
+                  .optional(),
+            }),
+         },
+         async (params, c) => {
+            await c.context.ctx().helper.granted(c, AuthPermissions.createUser);
 
-                  return c.json(await this.auth.createUser(params));
-               },
-            );
-         }
-      } catch (e) {
-         $console.warn("error creating auth_user_create tool", e);
-      }
+            return c.json(await this.auth.createUser(params));
+         },
+      );
 
       mcp.tool(
          "auth_user_token",

app/src/auth/auth-schema.ts

@@ -51,7 +51,6 @@ export const authConfigSchema = $object(
       basepath: s.string({ default: "/api/auth" }),
       entity_name: s.string({ default: "users" }),
       allow_register: s.boolean({ default: true }).optional(),
-      default_role_register: s.string().optional(),
       jwt: jwtConfig,
       cookie: cookieConfig,
       strategies: $record(

app/src/auth/authenticate/Authenticator.ts

@@ -74,7 +74,6 @@ export const jwtConfig = s.strictObject(
 export const authenticatorConfig = s.object({
    jwt: jwtConfig,
    cookie: cookieConfig,
-   default_role_register: s.string().optional(),
 });
 
 type AuthConfig = s.Static<typeof authenticatorConfig>;
@@ -165,13 +164,9 @@ export class Authenticator<
          if (!("strategy_value" in profile)) {
             throw new InvalidConditionsException("Profile must have a strategy value");
          }
-         if ("role" in profile) {
-            throw new InvalidConditionsException("Role cannot be provided during registration");
-         }
 
          const user = await this.userPool.create(strategy.getName(), {
             ...profile,
-            role: this.config.default_role_register,
             strategy_value: profile.strategy_value,
          });
 

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

@@ -10,7 +10,6 @@ const schema = s
    .object({
       hashing: s.string({ enum: ["plain", "sha256", "bcrypt"], default: "sha256" }),
       rounds: s.number({ minimum: 1, maximum: 10 }).optional(),
-      minLength: s.number({ default: 8, minimum: 1 }).optional(),
    })
    .strict();
 
@@ -38,7 +37,7 @@ export class PasswordStrategy extends AuthStrategy<typeof schema> {
             format: "email",
          }),
          password: s.string({
-            minLength: this.config.minLength,
+            minLength: 8, // @todo: this should be configurable
          }),
       });
    }
@@ -66,21 +65,12 @@ export class PasswordStrategy extends AuthStrategy<typeof schema> {
             return await bcryptCompare(compare, actual);
       }
 
-      return actual === compare;
+      return false;
    }
 
    verify(password: string) {
       return async (user: User) => {
-         if (!user || !user.strategy_value) {
-            throw new InvalidCredentialsException();
-         }
-
-         if (!this.getPayloadSchema().properties.password.validate(password).valid) {
-            $console.debug("PasswordStrategy: Invalid password", password);
-            throw new InvalidCredentialsException();
-         }
-
-         const compare = await this.compare(user.strategy_value, password);
+         const compare = await this.compare(user?.strategy_value!, password);
          if (compare !== true) {
             throw new InvalidCredentialsException();
          }

app/src/core/env.ts

@@ -8,7 +8,7 @@ export function isDebug(): boolean {
    try {
       // @ts-expect-error - this is a global variable in dev
       return is_toggled(__isDev);
-   } catch (_e) {
+   } catch (e) {
       return false;
    }
 }

app/src/core/server/flash.ts

@@ -32,7 +32,6 @@ export function getFlashMessage(
 ): { type: FlashMessageType; message: string } | undefined {
    const flash = getCookieValue(flash_key);
    if (flash && clear) {
-      // biome-ignore lint/suspicious/noDocumentCookie: .
       document.cookie = `${flash_key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
    }
    return flash ? JSON.parse(flash) : undefined;

app/src/core/utils/objects.ts

@@ -14,9 +14,9 @@ export function isObject(value: unknown): value is Record<string, unknown> {
 
 export function omitKeys<T extends object, K extends keyof T>(
    obj: T,
-   keys_: readonly K[] | K[] | string[],
+   keys_: readonly K[],
 ): Omit<T, Extract<K, keyof T>> {
-   const keys = new Set(keys_ as readonly K[]);
+   const keys = new Set(keys_);
    const result = {} as Omit<T, Extract<K, keyof T>>;
    for (const [key, value] of Object.entries(obj) as [keyof T, T[keyof T]][]) {
       if (!keys.has(key as K)) {

app/src/core/utils/runtime.ts

@@ -1,4 +1,3 @@
-import type { MaybePromise } from "core/types";
 import { getRuntimeKey as honoGetRuntimeKey } from "hono/adapter";
 
 /**
@@ -94,21 +93,3 @@ export async function threwAsync(fn: Promise<any>, instance?: new (...args: any[
       return true;
    }
 }
-
-export async function $waitUntil(
-   message: string,
-   condition: () => MaybePromise<boolean>,
-   delay = 100,
-   maxAttempts = 10,
-) {
-   let attempts = 0;
-   while (attempts < maxAttempts) {
-      if (await condition()) {
-         return;
-      }
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      attempts++;
-   }
-
-   throw new Error(`$waitUntil: "${message}" failed after ${maxAttempts} attempts`);
-}

app/src/data/api/DataController.ts

@@ -96,9 +96,6 @@ export class DataController extends Controller {
       // read entity schema
       hono.get(
          "/schema.json",
-         permission(SystemPermissions.schemaRead, {
-            context: (_c) => ({ module: "data" }),
-         }),
          permission(DataPermissions.entityRead, {
             context: (c) => ({ entity: c.req.param("entity") }),
          }),
@@ -127,9 +124,6 @@ export class DataController extends Controller {
       // read schema
       hono.get(
          "/schemas/:entity/:context?",
-         permission(SystemPermissions.schemaRead, {
-            context: (_c) => ({ module: "data" }),
-         }),
          permission(DataPermissions.entityRead, {
             context: (c) => ({ entity: c.req.param("entity") }),
          }),
@@ -167,7 +161,7 @@ export class DataController extends Controller {
       hono.get(
          "/types",
          permission(SystemPermissions.schemaRead, {
-            context: (_c) => ({ module: "data" }),
+            context: (c) => ({ module: "data" }),
          }),
          describeRoute({
             summary: "Retrieve data typescript definitions",
@@ -188,9 +182,6 @@ export class DataController extends Controller {
        */
       hono.get(
          "/info/:entity",
-         permission(SystemPermissions.schemaRead, {
-            context: (_c) => ({ module: "data" }),
-         }),
          permission(DataPermissions.entityRead, {
             context: (c) => ({ entity: c.req.param("entity") }),
          }),

app/src/data/connection/Connection.ts

@@ -6,12 +6,15 @@ import {
    type CompiledQuery,
    type DatabaseIntrospector,
    type Dialect,
+   type Expression,
    type Kysely,
    type KyselyPlugin,
    type OnModifyForeignAction,
    type QueryResult,
+   type RawBuilder,
    type SelectQueryBuilder,
    type SelectQueryNode,
+   type Simplify,
    sql,
 } from "kysely";
 import type { jsonArrayFrom, jsonBuildObject, jsonObjectFrom } from "kysely/helpers/sqlite";

app/src/data/connection/connection-test-suite.ts

@@ -14,31 +14,27 @@ export function connectionTestSuite(
    {
       makeConnection,
       rawDialectDetails,
-      disableConsoleLog: _disableConsoleLog = true,
    }: {
       makeConnection: () => MaybePromise<{
          connection: Connection;
          dispose: () => MaybePromise<void>;
       }>;
       rawDialectDetails: string[];
-      disableConsoleLog?: boolean;
    },
 ) {
    const { test, expect, describe, beforeEach, afterEach, afterAll, beforeAll } = testRunner;
-   if (_disableConsoleLog) {
-      beforeAll(() => disableConsoleLog());
-      afterAll(() => enableConsoleLog());
-   }
+   beforeAll(() => disableConsoleLog());
+   afterAll(() => enableConsoleLog());
 
-   let ctx: Awaited<ReturnType<typeof makeConnection>>;
-   beforeEach(async () => {
-      ctx = await makeConnection();
-   });
-   afterEach(async () => {
-      await ctx.dispose();
-   });
+   describe("base", () => {
+      let ctx: Awaited<ReturnType<typeof makeConnection>>;
+      beforeEach(async () => {
+         ctx = await makeConnection();
+      });
+      afterEach(async () => {
+         await ctx.dispose();
+      });
 
-   describe("base", async () => {
       test("pings", async () => {
          const res = await ctx.connection.ping();
          expect(res).toBe(true);
@@ -102,54 +98,52 @@ export function connectionTestSuite(
    });
 
    describe("schema", async () => {
-      const makeSchema = async () => {
-         const fields = [
-            {
-               type: "integer",
-               name: "id",
-               primary: true,
-            },
-            {
-               type: "text",
-               name: "text",
-            },
-            {
-               type: "json",
-               name: "json",
-            },
-         ] as const satisfies FieldSpec[];
+      const { connection, dispose } = await makeConnection();
+      afterAll(async () => {
+         await dispose();
+      });
 
-         let b = ctx.connection.kysely.schema.createTable("test");
-         for (const field of fields) {
-            // @ts-expect-error
-            b = b.addColumn(...ctx.connection.getFieldSchema(field));
-         }
-         await b.execute();
+      const fields = [
+         {
+            type: "integer",
+            name: "id",
+            primary: true,
+         },
+         {
+            type: "text",
+            name: "text",
+         },
+         {
+            type: "json",
+            name: "json",
+         },
+      ] as const satisfies FieldSpec[];
 
-         // add index
-         await ctx.connection.kysely.schema
-            .createIndex("test_index")
-            .on("test")
-            .columns(["id"])
-            .execute();
-      };
+      let b = connection.kysely.schema.createTable("test");
+      for (const field of fields) {
+         // @ts-expect-error
+         b = b.addColumn(...connection.getFieldSchema(field));
+      }
+      await b.execute();
+
+      // add index
+      await connection.kysely.schema.createIndex("test_index").on("test").columns(["id"]).execute();
 
       test("executes query", async () => {
-         await makeSchema();
-         await ctx.connection.kysely
+         await connection.kysely
             .insertInto("test")
             .values({ id: 1, text: "test", json: JSON.stringify({ a: 1 }) })
             .execute();
 
          const expected = { id: 1, text: "test", json: { a: 1 } };
 
-         const qb = ctx.connection.kysely.selectFrom("test").selectAll();
-         const res = await ctx.connection.executeQuery(qb);
+         const qb = connection.kysely.selectFrom("test").selectAll();
+         const res = await connection.executeQuery(qb);
          expect(res.rows).toEqual([expected]);
          expect(rawDialectDetails.every((detail) => getPath(res, detail) !== undefined)).toBe(true);
 
          {
-            const res = await ctx.connection.executeQueries(qb, qb);
+            const res = await connection.executeQueries(qb, qb);
             expect(res.length).toBe(2);
             res.map((r) => {
                expect(r.rows).toEqual([expected]);
@@ -161,21 +155,15 @@ export function connectionTestSuite(
       });
 
       test("introspects", async () => {
-         await makeSchema();
-         const tables = await ctx.connection.getIntrospector().getTables({
+         const tables = await connection.getIntrospector().getTables({
             withInternalKyselyTables: false,
          });
          const clean = tables.map((t) => ({
             ...t,
-            columns: t.columns
-               .map((c) => ({
-                  ...c,
-                  // ignore data type
-                  dataType: undefined,
-                  // ignore default value if "id"
-                  hasDefaultValue: c.name !== "id" ? c.hasDefaultValue : undefined,
-               }))
-               .sort((a, b) => a.name.localeCompare(b.name)),
+            columns: t.columns.map((c) => ({
+               ...c,
+               dataType: undefined,
+            })),
          }));
 
          expect(clean).toEqual([
@@ -188,16 +176,7 @@ export function connectionTestSuite(
                      dataType: undefined,
                      isNullable: false,
                      isAutoIncrementing: true,
-                     hasDefaultValue: undefined,
-                     comment: undefined,
-                  },
-                  {
-                     name: "json",
-                     dataType: undefined,
-                     isNullable: true,
-                     isAutoIncrementing: false,
                      hasDefaultValue: false,
-                     comment: undefined,
                   },
                   {
                      name: "text",
@@ -205,26 +184,32 @@ export function connectionTestSuite(
                      isNullable: true,
                      isAutoIncrementing: false,
                      hasDefaultValue: false,
-                     comment: undefined,
                   },
-               ],
-            },
-         ]);
-
-         expect(await ctx.connection.getIntrospector().getIndices()).toEqual([
-            {
-               name: "test_index",
-               table: "test",
-               isUnique: false,
-               columns: [
                   {
-                     name: "id",
-                     order: 0,
+                     name: "json",
+                     dataType: undefined,
+                     isNullable: true,
+                     isAutoIncrementing: false,
+                     hasDefaultValue: false,
                   },
                ],
             },
          ]);
       });
+
+      expect(await connection.getIntrospector().getIndices()).toEqual([
+         {
+            name: "test_index",
+            table: "test",
+            isUnique: false,
+            columns: [
+               {
+                  name: "id",
+                  order: 0,
+               },
+            ],
+         },
+      ]);
    });
 
    describe("integration", async () => {

app/src/data/connection/postgres/PgPostgresConnection.ts

@@ -1,33 +0,0 @@
-import { Kysely, PostgresDialect, type PostgresDialectConfig as KyselyPostgresDialectConfig } from "kysely";
-import { PostgresIntrospector } from "./PostgresIntrospector";
-import { PostgresConnection, plugins } from "./PostgresConnection";
-import { customIntrospector } from "../Connection";
-import type { Pool } from "pg";
-
-export type PostgresDialectConfig = Omit<KyselyPostgresDialectConfig, "pool"> & {
-   pool: Pool;
-};
-
-export class PgPostgresConnection extends PostgresConnection<Pool> {
-   override name = "pg";
-
-   constructor(config: PostgresDialectConfig) {
-      const kysely = new Kysely({
-         dialect: customIntrospector(PostgresDialect, PostgresIntrospector, {
-            excludeTables: [],
-         }).create(config),
-         plugins,
-      });
-
-      super(kysely);
-      this.client = config.pool;
-   }
-
-   override async close(): Promise<void> {
-      await this.client.end();
-   }
-}
-
-export function pg(config: PostgresDialectConfig): PgPostgresConnection {
-   return new PgPostgresConnection(config);
-}

app/src/data/connection/postgres/PostgresJsConnection.ts

@@ -1,31 +0,0 @@
-import { Kysely } from "kysely";
-import { PostgresIntrospector } from "./PostgresIntrospector";
-import { PostgresConnection, plugins } from "./PostgresConnection";
-import { customIntrospector } from "../Connection";
-import { PostgresJSDialect, type PostgresJSDialectConfig } from "kysely-postgres-js";
-
-export class PostgresJsConnection extends PostgresConnection<PostgresJSDialectConfig["postgres"]> {
-   override name = "postgres-js";
-
-   constructor(config: PostgresJSDialectConfig) {
-      const kysely = new Kysely({
-         dialect: customIntrospector(PostgresJSDialect, PostgresIntrospector, {
-            excludeTables: [],
-         }).create(config),
-         plugins,
-      });
-
-      super(kysely);
-      this.client = config.postgres;
-   }
-
-   override async close(): Promise<void> {
-      await this.client.end();
-   }
-}
-
-export function postgresJs(
-   config: PostgresJSDialectConfig,
-): PostgresJsConnection {
-   return new PostgresJsConnection(config);
-}

app/src/data/connection/sqlite/SqliteConnection.ts

@@ -13,43 +13,31 @@ import { customIntrospector } from "../Connection";
 import { SqliteIntrospector } from "./SqliteIntrospector";
 import type { Field } from "data/fields/Field";
 
+// @todo: add pragmas
 export type SqliteConnectionConfig<
    CustomDialect extends Constructor<Dialect> = Constructor<Dialect>,
 > = {
    excludeTables?: string[];
+   dialect: CustomDialect;
+   dialectArgs?: ConstructorParameters<CustomDialect>;
    additionalPlugins?: KyselyPlugin[];
    customFn?: Partial<DbFunctions>;
-} & (
-   | {
-        dialect: CustomDialect;
-        dialectArgs?: ConstructorParameters<CustomDialect>;
-     }
-   | {
-        kysely: Kysely<any>;
-     }
-);
+};
 
 export abstract class SqliteConnection<Client = unknown> extends Connection<Client> {
    override name = "sqlite";
 
    constructor(config: SqliteConnectionConfig) {
-      const { excludeTables, additionalPlugins } = config;
+      const { excludeTables, dialect, dialectArgs = [], additionalPlugins } = config;
       const plugins = [new ParseJSONResultsPlugin(), ...(additionalPlugins ?? [])];
 
-      let kysely: Kysely<any>;
-      if ("dialect" in config) {
-         kysely = new Kysely({
-            dialect: customIntrospector(config.dialect, SqliteIntrospector, {
-               excludeTables,
-               plugins,
-            }).create(...(config.dialectArgs ?? [])),
+      const kysely = new Kysely({
+         dialect: customIntrospector(dialect, SqliteIntrospector, {
+            excludeTables,
             plugins,
-         });
-      } else if ("kysely" in config) {
-         kysely = config.kysely;
-      } else {
-         throw new Error("Either dialect or kysely must be provided");
-      }
+         }).create(...dialectArgs),
+         plugins,
+      });
 
       super(
          kysely,

app/src/data/connection/sqlite/SqliteIntrospector.ts

@@ -83,7 +83,7 @@ export class SqliteIntrospector extends BaseIntrospector {
                   dataType: col.type,
                   isNullable: !col.notnull,
                   isAutoIncrementing: col.name === autoIncrementCol,
-                  hasDefaultValue: col.name === autoIncrementCol ? true : col.dflt_value != null,
+                  hasDefaultValue: col.dflt_value != null,
                   comment: undefined,
                };
             }) ?? [],

app/src/data/connection/sqlite/sqlocal/SQLocalConnection.spec.ts

@@ -1,15 +0,0 @@
-import { describe } from "bun:test";
-import { SQLocalConnection } from "./SQLocalConnection";
-import { connectionTestSuite } from "data/connection/connection-test-suite";
-import { bunTestRunner } from "adapter/bun/test";
-import { SQLocalKysely } from "sqlocal/kysely";
-
-describe("SQLocalConnection", () => {
-   connectionTestSuite(bunTestRunner, {
-      makeConnection: () => ({
-         connection: new SQLocalConnection(new SQLocalKysely({ databasePath: ":memory:" })),
-         dispose: async () => {},
-      }),
-      rawDialectDetails: [],
-   });
-});

app/src/data/connection/sqlite/sqlocal/SQLocalConnection.ts

@@ -1,50 +0,0 @@
-import { Kysely, ParseJSONResultsPlugin } from "kysely";
-import { SqliteConnection } from "../SqliteConnection";
-import { SqliteIntrospector } from "../SqliteIntrospector";
-import type { DB } from "bknd";
-import type { SQLocalKysely } from "sqlocal/kysely";
-
-const plugins = [new ParseJSONResultsPlugin()];
-
-export class SQLocalConnection extends SqliteConnection<SQLocalKysely> {
-   private connected: boolean = false;
-
-   constructor(client: SQLocalKysely) {
-      // @ts-expect-error - config is protected
-      client.config.onConnect = () => {
-         // we need to listen for the connection, it will be awaited in init()
-         this.connected = true;
-      };
-      super({
-         kysely: new Kysely<any>({
-            dialect: {
-               ...client.dialect,
-               createIntrospector: (db: Kysely<DB>) => {
-                  return new SqliteIntrospector(db as any, {
-                     plugins,
-                  });
-               },
-            },
-            plugins,
-         }) as any,
-      });
-      this.client = client;
-   }
-
-   override async init() {
-      if (this.initialized) return;
-      let tries = 0;
-      while (!this.connected && tries < 100) {
-         tries++;
-         await new Promise((resolve) => setTimeout(resolve, 5));
-      }
-      if (!this.connected) {
-         throw new Error("Failed to connect to SQLite database");
-      }
-      this.initialized = true;
-   }
-}
-
-export function sqlocal(instance: InstanceType<typeof SQLocalKysely>): SQLocalConnection {
-   return new SQLocalConnection(instance);
-}

app/src/data/entities/query/Repository.ts

@@ -103,7 +103,6 @@ export class Repository<TBD extends object = DefaultDB, TB extends keyof TBD = a
          validated.with = options.with;
       }
 
-      // add explicit joins. Implicit joins are added in `where` builder
       if (options.join && options.join.length > 0) {
          for (const entry of options.join) {
             const related = this.em.relationOf(entity.name, entry);
@@ -128,28 +127,12 @@ export class Repository<TBD extends object = DefaultDB, TB extends keyof TBD = a
          const invalid = WhereBuilder.getPropertyNames(options.where).filter((field) => {
             if (field.includes(".")) {
                const [alias, prop] = field.split(".") as [string, string];
-               // check aliases first (added joins)
-               if (aliases.includes(alias)) {
-                  this.checkIndex(alias, prop, "where");
-                  return !this.em.entity(alias).getField(prop);
-               }
-               // check if alias (entity) exists
-               if (!this.em.hasEntity(alias)) {
+               if (!aliases.includes(alias)) {
                   return true;
                }
-               // check related fields for auto join
-               const related = this.em.relationOf(entity.name, alias);
-               if (related) {
-                  const other = related.other(entity);
-                  if (other.entity.getField(prop)) {
-                     // if related field is found, add join to validated options
-                     validated.join?.push(alias);
-                     this.checkIndex(alias, prop, "where");
-                     return false;
-                  }
-               }
 
-               return true;
+               this.checkIndex(alias, prop, "where");
+               return !this.em.entity(alias).getField(prop);
             }
 
             this.checkIndex(entity.name, field, "where");

app/src/data/prototype/index.ts

@@ -289,7 +289,7 @@ class EntityManagerPrototype<Entities extends Record<string, Entity>> extends En
       super(Object.values(__entities), new DummyConnection(), relations, indices);
    }
 
-   withConnection(connection: Connection): EntityManager<Schemas<Entities>> {
+   withConnection(connection: Connection): EntityManager<Schema<Entities>> {
       return new EntityManager(this.entities, connection, this.relations.all, this.indices);
    }
 }

app/src/data/server/query.spec.ts

@@ -1,9 +1,8 @@
-import { test, describe, expect, beforeAll, afterAll } from "bun:test";
+import { test, describe, expect } from "bun:test";
 import * as q from "./query";
 import { parse as $parse, type ParseOptions } from "bknd/utils";
 import type { PrimaryFieldType } from "modules";
 import type { Generated } from "kysely";
-import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
 
 const parse = (v: unknown, o: ParseOptions = {}) =>
    $parse(q.repoQuery, v, {
@@ -16,9 +15,6 @@ const decode = (input: any, output: any) => {
    expect(parse(input)).toEqual(output);
 };
 
-beforeAll(() => disableConsoleLog());
-afterAll(() => enableConsoleLog());
-
 describe("server/query", () => {
    test("limit & offset", () => {
       //expect(() => parse({ limit: false })).toThrow();

app/src/index.ts

@@ -132,8 +132,6 @@ export type * from "data/entities/Entity";
 export type { EntityManager } from "data/entities/EntityManager";
 export type { SchemaManager } from "data/schema/SchemaManager";
 export type * from "data/entities";
-
-// data connection
 export {
    BaseIntrospector,
    Connection,
@@ -146,32 +144,9 @@ export {
    type ConnQuery,
    type ConnQueryResults,
 } from "data/connection";
-
-// data sqlite
 export { SqliteConnection } from "data/connection/sqlite/SqliteConnection";
 export { SqliteIntrospector } from "data/connection/sqlite/SqliteIntrospector";
 export { SqliteLocalConnection } from "data/connection/sqlite/SqliteLocalConnection";
-
-// data sqlocal
-export { SQLocalConnection, sqlocal } from "data/connection/sqlite/sqlocal/SQLocalConnection";
-
-// data postgres
-export {
-   pg,
-   PgPostgresConnection,
-} from "data/connection/postgres/PgPostgresConnection";
-export { PostgresIntrospector } from "data/connection/postgres/PostgresIntrospector";
-export { PostgresConnection } from "data/connection/postgres/PostgresConnection";
-export {
-   postgresJs,
-   PostgresJsConnection,
-} from "data/connection/postgres/PostgresJsConnection";
-export {
-   createCustomPostgresConnection,
-   type CustomPostgresConnection,
-} from "data/connection/postgres/custom";
-
-// data prototype
 export {
    text,
    number,

app/src/media/storage/adapters/adapter-test-suite.ts

@@ -5,7 +5,7 @@ import type { BunFile } from "bun";
 
 export async function adapterTestSuite(
    testRunner: TestRunner,
-   _adapter: StorageAdapter | (() => StorageAdapter),
+   adapter: StorageAdapter,
    file: File | BunFile,
    opts?: {
       retries?: number;
@@ -25,12 +25,7 @@ export async function adapterTestSuite(
    const _filename = randomString(10);
    const filename = `${_filename}.png`;
 
-   const getAdapter = (
-      typeof _adapter === "function" ? _adapter : () => _adapter
-   ) as () => StorageAdapter;
-
    await test("puts an object", async () => {
-      const adapter = getAdapter();
       objects = (await adapter.listObjects()).length;
       const result = await adapter.putObject(filename, file as unknown as File);
       expect(result).toBeDefined();
@@ -43,7 +38,6 @@ export async function adapterTestSuite(
    });
 
    await test("lists objects", async () => {
-      const adapter = getAdapter();
       const length = await retry(
          () => adapter.listObjects().then((res) => res.length),
          (length) => length > objects,
@@ -55,12 +49,10 @@ export async function adapterTestSuite(
    });
 
    await test("file exists", async () => {
-      const adapter = getAdapter();
       expect(await adapter.objectExists(filename)).toBe(true);
    });
 
    await test("gets an object", async () => {
-      const adapter = getAdapter();
       const res = await adapter.getObject(filename, new Headers());
       expect(res.ok).toBe(true);
       expect(res.headers.get("Accept-Ranges")).toBe("bytes");
@@ -70,7 +62,6 @@ export async function adapterTestSuite(
    if (options.testRange) {
       await test("handles range request - partial content", async () => {
          const headers = new Headers({ Range: "bytes=0-99" });
-         const adapter = getAdapter();
          const res = await adapter.getObject(filename, headers);
          expect(res.status).toBe(206); // Partial Content
          expect(/^bytes 0-99\/\d+$/.test(res.headers.get("Content-Range")!)).toBe(true);
@@ -79,7 +70,6 @@ export async function adapterTestSuite(
 
       await test("handles range request - suffix range", async () => {
          const headers = new Headers({ Range: "bytes=-100" });
-         const adapter = getAdapter();
          const res = await adapter.getObject(filename, headers);
          expect(res.status).toBe(206); // Partial Content
          expect(/^bytes \d+-\d+\/\d+$/.test(res.headers.get("Content-Range")!)).toBe(true);
@@ -87,7 +77,6 @@ export async function adapterTestSuite(
 
       await test("handles invalid range request", async () => {
          const headers = new Headers({ Range: "bytes=invalid" });
-         const adapter = getAdapter();
          const res = await adapter.getObject(filename, headers);
          expect(res.status).toBe(416); // Range Not Satisfiable
          expect(/^bytes \*\/\d+$/.test(res.headers.get("Content-Range")!)).toBe(true);
@@ -95,7 +84,6 @@ export async function adapterTestSuite(
    }
 
    await test("gets object meta", async () => {
-      const adapter = getAdapter();
       expect(await adapter.getObjectMeta(filename)).toEqual({
          type: file.type, // image/png
          size: file.size,
@@ -103,7 +91,6 @@ export async function adapterTestSuite(
    });
 
    await test("deletes an object", async () => {
-      const adapter = getAdapter();
       expect(await adapter.deleteObject(filename)).toBeUndefined();
 
       if (opts?.skipExistsAfterDelete !== true) {

app/src/modules/ModuleManager.ts

@@ -87,7 +87,7 @@ export type ModuleManagerOptions = {
    verbosity?: Verbosity;
 };
 
-const debug_modules = env("modules_debug", false);
+const debug_modules = env("modules_debug");
 
 abstract class ModuleManagerEvent<A = {}> extends Event<{ ctx: ModuleBuildContext } & A> {}
 export class ModuleManagerConfigUpdateEvent<

app/src/modules/permissions/index.ts

@@ -33,5 +33,3 @@ export const schemaRead = new Permission(
 );
 export const build = new Permission("system.build");
 export const mcp = new Permission("system.mcp");
-export const info = new Permission("system.info");
-export const openapi = new Permission("system.openapi");

app/src/modules/server/SystemController.ts

@@ -1,3 +1,5 @@
+/// <reference types="@cloudflare/workers-types" />
+
 import type { App } from "App";
 import {
    datetimeStringLocal,
@@ -357,7 +359,7 @@ export class SystemController extends Controller {
 
    override getController() {
       const { permission, auth } = this.middlewares;
-      const hono = this.create().use(auth()).use(permission(SystemPermissions.accessApi, {}));
+      const hono = this.create().use(auth());
 
       this.registerConfigController(hono);
 
@@ -432,9 +434,6 @@ export class SystemController extends Controller {
 
       hono.get(
          "/permissions",
-         permission(SystemPermissions.schemaRead, {
-            context: (_c) => ({ module: "auth" }),
-         }),
          describeRoute({
             summary: "Get the permissions",
             tags: ["system"],
@@ -447,7 +446,6 @@ export class SystemController extends Controller {
 
       hono.post(
          "/build",
-         permission(SystemPermissions.build, {}),
          describeRoute({
             summary: "Build the app",
             tags: ["system"],
@@ -478,7 +476,6 @@ export class SystemController extends Controller {
 
       hono.get(
          "/info",
-         permission(SystemPermissions.info, {}),
          mcpTool("system_info"),
          describeRoute({
             summary: "Get the server info",
@@ -512,7 +509,6 @@ export class SystemController extends Controller {
 
       hono.get(
          "/openapi.json",
-         permission(SystemPermissions.openapi, {}),
          openAPISpecs(this.ctx.server, {
             info: {
                title: "bknd API",
@@ -520,11 +516,7 @@ export class SystemController extends Controller {
             },
          }),
       );
-      hono.get(
-         "/swagger",
-         permission(SystemPermissions.openapi, {}),
-         swaggerUI({ url: "/api/system/openapi.json" }),
-      );
+      hono.get("/swagger", swaggerUI({ url: "/api/system/openapi.json" }));
 
       return hono;
    }

app/src/plugins/auth/email-otp.plugin.ts

@@ -126,7 +126,7 @@ export function emailOTP({
                         ...entityConfig,
                      },
                      "generated",
-                  ) as any,
+                  ),
                },
                ({ index }, schema) => {
                   const otp = schema[entityName]!;
@@ -153,7 +153,7 @@ export function emailOTP({
                   "/login",
                   jsc(
                      "json",
-                     s.strictObject({
+                     s.object({
                         email: s.string({ format: "email" }),
                         code: s.string({ minLength: 1 }).optional(),
                      }),
@@ -213,7 +213,7 @@ export function emailOTP({
                   ),
                   jsc("query", s.object({ redirect: s.string().optional() })),
                   async (c) => {
-                     const { email, code, ...rest } = c.req.valid("json");
+                     const { email, code } = c.req.valid("json");
                      const { redirect } = c.req.valid("query");
 
                      // throw if user exists
@@ -232,7 +232,6 @@ export function emailOTP({
                         await em.mutator(entityName).updateOne(otpData.id, { used_at: new Date() });
 
                         const user = await app.createUser({
-                           ...rest,
                            email,
                            password: randomString(32, true),
                         });

app/src/plugins/data/sort.plugin.spec.ts

@@ -0,0 +1,858 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { sort } from "./sort.plugin";
+import { em, entity, text, number } from "bknd";
+import { createApp } from "core/test/utils";
+import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
+
+beforeAll(() => disableConsoleLog());
+afterAll(enableConsoleLog);
+
+describe("sort plugin", () => {
+   test("should add sort field to configured entities", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const taskEntity = app.em.entity("tasks");
+      expect(taskEntity).toBeDefined();
+      expect(taskEntity?.fields.map((f) => f.name)).toContain("position");
+      expect(taskEntity?.field("position")?.type).toBe("number");
+   });
+
+   test("should auto-assign sort values on insert (starting from 0)", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // insert first item
+      const { data: task1 } = await mutator.insertOne({ title: "Task 1" });
+      expect(task1.position).toBe(0);
+
+      // insert second item
+      const { data: task2 } = await mutator.insertOne({ title: "Task 2" });
+      expect(task2.position).toBe(1);
+
+      // insert third item
+      const { data: task3 } = await mutator.insertOne({ title: "Task 3" });
+      expect(task3.position).toBe(2);
+   });
+
+   test("should preserve manually set sort values on insert", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // insert with explicit position
+      const { data: task } = await mutator.insertOne({ title: "Task 1", position: 10 });
+      expect(task.position).toBe(10);
+   });
+
+   test("should reorder items via API endpoint", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks at positions 0, 1, 2
+      const { data: task1 } = await mutator.insertOne({ title: "Task 1" });
+      const { data: task2 } = await mutator.insertOne({ title: "Task 2" });
+      const { data: task3 } = await mutator.insertOne({ title: "Task 3" });
+
+      // move task3 (position 2) to position 0
+      const res = await app.server.request("/api/sort/tasks/reorder", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({ id: task3.id, position: 0 }),
+      });
+
+      expect(res.status).toBe(200);
+
+      // verify positions
+      const repo = app.em.repo("tasks");
+      const { data: updatedTask1 } = await repo.findOne({ id: task1.id });
+      const { data: updatedTask2 } = await repo.findOne({ id: task2.id });
+      const { data: updatedTask3 } = await repo.findOne({ id: task3.id });
+
+      expect(updatedTask3.position).toBe(0); // moved to position 0
+      expect(updatedTask1.position).toBe(1); // shifted down
+      expect(updatedTask2.position).toBe(2); // shifted down
+   });
+
+   test("should automatically reorder when updating sort field directly", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks at positions 0, 1, 2, 3
+      const { data: task1 } = await mutator.insertOne({ title: "Task 1" });
+      const { data: task2 } = await mutator.insertOne({ title: "Task 2" });
+      const { data: task3 } = await mutator.insertOne({ title: "Task 3" });
+      const { data: task4 } = await mutator.insertOne({ title: "Task 4" });
+
+      // move task4 (position 3) to position 1 by updating directly
+      await mutator.updateOne(task4.id, { position: 1 });
+
+      // verify positions
+      const repo = app.em.repo("tasks");
+      const { data: updatedTask1 } = await repo.findOne({ id: task1.id });
+      const { data: updatedTask2 } = await repo.findOne({ id: task2.id });
+      const { data: updatedTask3 } = await repo.findOne({ id: task3.id });
+      const { data: updatedTask4 } = await repo.findOne({ id: task4.id });
+
+      expect(updatedTask1.position).toBe(0); // unchanged
+      expect(updatedTask2.position).toBe(2); // shifted down
+      expect(updatedTask3.position).toBe(3); // shifted down
+      expect(updatedTask4.position).toBe(1); // moved to position 1
+   });
+
+   test("should automatically reorder when moving items up", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks at positions 0, 1, 2, 3
+      const { data: task1 } = await mutator.insertOne({ title: "Task 1" });
+      const { data: task2 } = await mutator.insertOne({ title: "Task 2" });
+      const { data: task3 } = await mutator.insertOne({ title: "Task 3" });
+      const { data: task4 } = await mutator.insertOne({ title: "Task 4" });
+
+      // move task1 (position 0) to position 2 by updating directly
+      await mutator.updateOne(task1.id, { position: 2 });
+
+      // verify positions
+      const repo = app.em.repo("tasks");
+      const { data: updatedTask1 } = await repo.findOne({ id: task1.id });
+      const { data: updatedTask2 } = await repo.findOne({ id: task2.id });
+      const { data: updatedTask3 } = await repo.findOne({ id: task3.id });
+      const { data: updatedTask4 } = await repo.findOne({ id: task4.id });
+
+      expect(updatedTask1.position).toBe(2); // moved to position 2
+      expect(updatedTask2.position).toBe(0); // shifted up
+      expect(updatedTask3.position).toBe(1); // shifted up
+      expect(updatedTask4.position).toBe(3); // unchanged
+   });
+
+   test("should support scoped sorting", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+                  project_id: number(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                        scope: "project_id",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks in project 1
+      const { data: p1t1 } = await mutator.insertOne({
+         title: "P1 Task 1",
+         project_id: 1,
+      });
+      const { data: p1t2 } = await mutator.insertOne({
+         title: "P1 Task 2",
+         project_id: 1,
+      });
+
+      // create tasks in project 2
+      const { data: p2t1 } = await mutator.insertOne({
+         title: "P2 Task 1",
+         project_id: 2,
+      });
+      const { data: p2t2 } = await mutator.insertOne({
+         title: "P2 Task 2",
+         project_id: 2,
+      });
+
+      // positions should be scoped per project
+      expect(p1t1.position).toBe(0);
+      expect(p1t2.position).toBe(1);
+      expect(p2t1.position).toBe(0); // resets for new scope
+      expect(p2t2.position).toBe(1);
+   });
+
+   test("should reorder only within scope", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+                  project_id: number(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                        scope: "project_id",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks in project 1
+      const { data: p1t1 } = await mutator.insertOne({
+         title: "P1 Task 1",
+         project_id: 1,
+      });
+      const { data: p1t2 } = await mutator.insertOne({
+         title: "P1 Task 2",
+         project_id: 1,
+      });
+      const { data: p1t3 } = await mutator.insertOne({
+         title: "P1 Task 3",
+         project_id: 1,
+      });
+
+      // create tasks in project 2
+      const { data: p2t1 } = await mutator.insertOne({
+         title: "P2 Task 1",
+         project_id: 2,
+      });
+      const { data: p2t2 } = await mutator.insertOne({
+         title: "P2 Task 2",
+         project_id: 2,
+      });
+
+      // move p1t3 to position 0 (should only affect project 1)
+      await app.server.request("/api/sort/tasks/reorder", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({ id: p1t3.id, position: 0 }),
+      });
+
+      // verify project 1 tasks
+      const repo = app.em.repo("tasks");
+      const { data: updatedP1t1 } = await repo.findOne({ id: p1t1.id });
+      const { data: updatedP1t2 } = await repo.findOne({ id: p1t2.id });
+      const { data: updatedP1t3 } = await repo.findOne({ id: p1t3.id });
+
+      expect(updatedP1t3.position).toBe(0); // moved to position 0
+      expect(updatedP1t1.position).toBe(1); // shifted
+      expect(updatedP1t2.position).toBe(2); // shifted
+
+      // verify project 2 tasks are unchanged
+      const { data: updatedP2t1 } = await repo.findOne({ id: p2t1.id });
+      const { data: updatedP2t2 } = await repo.findOne({ id: p2t2.id });
+
+      expect(updatedP2t1.position).toBe(0); // unchanged
+      expect(updatedP2t2.position).toBe(1); // unchanged
+   });
+
+   test("should recalculate all positions", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks with irregular positions
+      await mutator.insertOne({ title: "Task 1", position: 5 });
+      await mutator.insertOne({ title: "Task 2", position: 10 });
+      await mutator.insertOne({ title: "Task 3", position: 15 });
+      await mutator.insertOne({ title: "Task 4", position: 100 });
+
+      // recalculate
+      const res = await app.server.request("/api/sort/tasks/recalculate", {
+         method: "POST",
+         body: JSON.stringify({}),
+         headers: {
+            "Content-Type": "application/json",
+         },
+      });
+
+      expect(res.status).toBe(200);
+
+      // verify positions are now 0, 1, 2, 3
+      const { data: tasks } = await app.em.repo("tasks").findMany({
+         orderBy: [{ position: "asc" }],
+      });
+
+      expect(tasks.length).toBe(4);
+      expect(tasks[0].position).toBe(0);
+      expect(tasks[1].position).toBe(1);
+      expect(tasks[2].position).toBe(2);
+      expect(tasks[3].position).toBe(3);
+   });
+
+   test("should recalculate positions within scope only", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+                  project_id: number(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                        scope: "project_id",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks in project 1 with irregular positions
+      await mutator.insertOne({ title: "P1 Task 1", project_id: 1, position: 5 });
+      await mutator.insertOne({ title: "P1 Task 2", project_id: 1, position: 15 });
+
+      // create tasks in project 2 with irregular positions
+      await mutator.insertOne({ title: "P2 Task 1", project_id: 2, position: 10 });
+      await mutator.insertOne({ title: "P2 Task 2", project_id: 2, position: 20 });
+
+      // recalculate only project 1
+      const res = await app.server.request("/api/sort/tasks/recalculate", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({ scope: 1 }),
+      });
+
+      expect(res.status).toBe(200);
+
+      // verify project 1 tasks are recalculated
+      const { data: p1Tasks } = await app.em.repo("tasks").findMany({
+         where: { project_id: 1 },
+         orderBy: [{ position: "asc" }],
+      });
+
+      expect(p1Tasks.length).toBe(2);
+      expect(p1Tasks[0].position).toBe(0);
+      expect(p1Tasks[1].position).toBe(1);
+
+      // verify project 2 tasks are unchanged
+      const { data: p2Tasks } = await app.em.repo("tasks").findMany({
+         where: { project_id: 2 },
+         orderBy: [{ position: "asc" }],
+      });
+
+      expect(p2Tasks.length).toBe(2);
+      expect(p2Tasks[0].position).toBe(10); // unchanged
+      expect(p2Tasks[1].position).toBe(20); // unchanged
+   });
+
+   test("should handle moving items to the end", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks at positions 0, 1, 2, 3
+      const { data: task1 } = await mutator.insertOne({ title: "Task 1" });
+      const { data: task2 } = await mutator.insertOne({ title: "Task 2" });
+      const { data: task3 } = await mutator.insertOne({ title: "Task 3" });
+      const { data: task4 } = await mutator.insertOne({ title: "Task 4" });
+
+      // move task1 to the end (position 3)
+      await app.server.request("/api/sort/tasks/reorder", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({ id: task1.id, position: 3 }),
+      });
+
+      // verify positions
+      const repo = app.em.repo("tasks");
+      const { data: updatedTask1 } = await repo.findOne({ id: task1.id });
+      const { data: updatedTask2 } = await repo.findOne({ id: task2.id });
+      const { data: updatedTask3 } = await repo.findOne({ id: task3.id });
+      const { data: updatedTask4 } = await repo.findOne({ id: task4.id });
+
+      expect(updatedTask1.position).toBe(3); // moved to end
+      expect(updatedTask2.position).toBe(0); // shifted up
+      expect(updatedTask3.position).toBe(1); // shifted up
+      expect(updatedTask4.position).toBe(2); // shifted up
+   });
+
+   test("should return 400 for invalid item id", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const res = await app.server.request("/api/sort/tasks/reorder", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({ id: 999999, position: 0 }),
+      });
+
+      expect(res.status).toBe(400);
+   });
+
+   test("should handle multiple entities with different configurations", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+               categories: entity("categories", {
+                  name: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                     categories: {
+                        field: "order",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      // verify both entities have their sort fields
+      const taskEntity = app.em.entity("tasks");
+      const categoryEntity = app.em.entity("categories");
+
+      expect(taskEntity?.fields.map((f) => f.name)).toContain("position");
+      expect(categoryEntity?.fields.map((f) => f.name)).toContain("order");
+
+      // create items in both entities
+      const { data: task } = await app.em.mutator("tasks").insertOne({ title: "Task 1" });
+      const { data: category } = await app.em.mutator("categories").insertOne({ name: "Cat 1" });
+
+      expect(task.position).toBe(0);
+      expect(category.order).toBe(0);
+
+      // verify both endpoints exist
+      const taskRes = await app.server.request("/api/sort/tasks/recalculate", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({}),
+      });
+      const catRes = await app.server.request("/api/sort/categories/recalculate", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({}),
+      });
+
+      expect(taskRes.status).toBe(200);
+      expect(catRes.status).toBe(200);
+   });
+
+   test("should not trigger reorder when updating other fields", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks
+      const { data: task1 } = await mutator.insertOne({ title: "Task 1" });
+      const { data: task2 } = await mutator.insertOne({ title: "Task 2" });
+      const { data: task3 } = await mutator.insertOne({ title: "Task 3" });
+
+      // update title only (should not trigger reordering)
+      await mutator.updateOne(task2.id, { title: "Task 2 Updated" });
+
+      // verify positions are unchanged
+      const repo = app.em.repo("tasks");
+      const { data: updatedTask1 } = await repo.findOne({ id: task1.id });
+      const { data: updatedTask2 } = await repo.findOne({ id: task2.id });
+      const { data: updatedTask3 } = await repo.findOne({ id: task3.id });
+
+      expect(updatedTask1.position).toBe(0);
+      expect(updatedTask2.position).toBe(1);
+      expect(updatedTask2.title).toBe("Task 2 Updated");
+      expect(updatedTask3.position).toBe(2);
+   });
+
+   test("should handle null sort values", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create task with null position (bypass listener by using kysely directly)
+      await app.connection.kysely
+         .insertInto("tasks")
+         .values({ title: "Task with null", position: null })
+         .execute();
+
+      // create normal task
+      await mutator.insertOne({ title: "Task 2" });
+
+      // update the null task to have a position
+      const nullTask = await app.connection.kysely
+         .selectFrom("tasks")
+         .selectAll()
+         .where("title", "=", "Task with null")
+         .executeTakeFirst();
+
+      await mutator.updateOne(nullTask!.id, { position: 0 });
+
+      // verify both tasks have proper positions
+      const { data: tasks } = await app.em.repo("tasks").findMany({
+         sort: { by: "position", dir: "asc" },
+      });
+
+      expect(tasks.length).toBe(2);
+      expect(tasks[0].position).toBe(0);
+      expect(tasks[1].position).toBe(1);
+   });
+
+   test("should not create duplicates when moving to an occupied position", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create two tasks at positions 0 and 1
+      const { data: task1 } = await mutator.insertOne({ title: "Task 1" });
+      const { data: task2 } = await mutator.insertOne({ title: "Task 2" });
+
+      expect(task1.position).toBe(0);
+      expect(task2.position).toBe(1);
+
+      // move task2 (at position 1) to position 0
+      await mutator.updateOne(task2.id, { position: 0 });
+
+      // verify no duplicates
+      const { data: tasks } = await app.em.repo("tasks").findMany({
+         sort: { by: "position", dir: "asc" },
+      });
+
+      expect(tasks.length).toBe(2);
+      expect(tasks[0].id).toBe(task2.id);
+      expect(tasks[0].position).toBe(0);
+      expect(tasks[1].id).toBe(task1.id);
+      expect(tasks[1].position).toBe(1);
+
+      // verify no tasks have the same position
+      const positions = tasks.map((t) => t.position);
+      const uniquePositions = new Set(positions);
+      expect(uniquePositions.size).toBe(positions.length);
+   });
+
+   test("should preserve order when recalculating", async () => {
+      const app = createApp({
+         config: {
+            data: em({
+               tasks: entity("tasks", {
+                  title: text(),
+               }),
+            }).toJSON(),
+         },
+         options: {
+            plugins: [
+               sort({
+                  entities: {
+                     tasks: {
+                        field: "position",
+                     },
+                  },
+               }),
+            ],
+         },
+      });
+      await app.build();
+
+      const mutator = app.em.mutator("tasks");
+
+      // create tasks with specific positions
+      const { data: taskA } = await mutator.insertOne({ title: "Task A", position: 5 });
+      const { data: taskB } = await mutator.insertOne({ title: "Task B", position: 3 });
+      const { data: taskC } = await mutator.insertOne({ title: "Task C", position: 10 });
+
+      // recalculate
+      await app.server.request("/api/sort/tasks/recalculate", {
+         method: "POST",
+         headers: {
+            "Content-Type": "application/json",
+         },
+         body: JSON.stringify({}),
+      });
+
+      // verify order is preserved (B, A, C based on original positions)
+      const { data: tasks } = await app.em.repo("tasks").findMany({
+         sort: { by: "position", dir: "asc" },
+      });
+
+      expect(tasks[0].id).toBe(taskB.id); // was at 3, now at 0
+      expect(tasks[0].position).toBe(0);
+      expect(tasks[1].id).toBe(taskA.id); // was at 5, now at 1
+      expect(tasks[1].position).toBe(1);
+      expect(tasks[2].id).toBe(taskC.id); // was at 10, now at 2
+      expect(tasks[2].position).toBe(2);
+   });
+});

app/src/plugins/data/sort.plugin.ts

@@ -0,0 +1,423 @@
+import { Exception, type App, type AppPlugin, DatabaseEvents, em, entity, number } from "bknd";
+import { invariant, HttpStatus, jsc, s, $console } from "bknd/utils";
+import { Hono } from "hono";
+import { sql } from "kysely";
+
+const DEFAULT_BATCH_SIZE = 1000;
+
+export type SortPluginOptions = {
+   /**
+    * The base path for the API endpoints.
+    * @default "/api/sort"
+    */
+   apiBasePath?: string;
+
+   /**
+    * Configuration for entities that should have sorting enabled.
+    * Key is the entity name, value is the configuration.
+    */
+   entities: Record<
+      string,
+      {
+         /**
+          * The name of the sort property (must be a number field).
+          */
+         field: string;
+
+         /**
+          * Optional scope field name. If provided, sorting will only happen within the same scope.
+          * For example, if scope is "category_id", items will only be sorted within items
+          * that have the same category_id value.
+          */
+         scope?: string;
+      }
+   >;
+
+   /**
+    * The batch size for recalculating sort order.
+    * @default 1000
+    */
+   recalculateBatchSize?: number;
+};
+
+class SortError extends Exception {
+   override name = "SortError";
+   override code = HttpStatus.BAD_REQUEST;
+}
+
+export function sort({
+   apiBasePath = "/api/sort",
+   entities,
+   recalculateBatchSize = DEFAULT_BATCH_SIZE,
+}: SortPluginOptions): AppPlugin {
+   return (app: App) => {
+      return {
+         name: "sort",
+         schema: () => {
+            return em(
+               Object.fromEntries(
+                  Object.entries(entities).map(([entityName, config]) => [
+                     entityName,
+                     entity(entityName, {
+                        [config.field]: number({ default_value: 0 }),
+                     }),
+                  ]),
+               ),
+               ({ index }, schema) => {
+                  for (const [entityName, config] of Object.entries(entities)) {
+                     const indexed = app.em.getIndexedFields(entityName);
+                     if (!indexed.some((f) => f.name === config.field)) {
+                        index(schema[entityName]!).on([config.field]);
+                     }
+                  }
+               },
+            );
+         },
+         onBuilt: async () => {
+            invariant(
+               entities && Object.keys(entities).length > 0,
+               "At least one entity must be configured",
+            );
+
+            // validate entities exist and have the configured fields
+            for (const [entityName, config] of Object.entries(entities)) {
+               const entity = app.em.entity(entityName);
+               invariant(entity, `Entity "${entityName}" not found in schema`);
+
+               const sortFieldSchema = entity.field(config.field)!;
+               invariant(
+                  sortFieldSchema,
+                  `Sort field "${config.field}" not found in entity "${entityName}"`,
+               );
+               invariant(
+                  sortFieldSchema.type === "number",
+                  `Sort field "${config.field}" in entity "${entityName}" must be a number field`,
+               );
+
+               if (config.scope) {
+                  const scopeFieldSchema = entity.field(config.scope);
+                  invariant(
+                     scopeFieldSchema,
+                     `Scope field "${config.scope}" not found in entity "${entityName}"`,
+                  );
+               }
+            }
+
+            const hono = new Hono();
+
+            // register recalculate endpoints for each entity
+            for (const [entityName, config] of Object.entries(entities)) {
+               hono.post(
+                  `/${entityName}/recalculate`,
+                  jsc(
+                     "json",
+                     s
+                        .object({
+                           scope: s.any().optional(),
+                        })
+                        .optional(),
+                  ),
+                  async (c) => {
+                     const body = c.req.valid("json");
+                     const scope = body?.scope;
+
+                     await recalculateSortOrder(
+                        app,
+                        entityName,
+                        config,
+                        recalculateBatchSize,
+                        scope,
+                     );
+
+                     return c.json({ success: true, message: "Sort order recalculated" });
+                  },
+               );
+
+               hono.post(
+                  `/${entityName}/reorder`,
+                  jsc(
+                     "json",
+                     s.object({
+                        id: s.any(),
+                        position: s.number(),
+                     }),
+                  ),
+                  async (c) => {
+                     const { id, position } = c.req.valid("json");
+
+                     await reorderItem(app, entityName, config, id, position);
+
+                     return c.json({ success: true, message: "Item reordered" });
+                  },
+               );
+            }
+
+            app.server.route(apiBasePath, hono);
+
+            // register listeners for automatic reordering
+            registerListeners(app, entities);
+         },
+      };
+   };
+}
+
+async function reorderItem(
+   app: App,
+   entityName: string,
+   config: SortPluginOptions["entities"][string],
+   id: any,
+   newPosition: number,
+) {
+   const { field: sortField, scope: scopeField } = config;
+   const em = app.em.fork();
+   const kysely = em.connection.kysely;
+
+   // get the item
+   const { data: item } = await em.repo(entityName).findOne({ id });
+   if (!item) {
+      throw new SortError(`Item with id "${id}" not found in entity "${entityName}"`);
+   }
+
+   const oldPosition = item[sortField] as number | null | undefined;
+   const scopeValue = scopeField ? item[scopeField] : undefined;
+
+   // update the item with new position (using forked em, so no listeners are triggered)
+   await em.mutator(entityName).updateOne(id, { [sortField]: newPosition });
+
+   // shift other items using kysely
+   if (oldPosition !== undefined && oldPosition !== null && oldPosition !== newPosition) {
+      if (newPosition < oldPosition) {
+         // moving up: increment items between newPosition and oldPosition
+         let query = kysely
+            .updateTable(entityName)
+            .set({ [sortField]: sql`${sql.ref(sortField)} + 1` } as any)
+            .where(sortField as any, ">=", newPosition)
+            .where(sortField as any, "<", oldPosition)
+            .where("id", "!=", id);
+
+         if (scopeField && scopeValue !== undefined) {
+            query = query.where(scopeField as any, "=", scopeValue);
+         }
+
+         await query.execute();
+      } else {
+         // moving down: decrement items between oldPosition and newPosition
+         let query = kysely
+            .updateTable(entityName)
+            .set({ [sortField]: sql`${sql.ref(sortField)} - 1` } as any)
+            .where(sortField as any, ">", oldPosition)
+            .where(sortField as any, "<=", newPosition)
+            .where("id", "!=", id);
+
+         if (scopeField && scopeValue !== undefined) {
+            query = query.where(scopeField as any, "=", scopeValue);
+         }
+
+         await query.execute();
+      }
+   } else if (oldPosition === undefined || oldPosition === null) {
+      // new item, shift everything at or after this position
+      let query = kysely
+         .updateTable(entityName)
+         .set({ [sortField]: sql`${sql.ref(sortField)} + 1` } as any)
+         .where(sortField as any, ">=", newPosition)
+         .where("id", "!=", id);
+
+      if (scopeField && scopeValue !== undefined) {
+         query = query.where(scopeField as any, "=", scopeValue);
+      }
+
+      await query.execute();
+   }
+}
+
+async function recalculateSortOrder(
+   app: App,
+   entityName: string,
+   config: SortPluginOptions["entities"][string],
+   batchSize: number,
+   scope?: any,
+) {
+   const { field: sortField, scope: scopeField } = config;
+   const db = app.connection.kysely;
+
+   const { count } = (await db
+      .selectFrom(entityName)
+      .select((eb) => eb.fn.count<number>("id").as("count"))
+      .$if(Boolean(scopeField && scope !== undefined), (eb) =>
+         eb.where(scopeField as any, "=", scope),
+      )
+      .$castTo<{ count: number }>()
+      .executeTakeFirst()) ?? { count: 0 };
+
+   const batches = Math.ceil(count / batchSize);
+   for (let i = 0; i < batches; i++) {
+      // get all items in scope, ordered by current sort value
+      const items = await db
+         .selectFrom(entityName)
+         .select(["id", sortField])
+         .$if(Boolean(scopeField && scope !== undefined), (eb) =>
+            eb.where(scopeField as any, "=", scope),
+         )
+         .orderBy(sortField, "asc")
+         .limit(batchSize)
+         .offset(i * batchSize)
+         .execute();
+
+      const newQbs = items.map((item, index) =>
+         db
+            .updateTable(entityName)
+            .set({ [sortField]: index })
+            .where("id", "=", item.id),
+      );
+
+      await app.connection.executeQueries(...newQbs);
+      $console.log(
+         `[Sort Plugin] Recalculated sort order for ${items.length} items in entity "${entityName}"${scopeField && scope !== undefined ? ` (scope: ${scope})` : ""} [batch ${i + 1}/${batches}]`,
+      );
+   }
+}
+
+function registerListeners(app: App, entities: SortPluginOptions["entities"]) {
+   const kysely = app.connection.kysely;
+
+   // handle insert events
+   app.emgr.onEvent(
+      DatabaseEvents.MutatorInsertBefore,
+      async (e) => {
+         const entityName = e.params.entity.name;
+         const config = entities[entityName];
+         if (!config) return e.params.data;
+
+         const { field: sortField, scope: scopeField } = config;
+         const data = e.params.data;
+         const scopeValue = scopeField ? data[scopeField] : undefined;
+
+         // if no position provided, set to max + 1
+         if (data[sortField] === undefined || data[sortField] === null) {
+            const query = kysely
+               .selectFrom(entityName)
+               .select((eb) => [eb.fn.max<number>(eb.ref(sortField)).as("max")])
+               // add scope filter if needed
+               .$if(Boolean(scopeField && scopeValue), (eb) =>
+                  eb.where(scopeField as any, "=", scopeValue as any),
+               );
+
+            const result = await query.executeTakeFirst();
+            const max = result?.max ?? -1;
+
+            return {
+               ...data,
+               [sortField]: max + 1,
+            };
+         }
+
+         // if position is provided, shift other items at or after that position
+         const newPosition = data[sortField] as number;
+
+         let shiftQuery = kysely
+            .updateTable(entityName)
+            .set({ [sortField]: sql`${sql.ref(sortField)} + 1` } as any)
+            .where(sortField as any, ">=", newPosition);
+
+         if (scopeField && scopeValue !== undefined) {
+            shiftQuery = shiftQuery.where(scopeField as any, "=", scopeValue);
+         }
+
+         await shiftQuery.execute();
+
+         return data;
+      },
+      {
+         mode: "sync",
+         id: "bknd-sort-insert",
+      },
+   );
+
+   // handle update events
+   app.emgr.onEvent(
+      DatabaseEvents.MutatorUpdateBefore,
+      async (e) => {
+         const entityName = e.params.entity.name;
+         const config = entities[entityName];
+         if (!config) return e.params.data;
+
+         const { field: sortField, scope: scopeField } = config;
+         const data = e.params.data;
+
+         // only handle if sort field is being updated
+         if (!(sortField in data)) return e.params.data;
+
+         const newPosition = data[sortField] as number;
+         const id = e.params.entityId;
+
+         // get the current item to know its old position and scope
+         const item = await kysely
+            .selectFrom(entityName)
+            .selectAll()
+            .where("id" as any, "=", id)
+            .executeTakeFirst();
+
+         if (!item) return data;
+
+         const oldPosition = item[sortField] as number | null | undefined;
+         const scopeValue = scopeField ? item[scopeField] : undefined;
+
+         // if oldPosition is null or undefined, treat as inserting at newPosition
+         if (oldPosition === null || oldPosition === undefined) {
+            // shift items at or after the new position
+            let query = kysely
+               .updateTable(entityName)
+               .set({ [sortField]: sql`${sql.ref(sortField)} + 1` } as any)
+               .where(sortField as any, ">=", newPosition)
+               .where("id" as any, "!=", id);
+
+            if (scopeField && scopeValue !== undefined) {
+               query = query.where(scopeField as any, "=", scopeValue);
+            }
+
+            await query.execute();
+            return data;
+         }
+
+         // shift other items using kysely
+         if (oldPosition !== newPosition) {
+            if (newPosition < oldPosition) {
+               // moving up: increment items between newPosition and oldPosition
+               let query = kysely
+                  .updateTable(entityName)
+                  .set({ [sortField]: sql`${sql.ref(sortField)} + 1` } as any)
+                  .where(sortField as any, ">=", newPosition)
+                  .where(sortField as any, "<", oldPosition)
+                  .where("id" as any, "!=", id);
+
+               if (scopeField && scopeValue !== undefined) {
+                  query = query.where(scopeField as any, "=", scopeValue);
+               }
+
+               await query.execute();
+            } else {
+               // moving down: decrement items between oldPosition and newPosition
+               let query = kysely
+                  .updateTable(entityName)
+                  .set({ [sortField]: sql`${sql.ref(sortField)} - 1` } as any)
+                  .where(sortField as any, ">", oldPosition)
+                  .where(sortField as any, "<=", newPosition)
+                  .where("id" as any, "!=", id);
+
+               if (scopeField && scopeValue !== undefined) {
+                  query = query.where(scopeField as any, "=", scopeValue);
+               }
+
+               await query.execute();
+            }
+         }
+
+         return data;
+      },
+      {
+         mode: "sync",
+         id: "bknd-sort-update",
+      },
+   );
+}

app/src/plugins/index.ts

@@ -9,3 +9,4 @@ export { syncTypes, type SyncTypesOptions } from "./dev/sync-types.plugin";
 export { syncSecrets, type SyncSecretsOptions } from "./dev/sync-secrets.plugin";
 export { timestamps, type TimestampsPluginOptions } from "./data/timestamps.plugin";
 export { emailOTP, type EmailOTPPluginOptions } from "./auth/email-otp.plugin";
+export { sort, type SortPluginOptions } from "./data/sort.plugin";

app/src/ui/Admin.tsx

@@ -5,7 +5,7 @@ import { BkndProvider } from "ui/client/bknd";
 import { useTheme, type AppTheme } from "ui/client/use-theme";
 import { Logo } from "ui/components/display/Logo";
 import * as AppShell from "ui/layouts/AppShell/AppShell";
-import { ClientProvider, useBkndWindowContext, type ClientProviderProps } from "bknd/client";
+import { ClientProvider, useBkndWindowContext, type ClientProviderProps } from "./client";
 import { createMantineTheme } from "./lib/mantine/theme";
 import { Routes } from "./routes";
 import type { BkndAdminAppShellOptions, BkndAdminEntitiesOptions } from "./options";
@@ -52,30 +52,26 @@ export type BkndAdminProps = {
    children?: ReactNode;
 };
 
-export default function Admin(props: BkndAdminProps) {
+export default function Admin({
+   baseUrl: baseUrlOverride,
+   withProvider = false,
+   config: _config = {},
+   children,
+}: BkndAdminProps) {
+   const { theme } = useTheme();
    const Provider = ({ children }: any) =>
-      props.withProvider ? (
+      withProvider ? (
          <ClientProvider
-            baseUrl={props.baseUrl}
-            {...(typeof props.withProvider === "object" ? props.withProvider : {})}
+            baseUrl={baseUrlOverride}
+            {...(typeof withProvider === "object" ? withProvider : {})}
          >
             {children}
          </ClientProvider>
       ) : (
          children
       );
-
-   return (
-      <Provider>
-         <AdminInner {...props} />
-      </Provider>
-   );
-}
-
-function AdminInner(props: BkndAdminProps) {
-   const { theme } = useTheme();
    const config = {
-      ...props.config,
+      ..._config,
       ...useBkndWindowContext(),
    };
 
@@ -86,12 +82,14 @@ function AdminInner(props: BkndAdminProps) {
    );
 
    return (
-      <MantineProvider {...createMantineTheme(theme as any)}>
-         <Notifications position="top-right" />
-         <Routes BkndWrapper={BkndWrapper} basePath={config?.basepath}>
-            {props.children}
-         </Routes>
-      </MantineProvider>
+      <Provider>
+         <MantineProvider {...createMantineTheme(theme as any)}>
+            <Notifications position="top-right" />
+            <Routes BkndWrapper={BkndWrapper} basePath={config?.basepath}>
+               {children}
+            </Routes>
+         </MantineProvider>
+      </Provider>
    );
 }
 

app/src/ui/client/BkndProvider.tsx

@@ -9,7 +9,7 @@ import {
    useState,
    type ReactNode,
 } from "react";
-import { useApi } from "bknd/client";
+import { useApi } from "ui/client";
 import { type TSchemaActions, getSchemaActions } from "./schema/actions";
 import { AppReduced } from "./utils/AppReduced";
 import { Message } from "ui/components/display/Message";

app/src/ui/client/ClientProvider.tsx

@@ -14,20 +14,18 @@ const ClientContext = createContext<BkndClientContext>(undefined!);
 export type ClientProviderProps = {
    children?: ReactNode;
    baseUrl?: string;
-   api?: Api;
 } & ApiOptions;
 
 export const ClientProvider = ({
    children,
    host,
    baseUrl: _baseUrl = host,
-   api: _api,
    ...props
 }: ClientProviderProps) => {
    const winCtx = useBkndWindowContext();
    const _ctx = useClientContext();
    let actualBaseUrl = _baseUrl ?? _ctx?.baseUrl ?? "";
-   let user: any;
+   let user: any = undefined;
 
    if (winCtx) {
       user = winCtx.user;
@@ -42,7 +40,6 @@ export const ClientProvider = ({
    const apiProps = { user, ...props, host: actualBaseUrl };
    const api = useMemo(
       () =>
-         _api ??
          new Api({
             ...apiProps,
             verbose: isDebug(),
@@ -53,7 +50,7 @@ export const ClientProvider = ({
                }
             },
          }),
-      [_api, JSON.stringify(apiProps)],
+      [JSON.stringify(apiProps)],
    );
 
    const [authState, setAuthState] = useState<Partial<AuthState> | undefined>(api.getAuthState());
@@ -67,14 +64,9 @@ export const ClientProvider = ({
 
 export const useApi = (host?: ApiOptions["host"]): Api => {
    const context = useContext(ClientContext);
-
    if (!context?.api || (host && host.length > 0 && host !== context.baseUrl)) {
-      console.info("creating new api", { host });
       return new Api({ host: host ?? "" });
    }
-   if (!context) {
-      throw new Error("useApi must be used within a ClientProvider");
-   }
 
    return context.api;
 };

app/src/ui/client/api/use-api.ts

@@ -2,7 +2,7 @@ import type { Api } from "Api";
 import { FetchPromise, type ModuleApi, type ResponseObject } from "modules/ModuleApi";
 import useSWR, { type SWRConfiguration, useSWRConfig, type Middleware, type SWRHook } from "swr";
 import useSWRInfinite from "swr/infinite";
-import { useApi } from "../ClientProvider";
+import { useApi } from "ui/client";
 import { useState } from "react";
 
 export const useApiQuery = <

app/src/ui/client/api/use-entity.ts

@@ -10,7 +10,7 @@ import type {
 import { objectTransform, encodeSearch } from "bknd/utils";
 import type { Insertable, Selectable, Updateable, Generated } from "kysely";
 import useSWR, { type SWRConfiguration, type SWRResponse, mutate } from "swr";
-import { type Api, useApi } from "bknd/client";
+import { type Api, useApi } from "ui/client";
 
 export class UseEntityApiError<Payload = any> extends Error {
    constructor(

app/src/ui/client/index.ts

@@ -4,7 +4,6 @@ export {
    type ClientProviderProps,
    useApi,
    useBaseUrl,
-   useClientContext
 } from "./ClientProvider";
 
 export * from "./api/use-api";

app/src/ui/client/schema/auth/use-auth.ts

@@ -1,6 +1,7 @@
 import type { AuthState } from "Api";
 import type { AuthResponse } from "bknd";
-import { useApi, useInvalidate, useClientContext } from "bknd/client";
+import { useApi, useInvalidate } from "ui/client";
+import { useClientContext } from "ui/client/ClientProvider";
 
 type LoginData = {
    email: string;
@@ -18,7 +19,6 @@ type UseAuth = {
    logout: () => Promise<void>;
    verify: () => Promise<void>;
    setToken: (token: string) => void;
-   local: boolean;
 };
 
 export const useAuth = (options?: { baseUrl?: string }): UseAuth => {
@@ -61,6 +61,5 @@ export const useAuth = (options?: { baseUrl?: string }): UseAuth => {
       logout,
       setToken,
       verify,
-      local: !!api.options.storage,
    };
 };

app/src/ui/components/buttons/Button.tsx

@@ -1,5 +1,6 @@
 import type React from "react";
-import { Children, forwardRef } from "react";
+import { Children } from "react";
+import { forwardRef } from "react";
 import { twMerge } from "tailwind-merge";
 import { Link } from "ui/components/wouter/Link";
 

app/src/ui/components/form/Formy/components.tsx

@@ -1,6 +1,6 @@
 import { Tooltip } from "@mantine/core";
 import clsx from "clsx";
-import { getBrowser } from "bknd/utils";
+import { getBrowser } from "core/utils";
 import type { Field } from "data/fields";
 import { Switch as RadixSwitch } from "radix-ui";
 import {

app/src/ui/components/form/native-form/NativeForm.tsx

@@ -16,18 +16,15 @@ import {
    setPath,
 } from "./utils";
 
-export type NativeFormProps = Omit<ComponentPropsWithoutRef<"form">, "onChange" | "onSubmit"> & {
+export type NativeFormProps = {
    hiddenSubmit?: boolean;
    validateOn?: "change" | "submit";
-   errorFieldSelector?: (selector: string) => any | null;
+   errorFieldSelector?: <K extends keyof HTMLElementTagNameMap>(name: string) => any | null;
    reportValidity?: boolean;
-   onSubmit?: (
-      data: any,
-      ctx: { event: FormEvent<HTMLFormElement>; form: HTMLFormElement },
-   ) => Promise<void> | void;
+   onSubmit?: (data: any, ctx: { event: FormEvent<HTMLFormElement> }) => Promise<void> | void;
    onSubmitInvalid?: (
       errors: InputError[],
-      ctx: { event: FormEvent<HTMLFormElement>; form: HTMLFormElement },
+      ctx: { event: FormEvent<HTMLFormElement> },
    ) => Promise<void> | void;
    onError?: (errors: InputError[]) => void;
    disableSubmitOnError?: boolean;
@@ -36,7 +33,7 @@ export type NativeFormProps = Omit<ComponentPropsWithoutRef<"form">, "onChange"
       ctx: { event: ChangeEvent<HTMLFormElement>; key: string; value: any; errors: InputError[] },
    ) => Promise<void> | void;
    clean?: CleanOptions | true;
-};
+} & Omit<ComponentPropsWithoutRef<"form">, "onChange" | "onSubmit">;
 
 export type InputError = {
    name: string;
@@ -191,12 +188,12 @@ export function NativeForm({
 
       const errors = validate({ report: true });
       if (errors.length > 0) {
-         onSubmitInvalid?.(errors, { event: e, form });
+         onSubmitInvalid?.(errors, { event: e });
          return;
       }
 
       if (onSubmit) {
-         await onSubmit(getFormValues(), { event: e, form });
+         await onSubmit(getFormValues(), { event: e });
       } else {
          form.submit();
       }

app/src/ui/components/wouter/Link.tsx

@@ -1,4 +1,5 @@
-import { type LinkProps, Link as WouterLink, useRouter } from "wouter";
+import { useInsertionEffect, useRef } from "react";
+import { type LinkProps, Link as WouterLink, useRoute, useRouter } from "wouter";
 import { useEvent } from "../../hooks/use-event";
 
 /*

app/src/ui/elements/auth/AuthForm.tsx

@@ -1,16 +1,13 @@
 import type { AppAuthOAuthStrategy, AppAuthSchema } from "auth/auth-schema";
 import clsx from "clsx";
 import { NativeForm } from "ui/components/form/native-form/NativeForm";
-import { transformObject } from "bknd/utils";
-import { useEffect, useState, type ComponentPropsWithoutRef, type FormEvent } from "react";
+import { transform } from "lodash-es";
+import type { ComponentPropsWithoutRef } from "react";
 import { Button } from "ui/components/buttons/Button";
 import { Group, Input, Password, Label } from "ui/components/form/Formy/components";
 import { SocialLink } from "./SocialLink";
-import { useAuth } from "bknd/client";
-import { Alert } from "ui/components/display/Alert";
-import { useLocation } from "wouter";
 
-export type LoginFormProps = Omit<ComponentPropsWithoutRef<"form">, "action"> & {
+export type LoginFormProps = Omit<ComponentPropsWithoutRef<"form">, "onSubmit" | "action"> & {
    className?: string;
    formData?: any;
    action: "login" | "register";
@@ -26,49 +23,24 @@ export function AuthForm({
    action,
    auth,
    buttonLabel = action === "login" ? "Sign in" : "Sign up",
-   onSubmit: _onSubmit,
    ...props
 }: LoginFormProps) {
-   const $auth = useAuth();
    const basepath = auth?.basepath ?? "/api/auth";
-   const [error, setError] = useState<string>();
-   const [, navigate] = useLocation();
    const password = {
       action: `${basepath}/password/${action}`,
       strategy: auth?.strategies?.password ?? ({ type: "password" } as const),
    };
 
-   const oauth = transformObject(auth?.strategies ?? {}, (value) => {
-      return value.type !== "password" ? value.config : undefined;
-   }) as Record<string, AppAuthOAuthStrategy>;
-   const has_oauth = Object.keys(oauth).length > 0;
-
-   async function onSubmit(
-      data: any,
-      ctx: { event: FormEvent<HTMLFormElement>; form: HTMLFormElement },
-   ) {
-      if ($auth?.local) {
-         ctx.event.preventDefault();
-
-         const res = await $auth.login(data);
-         if ("token" in res) {
-            navigate("/");
-         } else {
-            setError((res as any).error);
-            return;
+   const oauth = transform(
+      auth?.strategies ?? {},
+      (result, value, key) => {
+         if (value.type !== "password") {
+            result[key] = value.config;
          }
-      }
-
-      await _onSubmit?.(ctx.event);
-      // submit form
-      ctx.form.submit();
-   }
-
-   useEffect(() => {
-      if ($auth.user) {
-         navigate("/");
-      }
-   }, [$auth.user]);
+      },
+      {},
+   ) as Record<string, AppAuthOAuthStrategy>;
+   const has_oauth = Object.keys(oauth).length > 0;
 
    return (
       <div className="flex flex-col gap-4 w-full">
@@ -91,19 +63,17 @@ export function AuthForm({
          <NativeForm
             method={method}
             action={password.action}
-            onSubmit={onSubmit}
             {...(props as any)}
             validateOn="change"
             className={clsx("flex flex-col gap-3 w-full", className)}
          >
-            {error && <Alert.Exception message={error} className="justify-center" />}
             <Group>
                <Label htmlFor="email">Email address</Label>
                <Input type="email" name="email" required />
             </Group>
             <Group>
                <Label htmlFor="password">Password</Label>
-               <Password name="password" required minLength={1} />
+               <Password name="password" required minLength={8} />
             </Group>
 
             <Button

app/src/ui/elements/auth/SocialLink.tsx

@@ -1,4 +1,4 @@
-import { ucFirstAllSnakeToPascalWithSpaces } from "bknd/utils";
+import { ucFirstAllSnakeToPascalWithSpaces } from "core/utils";
 import type { ReactNode } from "react";
 import { Button } from "ui/components/buttons/Button";
 import type { IconType } from "ui/components/buttons/IconButton";

app/src/ui/elements/hooks/use-auth.ts

@@ -1,11 +1,9 @@
 import type { AppAuthSchema } from "auth/auth-schema";
 import { useEffect, useState } from "react";
-import { useApi } from "bknd/client";
+import { useApi } from "ui/client";
 
 type AuthStrategyData = Pick<AppAuthSchema, "strategies" | "basepath">;
-export const useAuthStrategies = (options?: {
-   baseUrl?: string;
-}): Partial<AuthStrategyData> & {
+export const useAuthStrategies = (options?: { baseUrl?: string }): Partial<AuthStrategyData> & {
    loading: boolean;
 } => {
    const [data, setData] = useState<AuthStrategyData>();

app/src/ui/elements/media/Dropzone.tsx

@@ -14,7 +14,7 @@ import { isFileAccepted } from "bknd/utils";
 import { type FileWithPath, useDropzone } from "./use-dropzone";
 import { checkMaxReached } from "./helper";
 import { DropzoneInner } from "./DropzoneInner";
-import { createDropzoneStore } from "./dropzone-state";
+import { createDropzoneStore } from "ui/elements/media/dropzone-state";
 import { useStore } from "zustand";
 
 export type FileState = {

app/src/ui/elements/media/DropzoneContainer.tsx

@@ -1,8 +1,9 @@
+import type { Api } from "bknd/client";
 import type { PrimaryFieldType, RepoQueryIn } from "bknd";
 import type { MediaFieldSchema } from "media/AppMedia";
 import type { TAppMediaConfig } from "media/media-schema";
 import { useId, useEffect, useRef, useState } from "react";
-import { type Api, useApi, useApiInfiniteQuery, useApiQuery, useInvalidate } from "bknd/client";
+import { useApi, useApiInfiniteQuery, useApiQuery, useInvalidate } from "bknd/client";
 import { useEvent } from "ui/hooks/use-event";
 import { Dropzone, type DropzoneProps } from "./Dropzone";
 import { mediaItemsToFileStates } from "./helper";
@@ -131,24 +132,26 @@ export function DropzoneContainer({
    }
 
    return (
-      <Dropzone
-         key={key}
-         getUploadInfo={getUploadInfo}
-         handleDelete={handleDelete}
-         autoUpload
-         initialItems={_initialItems}
-         footer={
-            infinite &&
-            "setSize" in $q && (
-               <Footer
-                  items={_initialItems.length}
-                  length={placeholderLength}
-                  onFirstVisible={() => $q.setSize($q.size + 1)}
-               />
-            )
-         }
-         {...props}
-      />
+      <>
+         <Dropzone
+            key={key}
+            getUploadInfo={getUploadInfo}
+            handleDelete={handleDelete}
+            autoUpload
+            initialItems={_initialItems}
+            footer={
+               infinite &&
+               "setSize" in $q && (
+                  <Footer
+                     items={_initialItems.length}
+                     length={placeholderLength}
+                     onFirstVisible={() => $q.setSize($q.size + 1)}
+                  />
+               )
+            }
+            {...props}
+         />
+      </>
    );
 }
 

app/src/ui/elements/media/DropzoneInner.tsx

@@ -19,8 +19,8 @@ import {
 } from "react-icons/tb";
 import { Dropdown, type DropdownItem } from "ui/components/overlay/Dropdown";
 import { IconButton } from "ui/components/buttons/IconButton";
-import { formatNumber } from "bknd/utils";
-import type { DropzoneRenderProps, FileState } from "./Dropzone";
+import { formatNumber } from "core/utils";
+import type { DropzoneRenderProps, FileState } from "ui/elements";
 import { useDropzoneFileState, useDropzoneState } from "./Dropzone";
 
 function handleUploadError(e: unknown) {

app/src/ui/layouts/AppShell/AppShell.tsx

@@ -474,7 +474,6 @@ type SectionHeaderAccordionItemProps = {
    ActiveIcon?: any;
    children?: React.ReactNode;
    renderHeaderRight?: (props: { open: boolean }) => React.ReactNode;
-   scrollContainerRef?: React.RefObject<HTMLDivElement>;
 };
 
 export const SectionHeaderAccordionItem = ({
@@ -484,7 +483,6 @@ export const SectionHeaderAccordionItem = ({
    ActiveIcon = IconChevronUp,
    children,
    renderHeaderRight,
-   scrollContainerRef,
 }: SectionHeaderAccordionItemProps) => (
    <div
       style={{ minHeight: 49 }}
@@ -495,8 +493,6 @@ export const SectionHeaderAccordionItem = ({
             : "flex-initial cursor-pointer hover:bg-primary/5",
       )}
    >
-      {/** biome-ignore lint/a11y/noStaticElementInteractions: . */}
-      {/** biome-ignore lint/a11y/useKeyWithClickEvents: . */}
       <div
          className={twMerge(
             "flex flex-row bg-muted/10 border-muted border-b h-14 py-4 pr-4 pl-2 items-center gap-2",
@@ -505,12 +501,14 @@ export const SectionHeaderAccordionItem = ({
       >
          <IconButton Icon={open ? ActiveIcon : IconChevronDown} disabled={open} />
          <h2 className="text-lg dark:font-bold font-semibold select-text">{title}</h2>
-         <div className="flex grow" />
+         <div className="flex flex-grow" />
          {renderHeaderRight?.({ open })}
       </div>
       <div
-         ref={scrollContainerRef}
-         className={twMerge("overflow-y-scroll transition-all", open ? " grow" : "h-0 opacity-0")}
+         className={twMerge(
+            "overflow-y-scroll transition-all",
+            open ? " flex-grow" : "h-0 opacity-0",
+         )}
       >
          {children}
       </div>
@@ -520,25 +518,14 @@ export const SectionHeaderAccordionItem = ({
 export const RouteAwareSectionHeaderAccordionItem = ({
    routePattern,
    identifier,
-   renderHeaderRight,
    ...props
-}: Omit<SectionHeaderAccordionItemProps, "open" | "toggle" | "renderHeaderRight"> & {
-   renderHeaderRight?: (props: { open: boolean; active: boolean }) => React.ReactNode;
+}: Omit<SectionHeaderAccordionItemProps, "open" | "toggle"> & {
    // it's optional because it could be provided using the context
    routePattern?: string;
    identifier: string;
 }) => {
    const { active, toggle } = useRoutePathState(routePattern, identifier);
-   return (
-      <SectionHeaderAccordionItem
-         {...props}
-         open={active}
-         toggle={toggle}
-         renderHeaderRight={
-            renderHeaderRight && ((props) => renderHeaderRight?.({ open: props.open, active }))
-         }
-      />
-   );
+   return <SectionHeaderAccordionItem {...props} open={active} toggle={toggle} />;
 };
 
 export const Separator = ({ className, ...props }: ComponentPropsWithoutRef<"hr">) => (

app/src/ui/layouts/AppShell/Header.tsx

@@ -1,4 +1,4 @@
-import { SegmentedControl } from "@mantine/core";
+import { SegmentedControl, Tooltip } from "@mantine/core";
 import { IconApi, IconBook, IconKeyOff, IconSettings, IconUser } from "@tabler/icons-react";
 import {
    TbDatabase,
@@ -10,7 +10,7 @@ import {
    TbUser,
    TbX,
 } from "react-icons/tb";
-import { useAuth, useBkndWindowContext } from "bknd/client";
+import { useAuth, useBkndWindowContext } from "ui/client";
 import { useBknd } from "ui/client/bknd";
 import { useTheme } from "ui/client/use-theme";
 import { Button } from "ui/components/buttons/Button";
@@ -24,35 +24,34 @@ import { useLocation } from "wouter";
 import { NavLink } from "./AppShell";
 import { autoFormatString } from "core/utils";
 import { appShellStore } from "ui/store";
-import { getVersion, isDebug } from "core/env";
+import { getVersion } from "core/env";
 import { McpIcon } from "ui/routes/tools/mcp/components/mcp-icon";
 import { useAppShellAdminOptions } from "ui/options";
 
 export function HeaderNavigation() {
    const [location, navigate] = useLocation();
-   const { config } = useBknd();
 
    const items: {
       label: string;
       href: string;
-      Icon?: any;
+      Icon: any;
       exact?: boolean;
       tooltip?: string;
       disabled?: boolean;
    }[] = [
+      /*{
+         label: "Base",
+         href: "#",
+         exact: true,
+         Icon: TbLayoutDashboard,
+         disabled: true,
+         tooltip: "Coming soon"
+      },*/
       { label: "Data", href: "/data", Icon: TbDatabase },
       { label: "Auth", href: "/auth", Icon: TbFingerprint },
       { label: "Media", href: "/media", Icon: TbPhoto },
+      { label: "Flows", href: "/flows", Icon: TbHierarchy2 },
    ];
-
-   if (isDebug() || Object.keys(config.flows?.flows ?? {}).length > 0) {
-      items.push({ label: "Flows", href: "/flows", Icon: TbHierarchy2 });
-   }
-
-   if (config.server.mcp.enabled) {
-      items.push({ label: "MCP", href: "/tools/mcp", Icon: McpIcon });
-   }
-
    const activeItem = items.find((item) =>
       item.exact ? location === item.href : location.startsWith(item.href),
    );
@@ -155,10 +154,8 @@ function UserMenu() {
 
    async function handleLogout() {
       await auth.logout();
-
-      if (!auth.local) {
-         navigate(logout_route, { reload: true });
-      }
+      // @todo: grab from somewhere constant
+      navigate(logout_route, { reload: true });
    }
 
    async function handleLogin() {

app/src/ui/modals/media/MediaInfoModal.tsx

@@ -1,6 +1,6 @@
 import type { ContextModalProps } from "@mantine/modals";
 import { type ReactNode, useEffect, useMemo, useState } from "react";
-import { useEntityQuery } from "bknd/client";
+import { useEntityQuery } from "ui/client";
 import { type FileState, Media } from "ui/elements";
 import { autoFormatString, datetimeStringLocal, formatNumber } from "core/utils";
 import { twMerge } from "tailwind-merge";

app/src/ui/modules/auth/hooks/use-create-user-modal.ts

@@ -1,4 +1,4 @@
-import { useApi, useInvalidate } from "bknd/client";
+import { useApi, useInvalidate } from "ui/client";
 import { useBkndAuth } from "ui/client/schema/auth/use-bknd-auth";
 import { routes, useNavigate } from "ui/lib/routes";
 import { bkndModals } from "ui/modals";

app/src/ui/modules/data/components/fields/EntityRelationalFormField.tsx

@@ -4,7 +4,7 @@ import type { EntityData } from "bknd";
 import type { RelationField } from "data/relations";
 import { useEffect, useRef, useState } from "react";
 import { TbEye } from "react-icons/tb";
-import { useEntityQuery } from "bknd/client";
+import { useEntityQuery } from "ui/client";
 import { useBknd } from "ui/client/bknd";
 import { Button } from "ui/components/buttons/Button";
 import * as Formy from "ui/components/form/Formy";

app/src/ui/routes/auth/auth.index.tsx

@@ -1,6 +1,6 @@
 import clsx from "clsx";
 import { TbArrowRight, TbCircle, TbCircleCheckFilled, TbFingerprint } from "react-icons/tb";
-import { useApiQuery } from "bknd/client";
+import { useApiQuery } from "ui/client";
 import { useBknd } from "ui/client/bknd";
 import { useBkndAuth } from "ui/client/schema/auth/use-bknd-auth";
 import { ButtonLink, type ButtonLinkProps } from "ui/components/buttons/Button";

app/src/ui/routes/auth/auth.roles.edit.$role.tsx

@@ -35,7 +35,7 @@ import { SegmentedControl, Tooltip } from "@mantine/core";
 import { Popover } from "ui/components/overlay/Popover";
 import { cn } from "ui/lib/utils";
 import { JsonViewer } from "ui/components/code/JsonViewer";
-import { mountOnce, useApiQuery } from "bknd/client";
+import { mountOnce, useApiQuery } from "ui/client";
 import { CodePreview } from "ui/components/code/CodePreview";
 import type { JsonError } from "json-schema-library";
 import { Alert } from "ui/components/display/Alert";
@@ -378,7 +378,11 @@ function replaceEntitiesEnum(schema: Record<string, any>, entities: string[]) {
    });
 }
 
-const Policy = ({ permission }: { permission: TPermission }) => {
+const Policy = ({
+   permission,
+}: {
+   permission: TPermission;
+}) => {
    const { value } = useDerivedFieldContext("", ({ value }) => ({
       effect: (value?.effect ?? "allow") as "allow" | "deny" | "filter",
    }));
@@ -499,24 +503,22 @@ const CustomFieldWrapper = ({
                         className: "max-w-none",
                      }}
                      position="bottom-end"
-                     target={() => (
-                        <div className="w-auto max-w-[80vw] md:max-w-120 bg-background overflow-scroll">
-                           {typeof schema.content === "object" ? (
-                              <JsonViewer
-                                 className="pr-3 text-sm"
-                                 json={schema.content}
-                                 title={schema.name}
-                                 expand={5}
-                              />
-                           ) : (
-                              <CodePreview
-                                 code={schema.content}
-                                 lang="typescript"
-                                 className="p-3 text-sm"
-                              />
-                           )}
-                        </div>
-                     )}
+                     target={() =>
+                        typeof schema.content === "object" ? (
+                           <JsonViewer
+                              className="w-auto max-w-120 bg-background pr-3 text-sm"
+                              json={schema.content}
+                              title={schema.name}
+                              expand={5}
+                           />
+                        ) : (
+                           <CodePreview
+                              code={schema.content}
+                              lang="typescript"
+                              className="w-auto max-w-120 bg-background p-3 text-sm"
+                           />
+                        )
+                     }
                   >
                      <Button variant="ghost" size="smaller" IconLeft={TbCodeDots}>
                         {autoFormatString(schema.name)}

app/src/ui/routes/data/data.$entity.$id.tsx

@@ -3,7 +3,7 @@ import { ucFirst } from "bknd/utils";
 import type { Entity, EntityData, EntityRelation } from "bknd";
 import { Fragment, useState } from "react";
 import { TbDots } from "react-icons/tb";
-import { useApiQuery, useEntityQuery } from "bknd/client";
+import { useApiQuery, useEntityQuery } from "ui/client";
 import { useBkndData } from "ui/client/schema/data/use-bknd-data";
 import { Button } from "ui/components/buttons/Button";
 import { IconButton } from "ui/components/buttons/IconButton";

app/src/ui/routes/data/data.$entity.create.tsx

@@ -1,6 +1,6 @@
 import type { EntityData } from "bknd";
 import { useState } from "react";
-import { useEntityMutate } from "bknd/client";
+import { useEntityMutate } from "ui/client";
 import { useBkndData } from "ui/client/schema/data/use-bknd-data";
 import { Button } from "ui/components/buttons/Button";
 import { Message } from "ui/components/display/Message";

app/src/ui/routes/data/data.$entity.index.tsx

@@ -2,7 +2,7 @@ import type { Entity } from "bknd";
 import { repoQuery } from "data/server/query";
 import { Fragment } from "react";
 import { TbDots } from "react-icons/tb";
-import { useApiQuery } from "bknd/client";
+import { useApiQuery } from "ui/client";
 import { useBknd } from "ui/client/bknd";
 import { useBkndData } from "ui/client/schema/data/use-bknd-data";
 import { Button } from "ui/components/buttons/Button";

app/src/ui/routes/data/forms/entity.fields.form.tsx

@@ -5,12 +5,12 @@ import {
    ucFirstAllSnakeToPascalWithSpaces,
    s,
    stringIdentifier,
-   pickKeys,
 } from "bknd/utils";
 import {
    type TAppDataEntityFields,
    fieldsSchemaObject as originalFieldsSchemaObject,
 } from "data/data-schema";
+import { omit } from "lodash-es";
 import { forwardRef, memo, useEffect, useImperativeHandle } from "react";
 import { type FieldArrayWithId, type UseFormReturn, useFieldArray, useForm } from "react-hook-form";
 import { TbGripVertical, TbSettings, TbTrash } from "react-icons/tb";
@@ -317,6 +317,7 @@ function EntityField({
    const name = watch(`fields.${index}.name`);
    const { active, toggle } = useRoutePathState(routePattern ?? "", name);
    const fieldSpec = fieldSpecs.find((s) => s.type === type)!;
+   const specificData = omit(field.field.config, commonProps);
    const disabled = fieldSpec.disabled || [];
    const hidden = fieldSpec.hidden || [];
    const dragDisabled = index === 0;
@@ -475,7 +476,7 @@ function EntityField({
                               field={field}
                               onChange={(value) => {
                                  setValue(`${prefix}.config`, {
-                                    ...pickKeys(getValues([`${prefix}.config`])[0], commonProps),
+                                    ...getValues([`fields.${index}.config`])[0],
                                     ...value,
                                  });
                               }}
@@ -519,7 +520,7 @@ const SpecificForm = ({
    readonly?: boolean;
 }) => {
    const type = field.field.type;
-   const specificData = omitKeys(field.field.config ?? {}, commonProps);
+   const specificData = omit(field.field.config, commonProps);
 
    return (
       <JsonSchemaForm

app/src/ui/routes/index.tsx

@@ -11,14 +11,11 @@ import SettingsRoutes from "./settings";
 import { FlashMessage } from "ui/modules/server/FlashMessage";
 import { AuthRegister } from "ui/routes/auth/auth.register";
 import { BkndModalsProvider } from "ui/modals";
-import { useBkndWindowContext } from "bknd/client";
+import { useBkndWindowContext } from "ui/client";
 import ToolsRoutes from "./tools";
 
 // @ts-ignore
-let TestRoutes: any;
-if (import.meta.env.DEV) {
-   TestRoutes = lazy(() => import("./test"));
-}
+const TestRoutes = lazy(() => import("./test"));
 
 export function Routes({
    BkndWrapper,
@@ -46,13 +43,11 @@ export function Routes({
                      <Route path="/" nest>
                         <Root>
                            <Switch>
-                              {TestRoutes && (
-                                 <Route path="/test*" nest>
-                                    <Suspense fallback={null}>
-                                       <TestRoutes />
-                                    </Suspense>
-                                 </Route>
-                              )}
+                              <Route path="/test*" nest>
+                                 <Suspense fallback={null}>
+                                    <TestRoutes />
+                                 </Suspense>
+                              </Route>
 
                               {children}
 

app/src/ui/routes/media/media.index.tsx

@@ -1,12 +1,11 @@
 import { IconPhoto } from "@tabler/icons-react";
 import { useBknd } from "ui/client/BkndProvider";
 import { Empty } from "ui/components/display/Empty";
+import { type FileState, Media } from "ui/elements";
 import { useBrowserTitle } from "ui/hooks/use-browser-title";
 import * as AppShell from "ui/layouts/AppShell/AppShell";
 import { useLocation } from "wouter";
 import { bkndModals } from "ui/modals";
-import { DropzoneContainer } from "ui/elements/media/DropzoneContainer";
-import type { FileState } from "ui/elements/media/Dropzone";
 
 export function MediaIndex() {
    const { config } = useBknd();
@@ -36,7 +35,7 @@ export function MediaIndex() {
    return (
       <AppShell.Scrollable>
          <div className="flex flex-1 p-3">
-            <DropzoneContainer onClick={onClick} infinite query={{ sort: "-id" }} />
+            <Media.Dropzone onClick={onClick} infinite query={{ sort: "-id" }} />
          </div>
       </AppShell.Scrollable>
    );

app/src/ui/routes/root.tsx

@@ -1,6 +1,6 @@
 import { IconHome } from "@tabler/icons-react";
 import { useEffect } from "react";
-import { useAuth } from "bknd/client";
+import { useAuth } from "ui/client";
 import { useEffectOnce } from "ui/hooks/use-effect";
 import { Empty } from "../components/display/Empty";
 import { useBrowserTitle } from "../hooks/use-browser-title";

app/src/ui/routes/settings/routes/auth.settings.tsx

@@ -49,21 +49,19 @@ export const AuthSettings = ({ schema: _unsafe_copy, config }) => {
    try {
       const user_entity = config.entity_name ?? "users";
       const entities = _s.config.data.entities ?? {};
+      console.log("entities", entities, user_entity);
       const user_fields = Object.entries(entities[user_entity]?.fields ?? {})
          .map(([name, field]) => (!field.config?.virtual ? name : undefined))
          .filter(Boolean);
 
       if (user_fields.length > 0) {
+         console.log("user_fields", user_fields);
          _schema.properties.jwt.properties.fields.items.enum = user_fields;
          _schema.properties.jwt.properties.fields.uniqueItems = true;
          uiSchema.jwt.fields["ui:widget"] = "checkboxes";
       }
-
-      const roles = Object.keys(config.roles ?? {});
-      if (roles.length > 0) {
-         _schema.properties.default_role_register.enum = roles;
-      }
-   } catch (_e) {}
+   } catch (e) {}
+   console.log("_s", _s);
    const roleSchema = _schema.properties.roles?.additionalProperties ?? { type: "object" };
    /* if (_s.permissions) {
       roleSchema.properties.permissions.items.enum = _s.permissions;

app/src/ui/routes/test/tests/swr-and-api.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { useApi, useApiQuery } from "bknd/client";
+import { useApi, useApiQuery } from "ui/client";
 import { Scrollable } from "ui/layouts/AppShell/AppShell";
 
 function Bla() {

app/src/ui/routes/tools/index.tsx

@@ -6,7 +6,7 @@ export default function ToolsRoutes() {
    return (
       <>
          <Route path="/" component={ToolsIndex} />
-         <Route path="/mcp*" component={ToolsMcp} nest />
+         <Route path="/mcp" component={ToolsMcp} />
       </>
    );
 }

app/src/ui/routes/tools/mcp/hooks/use-mcp-client.ts

@@ -1,5 +1,4 @@
 import { McpClient, type McpClientConfig } from "jsonv-ts/mcp";
-import { useApi } from "bknd/client";
 import { useBknd } from "ui/client/bknd";
 
 const clients = new Map<string, McpClient>();
@@ -13,14 +12,5 @@ export function getClient(opts: McpClientConfig) {
 
 export function useMcpClient() {
    const { config } = useBknd();
-   const api = useApi();
-   const token = api.getAuthState().token;
-   const headers =
-      api.token_transport === "header" && token ? { Authorization: `Bearer ${token}` } : undefined;
-
-   return getClient({
-      url: window.location.origin + config.server.mcp.path,
-      fetch: api.fetcher,
-      headers,
-   });
+   return getClient({ url: window.location.origin + config.server.mcp.path });
 }

app/src/ui/routes/tools/mcp/mcp.tsx

@@ -8,13 +8,14 @@ import { Empty } from "ui/components/display/Empty";
 import { Button } from "ui/components/buttons/Button";
 import { appShellStore } from "ui/store";
 import { useBrowserTitle } from "ui/hooks/use-browser-title";
-import { RoutePathStateProvider } from "ui/hooks/use-route-path-state";
-import { Route, Switch } from "wouter";
 
 export default function ToolsMcp() {
    useBrowserTitle(["MCP UI"]);
 
-   const { config } = useBknd();
+   const { config, options } = useBknd();
+   const feature = useMcpStore((state) => state.feature);
+   const setFeature = useMcpStore((state) => state.setFeature);
+   const content = useMcpStore((state) => state.content);
    const openSidebar = appShellStore((store) => store.toggleSidebar("default"));
    const mcpPath = config.server.mcp.path;
 
@@ -28,57 +29,51 @@ export default function ToolsMcp() {
    }
 
    return (
-      <RoutePathStateProvider path={"/:type?"} defaultIdentifier="tools">
-         <div className="flex flex-col flex-grow max-w-screen">
-            <AppShell.SectionHeader>
-               <div className="flex flex-row gap-4 items-center">
-                  <McpIcon />
-                  <AppShell.SectionHeaderTitle className="whitespace-nowrap truncate">
-                     MCP UI
-                  </AppShell.SectionHeaderTitle>
-                  <div className="hidden md:flex flex-row gap-2 items-center bg-primary/5 rounded-full px-3 pr-3.5 py-2">
-                     <TbWorld />
-                     <div className="min-w-0 flex-1">
-                        <span className="block truncate text-sm font-mono leading-none select-text">
-                           {window.location.origin + mcpPath}
-                        </span>
-                     </div>
+      <div className="flex flex-col flex-grow max-w-screen">
+         <AppShell.SectionHeader>
+            <div className="flex flex-row gap-4 items-center">
+               <McpIcon />
+               <AppShell.SectionHeaderTitle className="whitespace-nowrap truncate">
+                  MCP UI
+               </AppShell.SectionHeaderTitle>
+               <div className="hidden md:flex flex-row gap-2 items-center bg-primary/5 rounded-full px-3 pr-3.5 py-2">
+                  <TbWorld />
+                  <div className="min-w-0 flex-1">
+                     <span className="block truncate text-sm font-mono leading-none select-text">
+                        {window.location.origin + mcpPath}
+                     </span>
                   </div>
                </div>
-            </AppShell.SectionHeader>
-
-            <div className="flex grow h-full">
-               <AppShell.Sidebar>
-                  <Tools.Sidebar />
-                  <AppShell.RouteAwareSectionHeaderAccordionItem
-                     title="Resources"
-                     identifier="resources"
-                  >
-                     <div className="flex flex-col flex-grow p-3 gap-3 justify-center items-center opacity-40">
-                        <i>Resources</i>
-                     </div>
-                  </AppShell.RouteAwareSectionHeaderAccordionItem>
-               </AppShell.Sidebar>
-
-               <Switch>
-                  <Route path="/tools/:toolName?" component={Tools.Content} />
-                  <Route path="*">
-                     <Empty
-                        title="No tool selected"
-                        description="Please select a tool to continue."
-                     >
-                        <Button
-                           variant="primary"
-                           onClick={() => openSidebar()}
-                           className="block md:hidden"
-                        >
-                           Open Tools
-                        </Button>
-                     </Empty>
-                  </Route>
-               </Switch>
             </div>
+         </AppShell.SectionHeader>
+
+         <div className="flex h-full">
+            <AppShell.Sidebar>
+               <Tools.Sidebar open={feature === "tools"} toggle={() => setFeature("tools")} />
+               <AppShell.SectionHeaderAccordionItem
+                  title="Resources"
+                  open={feature === "resources"}
+                  toggle={() => setFeature("resources")}
+               >
+                  <div className="flex flex-col flex-grow p-3 gap-3 justify-center items-center opacity-40">
+                     <i>Resources</i>
+                  </div>
+               </AppShell.SectionHeaderAccordionItem>
+            </AppShell.Sidebar>
+            {feature === "tools" && <Tools.Content />}
+
+            {!content && (
+               <Empty title="No tool selected" description="Please select a tool to continue.">
+                  <Button
+                     variant="primary"
+                     onClick={() => openSidebar()}
+                     className="block md:hidden"
+                  >
+                     Open Tools
+                  </Button>
+               </Empty>
+            )}
          </div>
-      </RoutePathStateProvider>
+      </div>
    );
 }