@fragno-dev/test 0.1.1

package/.turbo/turbo-build.log

@@ -0,0 +1,15 @@
+
+> @fragno-dev/test@0.1.1 build /home/runner/work/fragno/fragno/packages/fragno-test
+> tsdown
+
+ℹ tsdown v0.15.10 powered by rolldown v1.0.0-beta.44
+ℹ Using tsdown config: /home/runner/work/fragno/fragno/packages/fragno-test/tsdown.config.ts
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ dist/index.js        1.64 kB │ gzip: 0.67 kB
+ℹ dist/index.js.map    5.90 kB │ gzip: 1.93 kB
+ℹ dist/index.d.ts.map  1.21 kB │ gzip: 0.57 kB
+ℹ dist/index.d.ts      2.29 kB │ gzip: 0.68 kB
+ℹ 4 files, total: 11.04 kB
+✔ Build complete in 11624ms

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @fragno-dev/test
+
+## 0.1.1
+
+### Patch Changes
+
+- 711226d: feat(testing): add `createDatabaseFragmentForTest` in new test package that automatically
+  sets up a Fragment's database and makes it ready for testing
+- Updated dependencies [8b2859c]
+- Updated dependencies [bef9f6c]
+- Updated dependencies [711226d]
+  - @fragno-dev/db@0.1.5
+  - @fragno-dev/core@0.1.3

package/LICENSE.md

@@ -0,0 +1,16 @@
+Copyright 2025 - present "ReJot Nederland B.V.", and individual contributors.
+
+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.

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { Kysely } from "kysely";
+import { CreateFragmentForTestOptions, CreateFragmentForTestOptions as CreateFragmentForTestOptions$1, FragmentForTest, FragmentForTest as FragmentForTest$1, InitRoutesOverrides, RouteHandlerInputOptions, TestResponse, createFragmentForTest } from "@fragno-dev/core/test";
+import { AnySchema } from "@fragno-dev/db/schema";
+import { DatabaseAdapter } from "@fragno-dev/db/adapters";
+import { FragnoPublicConfig } from "@fragno-dev/core/api/fragment-instantiation";
+import { FragmentDefinition } from "@fragno-dev/core/api/fragment-builder";
+
+//#region src/index.d.ts
+
+/**
+ * Options for creating a database fragment for testing
+ */
+interface CreateDatabaseFragmentForTestOptions<TConfig, TDeps, TServices, TAdditionalContext extends Record<string, unknown>, TOptions extends FragnoPublicConfig> extends Omit<CreateFragmentForTestOptions$1<TConfig, TDeps, TServices, TAdditionalContext, TOptions>, "config"> {
+  databasePath?: string;
+  migrateToVersion?: number;
+  config?: TConfig;
+}
+/**
+ * Extended fragment test instance with database adapter and Kysely instance
+ */
+interface DatabaseFragmentForTest<TConfig, TDeps, TServices, TAdditionalContext extends Record<string, unknown>, TOptions extends FragnoPublicConfig> extends FragmentForTest$1<TConfig, TDeps, TServices, TAdditionalContext, TOptions> {
+  kysely: Kysely<any>;
+  adapter: DatabaseAdapter<any>;
+}
+declare function createDatabaseFragmentForTest<const TConfig, const TDeps, const TServices extends Record<string, unknown>, const TAdditionalContext extends Record<string, unknown>, const TOptions extends FragnoPublicConfig, const TSchema extends AnySchema>(fragmentBuilder: {
+  definition: FragmentDefinition<TConfig, TDeps, TServices, TAdditionalContext>;
+  $requiredOptions: TOptions;
+}, options?: CreateDatabaseFragmentForTestOptions<TConfig, TDeps, TServices, TAdditionalContext, TOptions>): Promise<DatabaseFragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions>>;
+//#endregion
+export { CreateDatabaseFragmentForTestOptions, type CreateFragmentForTestOptions, DatabaseFragmentForTest, type FragmentForTest, type InitRoutesOverrides, type RouteHandlerInputOptions, type TestResponse, createDatabaseFragmentForTest, createFragmentForTest };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AA0BA;;AAKmB,UALF,oCAKE,CAAA,OAAA,EAAA,KAAA,EAAA,SAAA,EAAA,2BADU,MACV,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,iBAAA,kBAAA,CAAA,SACT,IADS,CAEf,8BAFe,CAEc,OAFd,EAEuB,KAFvB,EAE8B,SAF9B,EAEyC,kBAFzC,EAE6D,QAF7D,CAAA,EAAA,QAAA,CAAA,CAAA;EAEc,YAAA,CAAA,EAAA,MAAA;EAAS,gBAAA,CAAA,EAAA,MAAA;EAAO,MAAA,CAAA,EAKtC,OALsC;;;;;AADvC,UAYO,uBAZP,CAAA,OAAA,EAAA,KAAA,EAAA,SAAA,EAAA,2BAgBmB,MAhBnB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,iBAiBS,kBAjBT,CAAA,SAkBA,iBAlBA,CAkBgB,OAlBhB,EAkByB,KAlBzB,EAkBgC,SAlBhC,EAkB2C,kBAlB3C,EAkB+D,QAlB/D,CAAA,CAAA;EAAI,MAAA,EAoBJ,MApBI,CAAA,GAAA,CAAA;EAYG,OAAA,EAUN,eAVM,CAAA,GAAuB,CAAA;;AAKrB,iBAQG,6BARH,CAAA,aAAA,EAAA,WAAA,EAAA,wBAWO,MAXP,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,iCAYgB,MAZhB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,uBAaM,kBAbN,EAAA,sBAcK,SAdL,CAAA,CAAA,eAAA,EAAA;EACO,UAAA,EAgBV,kBAhBU,CAgBS,OAhBT,EAgBkB,KAhBlB,EAgByB,SAhBzB,EAgBoC,kBAhBpC,CAAA;EAAS,gBAAA,EAiBb,QAjBa;CAAO,EAAA,OAAA,CAAA,EAmB9B,oCAnB8B,CAoBtC,OApBsC,EAqBtC,KArBsC,EAsBtC,SAtBsC,EAuBtC,kBAvBsC,EAwBtC,QAxBsC,CAAA,CAAA,EA0BvC,OA1BuC,CA0B/B,uBA1B+B,CA0BP,OA1BO,EA0BE,KA1BF,EA0BS,SA1BT,EA0BoB,kBA1BpB,EA0BwC,QA1BxC,CAAA,CAAA"}

package/dist/index.js

@@ -0,0 +1,39 @@
+import { Kysely } from "kysely";
+import { SQLocalKysely } from "sqlocal/kysely";
+import { KyselyAdapter } from "@fragno-dev/db/adapters/kysely";
+import { createFragmentForTest, createFragmentForTest as createFragmentForTest$1 } from "@fragno-dev/core/test";
+
+//#region src/index.ts
+async function createDatabaseFragmentForTest(fragmentBuilder, options) {
+	const { databasePath = ":memory:", migrateToVersion, config, options: fragmentOptions, deps, services, additionalContext } = options ?? {};
+	const { dialect } = new SQLocalKysely(databasePath);
+	const kysely = new Kysely({ dialect });
+	const adapter = new KyselyAdapter({
+		db: kysely,
+		provider: "sqlite"
+	});
+	const fragmentAdditionalContext = fragmentBuilder.definition.additionalContext;
+	const schema = fragmentAdditionalContext?.databaseSchema;
+	const namespace = fragmentAdditionalContext?.databaseNamespace ?? "";
+	if (!schema) throw new Error(`Fragment '${fragmentBuilder.definition.name}' does not have a database schema. Make sure you're using defineFragmentWithDatabase().withDatabase(schema).`);
+	const migrator = adapter.createMigrationEngine(schema, namespace);
+	await (migrateToVersion ? await migrator.prepareMigrationTo(migrateToVersion, { updateSettings: false }) : await migrator.prepareMigration({ updateSettings: false })).execute();
+	return {
+		...createFragmentForTest$1(fragmentBuilder, {
+			config,
+			options: {
+				...fragmentOptions,
+				databaseAdapter: adapter
+			},
+			deps,
+			services,
+			additionalContext
+		}),
+		kysely,
+		adapter
+	};
+}
+
+//#endregion
+export { createDatabaseFragmentForTest, createFragmentForTest };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createFragmentForTest"],"sources":["../src/index.ts"],"sourcesContent":["import { Kysely } from \"kysely\";\nimport { SQLocalKysely } from \"sqlocal/kysely\";\nimport { KyselyAdapter } from \"@fragno-dev/db/adapters/kysely\";\nimport type { AnySchema } from \"@fragno-dev/db/schema\";\nimport type { DatabaseAdapter } from \"@fragno-dev/db/adapters\";\nimport {\n  createFragmentForTest,\n  type FragmentForTest,\n  type CreateFragmentForTestOptions,\n} from \"@fragno-dev/core/test\";\nimport type { FragnoPublicConfig } from \"@fragno-dev/core/api/fragment-instantiation\";\nimport type { FragmentDefinition } from \"@fragno-dev/core/api/fragment-builder\";\n\n// Re-export utilities from @fragno-dev/core/test\nexport {\n  createFragmentForTest,\n  type TestResponse,\n  type CreateFragmentForTestOptions,\n  type RouteHandlerInputOptions,\n  type FragmentForTest,\n  type InitRoutesOverrides,\n} from \"@fragno-dev/core/test\";\n\n/**\n * Options for creating a database fragment for testing\n */\nexport interface CreateDatabaseFragmentForTestOptions<\n  TConfig,\n  TDeps,\n  TServices,\n  TAdditionalContext extends Record<string, unknown>,\n  TOptions extends FragnoPublicConfig,\n> extends Omit<\n    CreateFragmentForTestOptions<TConfig, TDeps, TServices, TAdditionalContext, TOptions>,\n    \"config\"\n  > {\n  databasePath?: string;\n  migrateToVersion?: number;\n  config?: TConfig;\n}\n\n/**\n * Extended fragment test instance with database adapter and Kysely instance\n */\nexport interface DatabaseFragmentForTest<\n  TConfig,\n  TDeps,\n  TServices,\n  TAdditionalContext extends Record<string, unknown>,\n  TOptions extends FragnoPublicConfig,\n> extends FragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  kysely: Kysely<any>;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  adapter: DatabaseAdapter<any>;\n}\n\nexport async function createDatabaseFragmentForTest<\n  const TConfig,\n  const TDeps,\n  const TServices extends Record<string, unknown>,\n  const TAdditionalContext extends Record<string, unknown>,\n  const TOptions extends FragnoPublicConfig,\n  const TSchema extends AnySchema,\n>(\n  fragmentBuilder: {\n    definition: FragmentDefinition<TConfig, TDeps, TServices, TAdditionalContext>;\n    $requiredOptions: TOptions;\n  },\n  options?: CreateDatabaseFragmentForTestOptions<\n    TConfig,\n    TDeps,\n    TServices,\n    TAdditionalContext,\n    TOptions\n  >,\n): Promise<DatabaseFragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions>> {\n  const {\n    databasePath = \":memory:\",\n    migrateToVersion,\n    config,\n    options: fragmentOptions,\n    deps,\n    services,\n    additionalContext,\n  } = options ?? {};\n\n  // Create SQLocalKysely instance\n  const { dialect } = new SQLocalKysely(databasePath);\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const kysely = new Kysely<any>({\n    dialect,\n  });\n\n  // Create KyselyAdapter\n  const adapter = new KyselyAdapter({\n    db: kysely,\n    provider: \"sqlite\",\n  });\n\n  // Get schema and namespace from fragment definition's additionalContext\n  // Safe cast: DatabaseFragmentBuilder adds databaseSchema and databaseNamespace to additionalContext\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const fragmentAdditionalContext = fragmentBuilder.definition.additionalContext as any;\n  const schema = fragmentAdditionalContext?.databaseSchema as TSchema | undefined;\n  const namespace = (fragmentAdditionalContext?.databaseNamespace as string | undefined) ?? \"\";\n\n  if (!schema) {\n    throw new Error(\n      `Fragment '${fragmentBuilder.definition.name}' does not have a database schema. ` +\n        `Make sure you're using defineFragmentWithDatabase().withDatabase(schema).`,\n    );\n  }\n\n  // Run migrations automatically\n  const migrator = adapter.createMigrationEngine(schema, namespace);\n  const preparedMigration = migrateToVersion\n    ? await migrator.prepareMigrationTo(migrateToVersion, {\n        updateSettings: false,\n      })\n    : await migrator.prepareMigration({\n        updateSettings: false,\n      });\n  await preparedMigration.execute();\n\n  // Create fragment with database adapter in options\n  // Safe cast: We're merging the user's options with the databaseAdapter, which is required by TOptions\n  // The user's TOptions is constrained to FragnoPublicConfig (or a subtype), which we extend with databaseAdapter\n  const mergedOptions = {\n    ...fragmentOptions,\n    databaseAdapter: adapter,\n  } as unknown as TOptions;\n\n  // Safe cast: If config is not provided, we pass undefined as TConfig.\n  // The base createFragmentForTest expects config: TConfig, but if TConfig allows undefined\n  // or if the fragment doesn't use config in its dependencies function, this will work correctly.\n  const fragment = createFragmentForTest(fragmentBuilder, {\n    config: config as TConfig,\n    options: mergedOptions,\n    deps,\n    services,\n    additionalContext,\n  });\n\n  return {\n    ...fragment,\n    kysely,\n    adapter,\n  };\n}\n"],"mappings":";;;;;;AAyDA,eAAsB,8BAQpB,iBAIA,SAO2F;CAC3F,MAAM,EACJ,eAAe,YACf,kBACA,QACA,SAAS,iBACT,MACA,UACA,sBACE,WAAW,EAAE;CAGjB,MAAM,EAAE,YAAY,IAAI,cAAc,aAAa;CAEnD,MAAM,SAAS,IAAI,OAAY,EAC7B,SACD,CAAC;CAGF,MAAM,UAAU,IAAI,cAAc;EAChC,IAAI;EACJ,UAAU;EACX,CAAC;CAKF,MAAM,4BAA4B,gBAAgB,WAAW;CAC7D,MAAM,SAAS,2BAA2B;CAC1C,MAAM,YAAa,2BAA2B,qBAA4C;AAE1F,KAAI,CAAC,OACH,OAAM,IAAI,MACR,aAAa,gBAAgB,WAAW,KAAK,8GAE9C;CAIH,MAAM,WAAW,QAAQ,sBAAsB,QAAQ,UAAU;AAQjE,QAP0B,mBACtB,MAAM,SAAS,mBAAmB,kBAAkB,EAClD,gBAAgB,OACjB,CAAC,GACF,MAAM,SAAS,iBAAiB,EAC9B,gBAAgB,OACjB,CAAC,EACkB,SAAS;AAqBjC,QAAO;EACL,GATeA,wBAAsB,iBAAiB;GAC9C;GACR,SAVoB;IACpB,GAAG;IACH,iBAAiB;IAClB;GAQC;GACA;GACA;GACD,CAAC;EAIA;EACA;EACD"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@fragno-dev/test",
+  "version": "0.1.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "kysely": "^0.28.7",
+    "sqlocal": "^0.15.2",
+    "@fragno-dev/core": "0.1.3",
+    "@fragno-dev/db": "0.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "vitest": "^3.2.4",
+    "zod": "^4.1.12",
+    "@fragno-private/vitest-config": "0.0.0",
+    "@fragno-private/typescript-config": "0.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rejot-dev/fragno.git",
+    "directory": "packages/fragno-test"
+  },
+  "homepage": "https://fragno.dev",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "types:check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest --watch"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,263 @@
+import { describe, expect, it, afterEach } from "vitest";
+import { column, idColumn, schema } from "@fragno-dev/db/schema";
+import { defineFragmentWithDatabase } from "@fragno-dev/db/fragment";
+import { createDatabaseFragmentForTest } from "./index";
+import { unlinkSync, existsSync } from "node:fs";
+
+// Test schema with multiple versions
+const testSchema = schema((s) => {
+  return s
+    .addTable("users", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("name", column("string"))
+        .addColumn("email", column("string"))
+        .createIndex("idx_users_all", ["id"]); // Index for querying
+    })
+    .alterTable("users", (t) => {
+      return t.addColumn("age", column("integer").nullable());
+    });
+});
+
+// Test fragment definition
+const testFragmentDef = defineFragmentWithDatabase<{}>("test-fragment")
+  .withDatabase(testSchema)
+  .withServices(({ orm }) => {
+    return {
+      createUser: async (data: { name: string; email: string; age?: number | null }) => {
+        const id = await orm.create("users", data);
+        return { ...data, id: id.valueOf() };
+      },
+      getUsers: async () => {
+        const users = await orm.find("users", (b) =>
+          b.whereIndex("idx_users_all", (eb) => eb("id", "!=", "")),
+        );
+        return users.map((u) => ({ ...u, id: u.id.valueOf() }));
+      },
+    };
+  });
+
+describe("createDatabaseFragmentForTest", () => {
+  describe("databasePath option", () => {
+    const testDbPath = "./test-fragno.pglite";
+
+    afterEach(() => {
+      // Clean up test database files
+      if (existsSync(testDbPath)) {
+        try {
+          unlinkSync(testDbPath);
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+
+    it("should use in-memory database by default", async () => {
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef);
+
+      // Should be able to create and query users
+      const user = await fragment.services.createUser({
+        name: "Test User",
+        email: "test@example.com",
+        age: 25,
+      });
+
+      expect(user).toMatchObject({
+        id: expect.any(String),
+        name: "Test User",
+        email: "test@example.com",
+        age: 25,
+      });
+
+      const users = await fragment.services.getUsers();
+      expect(users).toHaveLength(1);
+      expect(users[0]).toMatchObject(user);
+    });
+
+    it("should create database at specified path", async () => {
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef, {
+        databasePath: testDbPath,
+      });
+
+      // Create a user
+      await fragment.services.createUser({
+        name: "Persisted User",
+        email: "persisted@example.com",
+        age: 30,
+      });
+
+      // Verify data exists in this instance
+      const users = await fragment.services.getUsers();
+      expect(users).toHaveLength(1);
+      expect(users[0]).toMatchObject({
+        name: "Persisted User",
+        email: "persisted@example.com",
+        age: 30,
+      });
+    });
+  });
+
+  describe("migrateToVersion option", () => {
+    it("should migrate to latest version by default", async () => {
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef);
+
+      // Should have the 'age' column from version 2
+      const user = await fragment.services.createUser({
+        name: "Test User",
+        email: "test@example.com",
+        age: 25,
+      });
+
+      expect(user).toMatchObject({
+        id: expect.any(String),
+        name: "Test User",
+        email: "test@example.com",
+        age: 25,
+      });
+    });
+
+    it("should migrate to specific version when specified", async () => {
+      // Migrate to version 1 (before 'age' column was added)
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef, {
+        migrateToVersion: 1,
+      });
+
+      // Query the database directly to check schema
+      // In version 1, we should be able to insert without the age column
+      const tableName = "users_test-fragment-db";
+      await fragment.kysely
+        .insertInto(tableName)
+        .values({
+          id: "test-id-1",
+          name: "V1 User",
+          email: "v1@example.com",
+        })
+        .execute();
+
+      const result = await fragment.kysely.selectFrom(tableName).selectAll().execute();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        id: "test-id-1",
+        name: "V1 User",
+        email: "v1@example.com",
+      });
+      // In version 1, the age column should not exist
+      expect(result[0]).not.toHaveProperty("age");
+    });
+
+    it("should allow creating user with age when migrated to version 2", async () => {
+      // Explicitly migrate to version 2
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef, {
+        migrateToVersion: 2,
+      });
+
+      // Should be able to use age column
+      const user = await fragment.services.createUser({
+        name: "V2 User",
+        email: "v2@example.com",
+        age: 35,
+      });
+
+      expect(user).toMatchObject({
+        id: expect.any(String),
+        name: "V2 User",
+        email: "v2@example.com",
+        age: 35,
+      });
+
+      const tableName = "users_test-fragment-db";
+      const result = await fragment.kysely.selectFrom(tableName).selectAll().execute();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        name: "V2 User",
+        email: "v2@example.com",
+        age: 35,
+      });
+    });
+  });
+
+  describe("combined options", () => {
+    const testDbPath = "./test-combined.pglite";
+
+    afterEach(() => {
+      if (existsSync(testDbPath)) {
+        try {
+          unlinkSync(testDbPath);
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    });
+
+    it("should work with both databasePath and migrateToVersion", async () => {
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef, {
+        databasePath: testDbPath,
+        migrateToVersion: 2,
+      });
+
+      // Create user at version 2 (with age support)
+      const user = await fragment.services.createUser({
+        name: "Combined Test",
+        email: "combined@example.com",
+        age: 40,
+      });
+
+      expect(user).toMatchObject({
+        id: expect.any(String),
+        name: "Combined Test",
+        email: "combined@example.com",
+        age: 40,
+      });
+
+      const users = await fragment.services.getUsers();
+      expect(users).toHaveLength(1);
+      expect(users[0]).toMatchObject({
+        name: "Combined Test",
+        email: "combined@example.com",
+        age: 40,
+      });
+    });
+  });
+
+  describe("fragment initialization", () => {
+    it("should provide kysely instance", async () => {
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef);
+
+      expect(fragment.kysely).toBeDefined();
+      expect(typeof fragment.kysely.selectFrom).toBe("function");
+    });
+
+    it("should provide adapter instance", async () => {
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef);
+
+      expect(fragment.adapter).toBeDefined();
+      expect(typeof fragment.adapter.createMigrationEngine).toBe("function");
+    });
+
+    it("should have all standard fragment test properties", async () => {
+      const fragment = await createDatabaseFragmentForTest(testFragmentDef);
+
+      expect(fragment.services).toBeDefined();
+      expect(fragment.initRoutes).toBeDefined();
+      expect(fragment.handler).toBeDefined();
+    });
+
+    it("should throw error for non-database fragment", async () => {
+      // Create a fragment without database
+      const nonDbFragment = {
+        definition: {
+          name: "non-db-fragment",
+          additionalContext: {},
+        },
+        $requiredOptions: {},
+      };
+
+      await expect(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        createDatabaseFragmentForTest(nonDbFragment as any),
+      ).rejects.toThrow("Fragment 'non-db-fragment' does not have a database schema");
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,150 @@
+import { Kysely } from "kysely";
+import { SQLocalKysely } from "sqlocal/kysely";
+import { KyselyAdapter } from "@fragno-dev/db/adapters/kysely";
+import type { AnySchema } from "@fragno-dev/db/schema";
+import type { DatabaseAdapter } from "@fragno-dev/db/adapters";
+import {
+  createFragmentForTest,
+  type FragmentForTest,
+  type CreateFragmentForTestOptions,
+} from "@fragno-dev/core/test";
+import type { FragnoPublicConfig } from "@fragno-dev/core/api/fragment-instantiation";
+import type { FragmentDefinition } from "@fragno-dev/core/api/fragment-builder";
+
+// Re-export utilities from @fragno-dev/core/test
+export {
+  createFragmentForTest,
+  type TestResponse,
+  type CreateFragmentForTestOptions,
+  type RouteHandlerInputOptions,
+  type FragmentForTest,
+  type InitRoutesOverrides,
+} from "@fragno-dev/core/test";
+
+/**
+ * Options for creating a database fragment for testing
+ */
+export interface CreateDatabaseFragmentForTestOptions<
+  TConfig,
+  TDeps,
+  TServices,
+  TAdditionalContext extends Record<string, unknown>,
+  TOptions extends FragnoPublicConfig,
+> extends Omit<
+    CreateFragmentForTestOptions<TConfig, TDeps, TServices, TAdditionalContext, TOptions>,
+    "config"
+  > {
+  databasePath?: string;
+  migrateToVersion?: number;
+  config?: TConfig;
+}
+
+/**
+ * Extended fragment test instance with database adapter and Kysely instance
+ */
+export interface DatabaseFragmentForTest<
+  TConfig,
+  TDeps,
+  TServices,
+  TAdditionalContext extends Record<string, unknown>,
+  TOptions extends FragnoPublicConfig,
+> extends FragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  kysely: Kysely<any>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  adapter: DatabaseAdapter<any>;
+}
+
+export async function createDatabaseFragmentForTest<
+  const TConfig,
+  const TDeps,
+  const TServices extends Record<string, unknown>,
+  const TAdditionalContext extends Record<string, unknown>,
+  const TOptions extends FragnoPublicConfig,
+  const TSchema extends AnySchema,
+>(
+  fragmentBuilder: {
+    definition: FragmentDefinition<TConfig, TDeps, TServices, TAdditionalContext>;
+    $requiredOptions: TOptions;
+  },
+  options?: CreateDatabaseFragmentForTestOptions<
+    TConfig,
+    TDeps,
+    TServices,
+    TAdditionalContext,
+    TOptions
+  >,
+): Promise<DatabaseFragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions>> {
+  const {
+    databasePath = ":memory:",
+    migrateToVersion,
+    config,
+    options: fragmentOptions,
+    deps,
+    services,
+    additionalContext,
+  } = options ?? {};
+
+  // Create SQLocalKysely instance
+  const { dialect } = new SQLocalKysely(databasePath);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const kysely = new Kysely<any>({
+    dialect,
+  });
+
+  // Create KyselyAdapter
+  const adapter = new KyselyAdapter({
+    db: kysely,
+    provider: "sqlite",
+  });
+
+  // Get schema and namespace from fragment definition's additionalContext
+  // Safe cast: DatabaseFragmentBuilder adds databaseSchema and databaseNamespace to additionalContext
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const fragmentAdditionalContext = fragmentBuilder.definition.additionalContext as any;
+  const schema = fragmentAdditionalContext?.databaseSchema as TSchema | undefined;
+  const namespace = (fragmentAdditionalContext?.databaseNamespace as string | undefined) ?? "";
+
+  if (!schema) {
+    throw new Error(
+      `Fragment '${fragmentBuilder.definition.name}' does not have a database schema. ` +
+        `Make sure you're using defineFragmentWithDatabase().withDatabase(schema).`,
+    );
+  }
+
+  // Run migrations automatically
+  const migrator = adapter.createMigrationEngine(schema, namespace);
+  const preparedMigration = migrateToVersion
+    ? await migrator.prepareMigrationTo(migrateToVersion, {
+        updateSettings: false,
+      })
+    : await migrator.prepareMigration({
+        updateSettings: false,
+      });
+  await preparedMigration.execute();
+
+  // Create fragment with database adapter in options
+  // Safe cast: We're merging the user's options with the databaseAdapter, which is required by TOptions
+  // The user's TOptions is constrained to FragnoPublicConfig (or a subtype), which we extend with databaseAdapter
+  const mergedOptions = {
+    ...fragmentOptions,
+    databaseAdapter: adapter,
+  } as unknown as TOptions;
+
+  // Safe cast: If config is not provided, we pass undefined as TConfig.
+  // The base createFragmentForTest expects config: TConfig, but if TConfig allows undefined
+  // or if the fragment doesn't use config in its dependencies function, this will work correctly.
+  const fragment = createFragmentForTest(fragmentBuilder, {
+    config: config as TConfig,
+    options: mergedOptions,
+    deps,
+    services,
+    additionalContext,
+  });
+
+  return {
+    ...fragment,
+    kysely,
+    adapter,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@fragno-private/typescript-config/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    "composite": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsdown.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  dts: true,
+  unbundle: true,
+});

package/vitest.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig, mergeConfig } from "vitest/config";
+import { baseConfig } from "@fragno-private/vitest-config";
+
+export default defineConfig(mergeConfig(baseConfig, {}));