fixing tests, move node tests to vitest

app/__test__/adapter/adapter.test.ts

@@ -3,21 +3,36 @@ import * as adapter from "adapter";
 import { disableConsoleLog, enableConsoleLog } from "core/utils";
 import { adapterTestSuite } from "adapter/adapter-test-suite";
 import { bunTestRunner } from "adapter/bun/test";
+import { omitKeys } from "core/utils";
 
 beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
 
 describe("adapter", () => {
    it("makes config", () => {
-      expect(adapter.makeConfig({})).toEqual({});
-      expect(adapter.makeConfig({}, { env: { TEST: "test" } })).toEqual({});
+      expect(omitKeys(adapter.makeConfig({}), ["connection"])).toEqual({});
+      expect(omitKeys(adapter.makeConfig({}, { env: { TEST: "test" } }), ["connection"])).toEqual(
+         {},
+      );
 
       // merges everything returned from `app` with the config
-      expect(adapter.makeConfig({ app: (a) => a as any }, { env: { TEST: "test" } })).toEqual({
-         env: { TEST: "test" },
-      } as any);
+      expect(
+         omitKeys(
+            adapter.makeConfig(
+               { app: (a) => ({ initialConfig: { server: { cors: { origin: a.env.TEST } } } }) },
+               { env: { TEST: "test" } },
+            ),
+            ["connection"],
+         ),
+      ).toEqual({
+         initialConfig: { server: { cors: { origin: "test" } } },
+      });
    });
 
+   /* it.only("...", async () => {
+      const app = await adapter.createAdapterApp();
+   }); */
+
    it("reuses apps correctly", async () => {
       const id = crypto.randomUUID();
 

app/__test__/app/App.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, mock, test } from "bun:test";
 import type { ModuleBuildContext } from "../../src";
-import { App, createApp } from "../../src/App";
+import { App, createApp } from "core/test/utils";
 import * as proto from "../../src/data/prototype";
 
 describe("App", () => {

app/__test__/app/repro.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { createApp, registries } from "../../src";
+import { registries } from "../../src";
+import { createApp } from "core/test/utils";
 import * as proto from "../../src/data/prototype";
 import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
 

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "bun:test";
-import { createApp } from "../../src";
+import { createApp } from "core/test/utils";
 import { Api } from "../../src/Api";
 
 describe("integration config", () => {

app/__test__/media/MediaController.spec.ts

@@ -1,7 +1,8 @@
 /// <reference types="@types/bun" />
 
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { createApp, registries } from "../../src";
+import { registries } from "../../src";
+import { createApp } from "core/test/utils";
 import { mergeObject, randomString } from "../../src/core/utils";
 import type { TAppMediaConfig } from "../../src/media/media-schema";
 import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";

app/__test__/modules/AppAuth.spec.ts

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import { createApp } from "../../src";
+import { createApp } from "core/test/utils";
 import { AuthController } from "../../src/auth/api/AuthController";
 import { em, entity, make, text } from "../../src/data";
 import { AppAuth, type ModuleBuildContext } from "../../src/modules";

app/__test__/modules/AppMedia.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { createApp, registries } from "../../src";
+import { registries } from "../../src";
+import { createApp } from "core/test/utils";
 import { em, entity, text } from "../../src/data";
 import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
 import { AppMedia } from "../../src/modules";

app/package.json

@@ -31,11 +31,9 @@
     "test": "ALL_TESTS=1 bun test --bail",
     "test:all": "bun run test && bun run test:node",
     "test:bun": "ALL_TESTS=1 bun test --bail",
-    "test:node": "tsx --test $(find . -type f -name '*.native-spec.ts')",
+    "test:node": "vitest run",
     "test:adapters": "bun test src/adapter/**/*.adapter.spec.ts --bail",
     "test:coverage": "ALL_TESTS=1 bun test --bail --coverage",
-    "test:vitest": "vitest run",
-    "test:vitest:watch": "vitest",
     "test:vitest:coverage": "vitest run --coverage",
     "test:e2e": "playwright test",
     "test:e2e:adapters": "bun run e2e/adapters.ts",
@@ -73,14 +71,15 @@
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@libsql/client": "^0.15.9",
     "@aws-sdk/client-s3": "^3.758.0",
     "@bluwy/giget-core": "^0.1.2",
+    "@cloudflare/vitest-pool-workers": "^0.8.38",
     "@cloudflare/workers-types": "^4.20250606.0",
     "@dagrejs/dagre": "^1.1.4",
     "@hono/typebox-validator": "^0.3.3",
     "@hono/vite-dev-server": "^0.19.1",
     "@hookform/resolvers": "^4.1.3",
+    "@libsql/client": "^0.15.9",
     "@libsql/kysely-libsql": "^0.4.1",
     "@mantine/modals": "^7.17.1",
     "@mantine/notifications": "^7.17.1",

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

@@ -1,17 +1,11 @@
 /// <reference types="bun-types" />
 
 import path from "node:path";
-import {
-   type RuntimeBkndConfig,
-   createRuntimeApp,
-   type RuntimeOptions,
-   Connection,
-} from "bknd/adapter";
+import { type RuntimeBkndConfig, createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
 import { registerLocalMediaAdapter } from ".";
 import { config } from "bknd/core";
 import type { ServeOptions } from "bun";
 import { serveStatic } from "hono/bun";
-import { sqlite } from "bknd/adapter/sqlite";
 import type { App } from "App";
 
 type BunEnv = Bun.Env;
@@ -25,17 +19,9 @@ export async function createApp<Env = BunEnv>(
    const root = path.resolve(distPath ?? "./node_modules/bknd/dist", "static");
    registerLocalMediaAdapter();
 
-   let connection: Connection | undefined;
-   if (Connection.isConnection(config.connection)) {
-      connection = config.connection;
-   } else {
-      connection = sqlite(config.connection ?? { url: ":memory:" });
-   }
-
    return await createRuntimeApp(
       {
          ...config,
-         connection,
          serveStatic: serveStatic({ root }),
       },
       args ?? (process.env as Env),

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

@@ -13,30 +13,32 @@ describe("cf adapter", () => {
    const DB_URL = ":memory:";
    const $ctx = (env?: any, request?: Request, ctx?: ExecutionContext) => ({
       request: request ?? (null as any),
-      env: env ?? { DB_URL },
+      env: env ?? { url: DB_URL },
       ctx: ctx ?? (null as any),
    });
 
    it("makes config", async () => {
-      expect(
-         makeConfig(
-            {
-               connection: { url: DB_URL },
-            },
-            $ctx({ DB_URL }),
-         ),
-      ).toEqual({ connection: { url: DB_URL } });
+      const staticConfig = makeConfig(
+         {
+            connection: { url: DB_URL },
+            initialConfig: { data: { basepath: DB_URL } },
+         },
+         $ctx({ DB_URL }),
+      );
+      expect(staticConfig.initialConfig).toEqual({ data: { basepath: DB_URL } });
+      expect(staticConfig.connection).toBeDefined();
 
-      expect(
-         makeConfig(
-            {
-               app: (env) => ({
-                  connection: { url: env.DB_URL },
-               }),
-            },
-            $ctx({ DB_URL }),
-         ),
-      ).toEqual({ connection: { url: DB_URL } });
+      const dynamicConfig = makeConfig(
+         {
+            app: (env) => ({
+               initialConfig: { data: { basepath: env.DB_URL } },
+               connection: { url: env.DB_URL },
+            }),
+         },
+         $ctx({ DB_URL }),
+      );
+      expect(dynamicConfig.initialConfig).toEqual({ data: { basepath: DB_URL } });
+      expect(dynamicConfig.connection).toBeDefined();
    });
 
    adapterTestSuite<CloudflareBkndConfig, CfMakeConfigArgs<any>>(bunTestRunner, {

app/src/adapter/cloudflare/config.ts

@@ -9,6 +9,7 @@ import { makeConfig as makeAdapterConfig } from "bknd/adapter";
 import type { Context, ExecutionContext } from "hono";
 import { $console } from "core";
 import { setCookie } from "hono/cookie";
+import { sqlite } from "bknd/adapter/sqlite";
 
 export const constants = {
    exec_async_event_id: "cf_register_waituntil",
@@ -98,54 +99,70 @@ export function makeConfig<Env extends CloudflareEnv = CloudflareEnv>(
 
    const appConfig = makeAdapterConfig(config, args?.env);
 
-   if (args?.env) {
-      const bindings = config.bindings?.(args?.env);
+   // if connection instance is given, don't do anything
+   // other than checking if D1 session is defined
+   if (D1Connection.isConnection(appConfig.connection)) {
+      if (config.d1?.session) {
+         // we cannot guarantee that db was opened with session
+         throw new Error(
+            "D1 session don't work when D1 is directly given as connection. Define it in bindings instead.",
+         );
+      }
+      // if connection is given, try to open with unified sqlite adapter
+   } else if (appConfig.connection) {
+      appConfig.connection = sqlite(appConfig.connection);
 
+      // if connection is not given, but env is set
+      // try to make D1 from bindings
+   } else if (args?.env) {
+      const bindings = config.bindings?.(args?.env);
       const sessionHelper = d1SessionHelper(config);
       const sessionId = sessionHelper.get(args.request);
       let session: D1DatabaseSession | undefined;
+      let db: D1Database | undefined;
 
-      if (!appConfig.connection) {
-         let db: D1Database | undefined;
-         if (bindings?.db) {
-            $console.log("Using database from bindings");
-            db = bindings.db;
-         } else if (Object.keys(args).length > 0) {
-            const binding = getBinding(args.env, "D1Database");
-            if (binding) {
-               $console.log(`Using database from env "${binding.key}"`);
-               db = binding.value;
-            }
-         }
+      // if db is given in bindings, use it
+      if (bindings?.db) {
+         $console.log("Using database from bindings");
+         db = bindings.db;
 
-         if (db) {
-            if (config.d1?.session) {
-               session = db.withSession(sessionId ?? config.d1?.first);
-               appConfig.connection = new D1Connection({ binding: session });
-            } else {
-               appConfig.connection = new D1Connection({ binding: db });
-            }
-         } else {
-            throw new Error("No database connection given");
+         // scan for D1Database in args
+      } else {
+         const binding = getBinding(args.env, "D1Database");
+         if (binding) {
+            $console.log(`Using database from env "${binding.key}"`);
+            db = binding.value;
          }
       }
 
-      if (config.d1?.session) {
-         appConfig.options = {
-            ...appConfig.options,
-            manager: {
-               ...appConfig.options?.manager,
-               onServerInit: (server) => {
-                  server.use(async (c, next) => {
-                     sessionHelper.set(c, session);
-                     await next();
-                  });
+      // if db is found, check if session is requested
+      if (db) {
+         if (config.d1?.session) {
+            session = db.withSession(sessionId ?? config.d1?.first);
+
+            appConfig.connection = new D1Connection({ binding: session });
+            appConfig.options = {
+               ...appConfig.options,
+               manager: {
+                  ...appConfig.options?.manager,
+                  onServerInit: (server) => {
+                     server.use(async (c, next) => {
+                        sessionHelper.set(c, session);
+                        await next();
+                     });
+                  },
                },
-            },
-         };
+            };
+         } else {
+            appConfig.connection = new D1Connection({ binding: db });
+         }
       }
    }
 
+   if (!D1Connection.isConnection(appConfig.connection)) {
+      throw new Error("Couldn't find database connection");
+   }
+
    return appConfig;
 }
 

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

@@ -1,32 +0,0 @@
-import { createWriteStream, readFileSync } from "node:fs";
-import { test } from "node:test";
-import { Miniflare } from "miniflare";
-import { StorageR2Adapter } from "./StorageR2Adapter";
-import { adapterTestSuite } from "media";
-import { nodeTestRunner } from "adapter/node/test";
-import path from "node:path";
-
-// https://github.com/nodejs/node/issues/44372#issuecomment-1736530480
-console.log = async (message: any) => {
-   const tty = createWriteStream("/dev/tty");
-   const msg = typeof message === "string" ? message : JSON.stringify(message, null, 2);
-   return tty.write(`${msg}\n`);
-};
-
-test("StorageR2Adapter", async () => {
-   const mf = new Miniflare({
-      modules: true,
-      script: "export default { async fetch() { return new Response(null); } }",
-      r2Buckets: ["BUCKET"],
-   });
-
-   const bucket = (await mf.getR2Bucket("BUCKET")) as unknown as R2Bucket;
-   const adapter = new StorageR2Adapter(bucket);
-
-   const basePath = path.resolve(import.meta.dirname, "../../../../__test__/_assets");
-   const buffer = readFileSync(path.join(basePath, "image.png"));
-   const file = new File([buffer], "image.png", { type: "image/png" });
-
-   await adapterTestSuite(nodeTestRunner, adapter, file);
-   await mf.dispose();
-});

app/src/adapter/cloudflare/storage/StorageR2Adapter.vitest.ts

@@ -0,0 +1,32 @@
+import { readFileSync } from "node:fs";
+import { Miniflare } from "miniflare";
+import { StorageR2Adapter } from "./StorageR2Adapter";
+import { adapterTestSuite } from "media/storage/adapters/adapter-test-suite";
+import path from "node:path";
+import { describe, afterAll, test, expect } from "vitest";
+import { viTestRunner } from "adapter/node/vitest";
+
+let mf: Miniflare | undefined;
+describe("StorageR2Adapter", async () => {
+   mf = new Miniflare({
+      modules: true,
+      script: "export default { async fetch() { return new Response(null); } }",
+      r2Buckets: ["BUCKET"],
+   });
+   const bucket = (await mf?.getR2Bucket("BUCKET")) as unknown as R2Bucket;
+
+   test("test", () => {
+      expect(bucket).toBeDefined();
+   });
+   const adapter = new StorageR2Adapter(bucket);
+
+   const basePath = path.resolve(import.meta.dirname, "../../../../__test__/_assets");
+   const buffer = readFileSync(path.join(basePath, "image.png"));
+   const file = new File([buffer], "image.png", { type: "image/png" });
+
+   await adapterTestSuite(viTestRunner, adapter, file);
+});
+
+afterAll(async () => {
+   await mf?.dispose();
+});

app/src/adapter/cloudflare/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineWorkersConfig } from "@cloudflare/vitest-pool-workers/config";
+
+export default defineWorkersConfig({
+   test: {
+      poolOptions: {
+         workers: {
+            miniflare: {
+               compatibilityDate: "2025-06-04",
+            },
+         },
+      },
+      include: ["**/*.vi-test.ts", "**/*.vitest.ts"],
+   },
+});

app/src/adapter/index.ts

@@ -1,7 +1,8 @@
 import { App, type CreateAppConfig } from "bknd";
-import { config as $config } from "bknd/core";
+import { config as $config, $console } from "bknd/core";
 import type { MiddlewareHandler } from "hono";
 import type { AdminControllerOptions } from "modules/server/AdminController";
+import { Connection } from "bknd/data";
 
 export { Connection } from "bknd/data";
 
@@ -61,7 +62,20 @@ export async function createAdapterApp<Config extends BkndConfig = BkndConfig, A
    const id = opts?.id ?? "app";
    let app = apps.get(id);
    if (!app || opts?.force) {
-      app = App.create(makeConfig(config, args));
+      const appConfig = makeConfig(config, args);
+      if (!appConfig.connection || !Connection.isConnection(appConfig.connection)) {
+         let connection: Connection | undefined;
+         if (Connection.isConnection(config.connection)) {
+            connection = config.connection;
+         } else {
+            const sqlite = (await import("bknd/adapter/sqlite")).sqlite;
+            connection = sqlite(config.connection ?? { url: ":memory:" });
+            $console.info(`Using ${connection.name} connection`);
+         }
+         appConfig.connection = connection;
+      }
+
+      app = App.create(appConfig);
       apps.set(id, app);
    }
    return app;

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

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

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

@@ -1,16 +1,10 @@
 import path from "node:path";
 import { serve as honoServe } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { registerLocalMediaAdapter } from "adapter/node/index";
-import {
-   type RuntimeBkndConfig,
-   createRuntimeApp,
-   type RuntimeOptions,
-   Connection,
-} from "bknd/adapter";
+import { registerLocalMediaAdapter } from "adapter/node/storage";
+import { type RuntimeBkndConfig, createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
 import { config as $config } from "bknd/core";
 import { $console } from "core";
-import { sqlite } from "bknd/adapter/sqlite";
 import type { App } from "App";
 
 type NodeEnv = NodeJS.ProcessEnv;
@@ -35,18 +29,10 @@ export async function createApp<Env = NodeEnv>(
       console.warn("relativeDistPath is deprecated, please use distPath instead");
    }
 
-   let connection: Connection | undefined;
-   if (Connection.isConnection(config.connection)) {
-      connection = config.connection;
-   } else {
-      connection = sqlite(config.connection ?? { url: ":memory:" });
-   }
-
    registerLocalMediaAdapter();
    return await createRuntimeApp(
       {
          ...config,
-         connection,
          serveStatic: serveStatic({ root }),
       },
       // @ts-ignore

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

@@ -1,5 +1,5 @@
-import { describe } from "node:test";
-import { nodeTestRunner } from "adapter/node/test";
+import { describe } from "vitest";
+import { viTestRunner } from "adapter/node/vitest";
 import { StorageLocalAdapter } from "adapter/node";
 import { adapterTestSuite } from "media/storage/adapters/adapter-test-suite";
 import { readFileSync } from "node:fs";
@@ -14,5 +14,5 @@ describe("StorageLocalAdapter (node)", async () => {
       path: path.join(basePath, "tmp"),
    });
 
-   await adapterTestSuite(nodeTestRunner, adapter, file);
+   await adapterTestSuite(viTestRunner, adapter, file);
 });

app/src/adapter/sqlite/bun.ts

@@ -1,8 +1,6 @@
 import type { Connection } from "bknd/data";
-import { $console } from "bknd/core";
 import { bunSqlite } from "../bun/connection/BunSqliteConnection";
 
 export function sqlite(config: { url: string }): Connection {
-   $console.info("Using bun-sqlite", config);
    return bunSqlite(config);
 }

app/src/adapter/sqlite/edge.ts

@@ -1,8 +1,6 @@
-import { $console } from "bknd/core";
 import type { Connection } from "bknd/data";
 import { libsql } from "../../data/connection/sqlite/LibsqlConnection";
 
 export function sqlite(config: { url: string }): Connection {
-   $console.info("Using libsql", config);
    return libsql(config);
 }

app/src/adapter/sqlite/node.ts

@@ -1,8 +1,6 @@
-import { $console } from "bknd/core";
 import type { Connection } from "bknd/data";
 import { nodeSqlite } from "../node/connection/NodeSqliteConnection";
 
 export function sqlite(config: { url: string }): Connection {
-   $console.info("Using node-sqlite", config);
    return nodeSqlite(config);
 }

app/src/core/test/utils.ts

@@ -0,0 +1,12 @@
+import { createApp as createAppInternal, type CreateAppConfig } from "App";
+import { bunSqlite } from "adapter/bun/connection/BunSqliteConnection";
+import { Connection } from "data/connection/Connection";
+
+export { App } from "App";
+
+export function createApp({ connection, ...config }: CreateAppConfig = {}) {
+   return createAppInternal({
+      ...config,
+      connection: Connection.isConnection(connection) ? connection : bunSqlite(connection as any),
+   });
+}

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

@@ -8,12 +8,14 @@ import {
    GenericSqliteDialect,
 } from "kysely-generic-sqlite";
 import { SqliteConnection } from "./SqliteConnection";
+import type { Features } from "../Connection";
 
 export type GenericSqliteConnectionConfig = {
    name: string;
    additionalPlugins?: KyselyPlugin[];
    excludeTables?: string[];
    onCreateConnection?: OnCreateConnection;
+   supports?: Partial<Features>;
 };
 
 export { parseBigInt, buildQueryFn, GenericSqliteDialect, type IGenericSqlite };
@@ -33,5 +35,15 @@ export class GenericSqliteConnection<DB = unknown> extends SqliteConnection<DB>
          excludeTables: config?.excludeTables,
       });
       this.client = db;
+      if (config?.name) {
+         this.name = config.name;
+      }
+      if (config?.supports) {
+         for (const [key, value] of Object.entries(config.supports)) {
+            if (value) {
+               this.supported[key] = value;
+            }
+         }
+      }
    }
 }

app/src/data/connection/sqlite/LibsqlConnection.spec.ts

@@ -2,10 +2,11 @@ import { connectionTestSuite } from "../connection-test-suite";
 import { LibsqlConnection } from "./LibsqlConnection";
 import { bunTestRunner } from "adapter/bun/test";
 import { describe } from "bun:test";
+import { createClient } from "@libsql/client";
 
 describe("LibsqlConnection", () => {
    connectionTestSuite(bunTestRunner, {
-      makeConnection: () => new LibsqlConnection({ url: ":memory:" }),
+      makeConnection: () => new LibsqlConnection(createClient({ url: ":memory:" })),
       rawDialectDetails: ["rowsAffected", "lastInsertRowid"],
    });
 });

app/src/modules/ModuleManager.ts

@@ -11,16 +11,9 @@ import {
    stripMark,
    transformObject,
 } from "core/utils";
-import {
-   type Connection,
-   EntityManager,
-   type Schema,
-   datetime,
-   entity,
-   enumm,
-   jsonSchema,
-   number,
-} from "data";
+import type { Connection, Schema } from "data";
+import { EntityManager } from "data/entities/EntityManager";
+import * as proto from "data/prototype";
 import { TransformPersistFailedException } from "data/errors";
 import { Hono } from "hono";
 import type { Kysely } from "kysely";
@@ -116,12 +109,12 @@ const configJsonSchema = Type.Union([
       }),
    ),
 ]);
-export const __bknd = entity(TABLE_NAME, {
-   version: number().required(),
-   type: enumm({ enum: ["config", "diff", "backup"] }).required(),
-   json: jsonSchema({ schema: configJsonSchema }).required(),
-   created_at: datetime(),
-   updated_at: datetime(),
+export const __bknd = proto.entity(TABLE_NAME, {
+   version: proto.number().required(),
+   type: proto.enumm({ enum: ["config", "diff", "backup"] }).required(),
+   json: proto.jsonSchema({ schema: configJsonSchema }).required(),
+   created_at: proto.datetime(),
+   updated_at: proto.datetime(),
 });
 type ConfigTable2 = Schema<typeof __bknd>;
 interface T_INTERNAL_EM {

app/vitest.config.ts

@@ -1,18 +1,26 @@
 import { defineConfig } from "vitest/config";
 import react from "@vitejs/plugin-react";
 import tsconfigPaths from "vite-tsconfig-paths";
-
+import path from "node:path";
 export default defineConfig({
-   plugins: [react(), tsconfigPaths()],
+   plugins: [tsconfigPaths()],
    test: {
-      globals: true,
-      environment: "jsdom",
-      setupFiles: ["./__test__/vitest/setup.ts"],
+      projects: ["**/*.vitest.config.ts"],
       include: ["**/*.vi-test.ts", "**/*.vitest.ts"],
-      coverage: {
-         provider: "v8",
-         reporter: ["text", "json", "html"],
-         exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts", "**/*.config.ts"],
-      },
    },
 });
+
+// export defineConfig({
+//    plugins: [tsconfigPaths()],
+//    test: {
+//       globals: true,
+//       environment: "jsdom",
+//       setupFiles: ["./__test__/vitest/setup.ts"],
+//       include: ["**/*.vi-test.ts", "**/*.vitest.ts"],
+//       coverage: {
+//          provider: "v8",
+//          reporter: ["text", "json", "html"],
+//          exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts", "**/*.config.ts"],
+//       },
+//    },
+// });