@fragno-dev/corpus 0.0.6 → 0.0.7

package/dist/subjects/database-querying.md

@@ -7,7 +7,7 @@ CRUD operations and querying with conditions.
 import { defineFragment, instantiate } from "@fragno-dev/core";
 import { withDatabase } from "@fragno-dev/db";
 import { schema, idColumn, column } from "@fragno-dev/db/schema";
-import type { AbstractQuery } from "@fragno-dev/db/query";
+import type { SimpleQueryInterface } from "@fragno-dev/db/query";
 import { buildDatabaseFragmentsTest } from "@fragno-dev/test";
 ```
 
@@ -39,7 +39,7 @@ type UserSchema = typeof userSchema;
 
 ```typescript @fragno-test-init
 // Create a test fragment with database
-const testFragmentDef = defineFragment<{}>("test-db-fragment")
+const testFragmentDef = defineFragment<{}>("test-fragment")
   .extend(withDatabase(userSchema))
   .providesBaseService(() => ({}))
   .build();

package/dist/subjects/drizzle-adapter.md

@@ -7,54 +7,3 @@ import { DrizzleAdapter } from "@fragno-dev/db/adapters/drizzle";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type { PgliteDatabase } from "drizzle-orm/pglite";
 ```
-
-## Basic Setup
-
-Create a DrizzleAdapter with your Drizzle database instance and provider.
-
-```typescript @fragno-test:basic-setup types-only
-interface MyDatabase extends Record<string, unknown> {
-  users: {
-    id: string;
-    email: string;
-    name: string;
-  };
-  posts: {
-    id: string;
-    title: string;
-    content: string;
-    authorId: string;
-  };
-}
-
-declare const db: NodePgDatabase<MyDatabase>;
-
-export const adapter = new DrizzleAdapter({
-  db,
-  provider: "postgresql",
-});
-```
-
-The adapter requires your Drizzle instance and the database provider (`"postgresql"`, `"mysql"`, or
-`"sqlite"`).
-
-## Factory Function
-
-For async or sync database initialization, pass a factory function instead of a direct instance.
-
-```typescript @fragno-test:factory-function types-only
-import type { PgliteDatabase } from "drizzle-orm/pglite";
-
-async function createDatabase(): Promise<PgliteDatabase> {
-  // Async initialization logic
-  const db = {} as PgliteDatabase;
-  return db;
-}
-
-export const adapter = new DrizzleAdapter({
-  db: createDatabase,
-  provider: "postgresql",
-});
-```
-
-Factory functions can also be synchronous for lazy initialization scenarios.

package/dist/subjects/kysely-adapter.md

@@ -4,56 +4,54 @@ The KyselyAdapter connects Fragno's database API to your Kysely database instanc
 
 ```typescript @fragno-imports
 import { KyselyAdapter } from "@fragno-dev/db/adapters/kysely";
-import { Kysely } from "kysely";
-import type { Dialect } from "kysely";
+import {
+  PGLiteDriverConfig,
+  SQLocalDriverConfig,
+  BetterSQLite3DriverConfig,
+} from "@fragno-dev/db/drivers";
+import { SqliteDialect, PostgresDialect, MysqlDialect } from "@fragno-dev/db/dialects";
+import type { Dialect } from "@fragno-dev/db/sql-driver";
+import SQLite from "better-sqlite3";
+import { KyselyPGlite } from "kysely-pglite";
 ```
 
 ## Basic Setup
 
-Create a KyselyAdapter with your Kysely database instance and provider.
+Create a KyselyAdapter with your Kysely dialect and driver configuration.
 
 ```typescript @fragno-test:basic-setup types-only
-interface MyDatabase {
-  users: {
-    id: string;
-    email: string;
-    name: string;
-  };
-  posts: {
-    id: string;
-    title: string;
-    content: string;
-    authorId: string;
-  };
-}
-
-declare const dialect: Dialect;
-
-export const db = new Kysely<MyDatabase>({
-  dialect,
+const dialect = new SqliteDialect({
+  database: new SQLite(":memory:"),
 });
 
 export const adapter = new KyselyAdapter({
-  db,
-  provider: "postgresql",
+  dialect,
+  driverConfig: new BetterSQLite3DriverConfig(),
 });
 ```
 
-The adapter requires your Kysely instance and the database provider (`"postgresql"`, `"mysql"`, or
-`"sqlite"`).
+The adapter requires:
 
-## Factory Function
+- `dialect`: A Kysely dialect instance for your database
+- `driverConfig`: A driver configuration matching your database type (`PGLiteDriverConfig`,
+  `SQLocalDriverConfig`, or `BetterSQLite3DriverConfig`)
 
-For async database initialization, pass a factory function instead of a direct instance.
+## First Party Kysely Dialects
 
-```typescript @fragno-test:factory-function types-only
-async function createDatabase() {
-  // Async initialization logic
-  return new Kysely({ dialect: {} as Dialect });
-}
+Fragno re-exports the "first party" Kysely dialects for SQLite, PostgreSQL, and MySQL. This means
+you can use these dialects without installing them yourself.
+
+```typescript @fragno-test:first-party-kysely-dialects types-only
+import { SqliteDialect, PostgresDialect, MysqlDialect } from "@fragno-dev/db/dialects";
+```
+
+## PGLite Example
+
+```typescript @fragno-test:postgresql-example types-only
+const { dialect } = await KyselyPGlite.create();
 
 export const adapter = new KyselyAdapter({
-  db: createDatabase,
-  provider: "postgresql",
+  dialect,
+  driverConfig: new PGLiteDriverConfig(),
 });
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fragno-dev/corpus",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -16,14 +16,17 @@
     "dist"
   ],
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/marked-terminal": "^6.1.1",
     "@types/node": "^22",
+    "better-sqlite3": "^12.5.0",
     "drizzle-orm": "^0.44.7",
     "kysely": "^0.28.0",
+    "kysely-pglite": "^0.6.1",
     "zod": "^4.0.5",
-    "@fragno-dev/core": "0.1.9",
-    "@fragno-dev/db": "0.1.15",
-    "@fragno-dev/test": "0.1.13",
+    "@fragno-dev/core": "0.1.11",
+    "@fragno-dev/db": "0.2.0",
+    "@fragno-dev/test": "1.0.0",
     "@fragno-private/typescript-config": "0.0.1",
     "@fragno-private/vitest-config": "0.0.0"
   },